121 files changed, 3172 insertions, 130578 deletions

diff --git a/src/gui/opengl/opengl.pri b/src/gui/opengl/opengl.pri
deleted file mode 100644
index 26060ea5df..0000000000
--- a/src/gui/opengl/opengl.pri
+++ /dev/null
@@ -1,123 +0,0 @@
-# Qt gui library, opengl module
-
-qtConfig(opengl): CONFIG += opengl
-qtConfig(opengles2): CONFIG += opengles2
-
-qtConfig(opengl) {
-
-    HEADERS += opengl/qopengl.h \
-               opengl/qopengl_p.h \
-               opengl/qopenglfunctions.h \
-               opengl/qopenglframebufferobject.h  \
-               opengl/qopenglframebufferobject_p.h  \
-               opengl/qopenglpaintdevice.h \
-               opengl/qopenglpaintdevice_p.h \
-               opengl/qopenglbuffer.h \
-               opengl/qopenglshaderprogram.h \
-               opengl/qopenglextensions_p.h \
-               opengl/qopenglgradientcache_p.h \
-               opengl/qopengltexturecache_p.h \
-               opengl/qopenglengineshadermanager_p.h \
-               opengl/qopengl2pexvertexarray_p.h \
-               opengl/qopenglpaintengine_p.h \
-               opengl/qopenglengineshadersource_p.h \
-               opengl/qopenglcustomshaderstage_p.h \
-               opengl/qopengltextureglyphcache_p.h \
-               opengl/qopenglshadercache_p.h \
-               opengl/qopenglversionfunctions.h \
-               opengl/qopenglversionfunctionsfactory_p.h \
-               opengl/qopenglvertexarrayobject.h \
-               opengl/qopengltextureblitter.h \
-               opengl/qopengltexture.h \
-               opengl/qopengltexture_p.h \
-               opengl/qopengltexturehelper_p.h \
-               opengl/qopengltextureuploader_p.h \
-               opengl/qopenglpixeltransferoptions.h \
-               opengl/qopenglextrafunctions.h \
-               opengl/qopenglprogrambinarycache_p.h
-
-    SOURCES += opengl/qopengl.cpp \
-               opengl/qopenglfunctions.cpp \
-               opengl/qopenglframebufferobject.cpp \
-               opengl/qopenglpaintdevice.cpp \
-               opengl/qopenglbuffer.cpp \
-               opengl/qopenglshaderprogram.cpp \
-               opengl/qopenglgradientcache.cpp \
-               opengl/qopengltexturecache.cpp \
-               opengl/qopenglengineshadermanager.cpp \
-               opengl/qopengl2pexvertexarray.cpp \
-               opengl/qopenglpaintengine.cpp \
-               opengl/qopenglcustomshaderstage.cpp \
-               opengl/qopengltextureglyphcache.cpp \
-               opengl/qopenglversionfunctions.cpp \
-               opengl/qopenglversionfunctionsfactory.cpp \
-               opengl/qopenglvertexarrayobject.cpp \
-               opengl/qopengltextureblitter.cpp \
-               opengl/qopengltexture.cpp \
-               opengl/qopengltexturehelper.cpp \
-               opengl/qopengltextureuploader.cpp \
-               opengl/qopenglpixeltransferoptions.cpp \
-               opengl/qopenglprogrambinarycache.cpp
-
-    !qtConfig(opengles2) {
-        HEADERS += opengl/qopenglfunctions_1_0.h \
-                   opengl/qopenglfunctions_1_1.h \
-                   opengl/qopenglfunctions_1_2.h \
-                   opengl/qopenglfunctions_1_3.h \
-                   opengl/qopenglfunctions_1_4.h \
-                   opengl/qopenglfunctions_1_5.h \
-                   opengl/qopenglfunctions_2_0.h \
-                   opengl/qopenglfunctions_2_1.h \
-                   opengl/qopenglfunctions_3_0.h \
-                   opengl/qopenglfunctions_3_1.h \
-                   opengl/qopenglfunctions_3_2_core.h \
-                   opengl/qopenglfunctions_3_3_core.h \
-                   opengl/qopenglfunctions_4_0_core.h \
-                   opengl/qopenglfunctions_4_1_core.h \
-                   opengl/qopenglfunctions_4_2_core.h \
-                   opengl/qopenglfunctions_4_3_core.h \
-                   opengl/qopenglfunctions_4_4_core.h \
-                   opengl/qopenglfunctions_4_5_core.h \
-                   opengl/qopenglfunctions_3_2_compatibility.h \
-                   opengl/qopenglfunctions_3_3_compatibility.h \
-                   opengl/qopenglfunctions_4_0_compatibility.h \
-                   opengl/qopenglfunctions_4_1_compatibility.h \
-                   opengl/qopenglfunctions_4_2_compatibility.h \
-                   opengl/qopenglfunctions_4_3_compatibility.h \
-                   opengl/qopenglfunctions_4_4_compatibility.h \
-                   opengl/qopenglfunctions_4_5_compatibility.h
-
-        SOURCES += opengl/qopenglfunctions_1_0.cpp \
-                   opengl/qopenglfunctions_1_1.cpp \
-                   opengl/qopenglfunctions_1_2.cpp \
-                   opengl/qopenglfunctions_1_3.cpp \
-                   opengl/qopenglfunctions_1_4.cpp \
-                   opengl/qopenglfunctions_1_5.cpp \
-                   opengl/qopenglfunctions_2_0.cpp \
-                   opengl/qopenglfunctions_2_1.cpp \
-                   opengl/qopenglfunctions_3_0.cpp \
-                   opengl/qopenglfunctions_3_1.cpp \
-                   opengl/qopenglfunctions_3_2_core.cpp \
-                   opengl/qopenglfunctions_3_3_core.cpp \
-                   opengl/qopenglfunctions_4_0_core.cpp \
-                   opengl/qopenglfunctions_4_1_core.cpp \
-                   opengl/qopenglfunctions_4_2_core.cpp \
-                   opengl/qopenglfunctions_4_3_core.cpp \
-                   opengl/qopenglfunctions_4_4_core.cpp \
-                   opengl/qopenglfunctions_4_5_core.cpp \
-                   opengl/qopenglfunctions_3_2_compatibility.cpp \
-                   opengl/qopenglfunctions_3_3_compatibility.cpp \
-                   opengl/qopenglfunctions_4_0_compatibility.cpp \
-                   opengl/qopenglfunctions_4_1_compatibility.cpp \
-                   opengl/qopenglfunctions_4_2_compatibility.cpp \
-                   opengl/qopenglfunctions_4_3_compatibility.cpp \
-                   opengl/qopenglfunctions_4_4_compatibility.cpp \
-                   opengl/qopenglfunctions_4_5_compatibility.cpp
-    }
-
-    qtConfig(opengles2) {
-        HEADERS += opengl/qopenglfunctions_es2.h
-
-        SOURCES += opengl/qopenglfunctions_es2.cpp
-    }
-}
diff --git a/src/gui/opengl/platform/egl/qeglconvenience.cpp b/src/gui/opengl/platform/egl/qeglconvenience.cpp
new file mode 100644
index 0000000000..4af50d72f2
--- /dev/null
+++ b/src/gui/opengl/platform/egl/qeglconvenience.cpp
@@ -0,0 +1,596 @@
+// Copyright (C) 2020 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+
+#include <QtCore/qbytearray.h>
+#include <QtGui/qopenglcontext.h>
+
+#ifdef Q_OS_LINUX
+#include <sys/ioctl.h>
+#include <linux/fb.h>
+#endif
+#include <QtGui/private/qmath_p.h>
+
+#include "qeglconvenience_p.h"
+
+#ifndef EGL_OPENGL_ES3_BIT_KHR
+#define EGL_OPENGL_ES3_BIT_KHR 0x0040
+#endif
+
+QT_BEGIN_NAMESPACE
+
+QList<EGLint> q_createConfigAttributesFromFormat(const QSurfaceFormat &format)
+{
+    int redSize     = format.redBufferSize();
+    int greenSize   = format.greenBufferSize();
+    int blueSize    = format.blueBufferSize();
+    int alphaSize   = format.alphaBufferSize();
+    int depthSize   = format.depthBufferSize();
+    int stencilSize = format.stencilBufferSize();
+    int sampleCount = format.samples();
+
+    QList<EGLint> configAttributes;
+
+    // Map default, unspecified values (-1) to 0. This is important due to sorting rule #3
+    // in section 3.4.1 of the spec and allows picking a potentially faster 16-bit config
+    // over 32-bit ones when there is no explicit request for the color channel sizes:
+    //
+    // The red/green/blue sizes have a sort priority of 3, so they are sorted by
+    // first. (unless a caveat like SLOW or NON_CONFORMANT is present) The sort order is
+    // Special and described as "by larger _total_ number of color bits.". So EGL will put
+    // 32-bit configs in the list before the 16-bit configs. However, the spec also goes
+    // on to say "If the requested number of bits in attrib_list for a particular
+    // component is 0, then the number of bits for that component is not considered". This
+    // part of the spec also seems to imply that setting the red/green/blue bits to zero
+    // means none of the components are considered and EGL disregards the entire sorting
+    // rule. It then looks to the next highest priority rule, which is
+    // EGL_BUFFER_SIZE. Despite the selection criteria being "AtLeast" for
+    // EGL_BUFFER_SIZE, it's sort order is "smaller" meaning 16-bit configs are put in the
+    // list before 32-bit configs.
+    //
+    // This also means that explicitly specifying a size like 565 will still result in
+    // having larger (888) configs first in the returned list. We need to handle this
+    // ourselves later by manually filtering the list, instead of just blindly taking the
+    // first config from it.
+
+    configAttributes.append(EGL_RED_SIZE);
+    configAttributes.append(redSize > 0 ? redSize : 0);
+
+    configAttributes.append(EGL_GREEN_SIZE);
+    configAttributes.append(greenSize > 0 ? greenSize : 0);
+
+    configAttributes.append(EGL_BLUE_SIZE);
+    configAttributes.append(blueSize > 0 ? blueSize : 0);
+
+    configAttributes.append(EGL_ALPHA_SIZE);
+    configAttributes.append(alphaSize > 0 ? alphaSize : 0);
+
+    configAttributes.append(EGL_SAMPLES);
+    configAttributes.append(sampleCount > 0 ? sampleCount : 0);
+
+    configAttributes.append(EGL_SAMPLE_BUFFERS);
+    configAttributes.append(sampleCount > 0);
+
+    if (format.renderableType() != QSurfaceFormat::OpenVG) {
+        configAttributes.append(EGL_DEPTH_SIZE);
+        configAttributes.append(depthSize > 0 ? depthSize : 0);
+
+        configAttributes.append(EGL_STENCIL_SIZE);
+        configAttributes.append(stencilSize > 0 ? stencilSize : 0);
+    } else {
+        // OpenVG needs alpha mask for clipping
+        configAttributes.append(EGL_ALPHA_MASK_SIZE);
+        configAttributes.append(8);
+    }
+
+    return configAttributes;
+}
+
+bool q_reduceConfigAttributes(QList<EGLint> *configAttributes)
+{
+    // Reduce the complexity of a configuration request to ask for less
+    // because the previous request did not result in success.  Returns
+    // true if the complexity was reduced, or false if no further
+    // reductions in complexity are possible.
+
+    qsizetype i = configAttributes->indexOf(EGL_SWAP_BEHAVIOR);
+    if (i >= 0) {
+        configAttributes->remove(i,2);
+    }
+
+#ifdef EGL_VG_ALPHA_FORMAT_PRE_BIT
+    // For OpenVG, we sometimes try to create a surface using a pre-multiplied format. If we can't
+    // find a config which supports pre-multiplied formats, remove the flag on the surface type:
+
+    i = configAttributes->indexOf(EGL_SURFACE_TYPE);
+    if (i >= 0) {
+        EGLint surfaceType = configAttributes->at(i +1);
+        if (surfaceType & EGL_VG_ALPHA_FORMAT_PRE_BIT) {
+            surfaceType ^= EGL_VG_ALPHA_FORMAT_PRE_BIT;
+            configAttributes->replace(i+1,surfaceType);
+            return true;
+        }
+    }
+#endif
+
+    // EGL chooses configs with the highest color depth over
+    // those with smaller (but faster) lower color depths. One
+    // way around this is to set EGL_BUFFER_SIZE to 16, which
+    // trumps the others. Of course, there may not be a 16-bit
+    // config available, so it's the first restraint we remove.
+    i = configAttributes->indexOf(EGL_BUFFER_SIZE);
+    if (i >= 0) {
+        if (configAttributes->at(i+1) == 16) {
+            configAttributes->remove(i,2);
+            return true;
+        }
+    }
+
+    i = configAttributes->indexOf(EGL_SAMPLES);
+    if (i >= 0) {
+        EGLint value = configAttributes->value(i+1, 0);
+        if (value > 1)
+            configAttributes->replace(i+1, qMin(EGLint(16), value / 2));
+        else
+            configAttributes->remove(i, 2);
+        return true;
+    }
+
+    i = configAttributes->indexOf(EGL_SAMPLE_BUFFERS);
+    if (i >= 0) {
+        configAttributes->remove(i,2);
+        return true;
+    }
+
+    i = configAttributes->indexOf(EGL_DEPTH_SIZE);
+    if (i >= 0) {
+        if (configAttributes->at(i + 1) >= 32)
+            configAttributes->replace(i + 1, 24);
+        else if (configAttributes->at(i + 1) > 1)
+            configAttributes->replace(i + 1, 1);
+        else
+            configAttributes->remove(i, 2);
+        return true;
+    }
+
+    i = configAttributes->indexOf(EGL_ALPHA_SIZE);
+    if (i >= 0) {
+        configAttributes->remove(i,2);
+#if defined(EGL_BIND_TO_TEXTURE_RGBA) && defined(EGL_BIND_TO_TEXTURE_RGB)
+        i = configAttributes->indexOf(EGL_BIND_TO_TEXTURE_RGBA);
+        if (i >= 0) {
+            configAttributes->replace(i,EGL_BIND_TO_TEXTURE_RGB);
+            configAttributes->replace(i+1,true);
+
+        }
+#endif
+        return true;
+    }
+
+    i = configAttributes->indexOf(EGL_STENCIL_SIZE);
+    if (i >= 0) {
+        if (configAttributes->at(i + 1) > 1)
+            configAttributes->replace(i + 1, 1);
+        else
+            configAttributes->remove(i, 2);
+        return true;
+    }
+
+#ifdef EGL_BIND_TO_TEXTURE_RGB
+    i = configAttributes->indexOf(EGL_BIND_TO_TEXTURE_RGB);
+    if (i >= 0) {
+        configAttributes->remove(i,2);
+        return true;
+    }
+#endif
+
+    return false;
+}
+
+QEglConfigChooser::QEglConfigChooser(EGLDisplay display)
+    : m_display(display)
+    , m_surfaceType(EGL_WINDOW_BIT)
+    , m_ignore(false)
+    , m_confAttrRed(0)
+    , m_confAttrGreen(0)
+    , m_confAttrBlue(0)
+    , m_confAttrAlpha(0)
+{
+}
+
+QEglConfigChooser::~QEglConfigChooser()
+{
+}
+
+EGLConfig QEglConfigChooser::chooseConfig()
+{
+    QList<EGLint> configureAttributes = q_createConfigAttributesFromFormat(m_format);
+    configureAttributes.append(EGL_SURFACE_TYPE);
+    configureAttributes.append(surfaceType());
+
+    configureAttributes.append(EGL_RENDERABLE_TYPE);
+    bool needsES2Plus = false;
+    switch (m_format.renderableType()) {
+    case QSurfaceFormat::OpenVG:
+        configureAttributes.append(EGL_OPENVG_BIT);
+        break;
+#ifdef EGL_VERSION_1_4
+    case QSurfaceFormat::DefaultRenderableType: {
+#ifndef QT_NO_OPENGL
+        // NVIDIA EGL only provides desktop GL for development purposes, and recommends against using it.
+        const char *vendor = eglQueryString(display(), EGL_VENDOR);
+        if (QOpenGLContext::openGLModuleType() == QOpenGLContext::LibGL && (!vendor || !strstr(vendor, "NVIDIA")))
+            configureAttributes.append(EGL_OPENGL_BIT);
+        else
+#endif // QT_NO_OPENGL
+            needsES2Plus = true;
+        break;
+    }
+    case QSurfaceFormat::OpenGL:
+         configureAttributes.append(EGL_OPENGL_BIT);
+         break;
+#endif
+    case QSurfaceFormat::OpenGLES:
+        if (m_format.majorVersion() == 1) {
+            configureAttributes.append(EGL_OPENGL_ES_BIT);
+            break;
+        }
+        Q_FALLTHROUGH();
+    default:
+        needsES2Plus = true;
+        break;
+    }
+    if (needsES2Plus) {
+        if (m_format.majorVersion() >= 3 && q_hasEglExtension(display(), "EGL_KHR_create_context"))
+            configureAttributes.append(EGL_OPENGL_ES3_BIT_KHR);
+        else
+            configureAttributes.append(EGL_OPENGL_ES2_BIT);
+    }
+    configureAttributes.append(EGL_NONE);
+
+    EGLConfig cfg = nullptr;
+    do {
+        // Get the number of matching configurations for this set of properties.
+        EGLint matching = 0;
+        if (!eglChooseConfig(display(), configureAttributes.constData(), nullptr, 0, &matching) || !matching)
+            continue;
+
+        // Fetch all of the matching configurations and find the
+        // first that matches the pixel format we wanted.
+        qsizetype i = configureAttributes.indexOf(EGL_RED_SIZE);
+        m_confAttrRed = configureAttributes.at(i+1);
+        i = configureAttributes.indexOf(EGL_GREEN_SIZE);
+        m_confAttrGreen = configureAttributes.at(i+1);
+        i = configureAttributes.indexOf(EGL_BLUE_SIZE);
+        m_confAttrBlue = configureAttributes.at(i+1);
+        i = configureAttributes.indexOf(EGL_ALPHA_SIZE);
+        m_confAttrAlpha = i == -1 ? 0 : configureAttributes.at(i+1);
+
+        QList<EGLConfig> configs(matching);
+        eglChooseConfig(display(), configureAttributes.constData(), configs.data(),
+                        EGLint(configs.size()), &matching);
+        if (!cfg && matching > 0)
+            cfg = configs.first();
+
+        // Filter the list. Due to the EGL sorting rules configs with higher depth are
+        // placed first when the minimum color channel sizes have been specified (i.e. the
+        // QSurfaceFormat contains color sizes > 0). To prevent returning a 888 config
+        // when the QSurfaceFormat explicitly asked for 565, go through the returned
+        // configs and look for one that exactly matches the requested sizes. When no
+        // sizes have been given, take the first, which will be a config with the smaller
+        // (e.g. 16-bit) depth.
+        for (int i = 0; i < configs.size(); ++i) {
+            if (filterConfig(configs[i]))
+                return configs.at(i);
+        }
+    } while (q_reduceConfigAttributes(&configureAttributes));
+
+    if (!cfg)
+        qWarning("Cannot find EGLConfig, returning null config");
+    return cfg;
+}
+
+bool QEglConfigChooser::filterConfig(EGLConfig config) const
+{
+    // If we are fine with the highest depth (e.g. RGB888 configs) even when something
+    // smaller (565) was explicitly requested, do nothing.
+    if (m_ignore)
+        return true;
+
+    EGLint red = 0;
+    EGLint green = 0;
+    EGLint blue = 0;
+    EGLint alpha = 0;
+
+    // Compare only if a size was given. Otherwise just accept.
+    if (m_confAttrRed)
+        eglGetConfigAttrib(display(), config, EGL_RED_SIZE, &red);
+    if (m_confAttrGreen)
+        eglGetConfigAttrib(display(), config, EGL_GREEN_SIZE, &green);
+    if (m_confAttrBlue)
+        eglGetConfigAttrib(display(), config, EGL_BLUE_SIZE, &blue);
+    if (m_confAttrAlpha)
+        eglGetConfigAttrib(display(), config, EGL_ALPHA_SIZE, &alpha);
+
+    return red == m_confAttrRed && green == m_confAttrGreen
+           && blue == m_confAttrBlue && alpha == m_confAttrAlpha;
+}
+
+EGLConfig q_configFromGLFormat(EGLDisplay display, const QSurfaceFormat &format, bool highestPixelFormat, int surfaceType)
+{
+    QEglConfigChooser chooser(display);
+    chooser.setSurfaceFormat(format);
+    chooser.setSurfaceType(surfaceType);
+    chooser.setIgnoreColorChannels(highestPixelFormat);
+
+    return chooser.chooseConfig();
+}
+
+QSurfaceFormat q_glFormatFromConfig(EGLDisplay display, const EGLConfig config, const QSurfaceFormat &referenceFormat)
+{
+    QSurfaceFormat format;
+    EGLint redSize     = 0;
+    EGLint greenSize   = 0;
+    EGLint blueSize    = 0;
+    EGLint alphaSize   = 0;
+    EGLint depthSize   = 0;
+    EGLint stencilSize = 0;
+    EGLint sampleCount = 0;
+    EGLint renderableType = 0;
+
+    eglGetConfigAttrib(display, config, EGL_RED_SIZE,     &redSize);
+    eglGetConfigAttrib(display, config, EGL_GREEN_SIZE,   &greenSize);
+    eglGetConfigAttrib(display, config, EGL_BLUE_SIZE,    &blueSize);
+    eglGetConfigAttrib(display, config, EGL_ALPHA_SIZE,   &alphaSize);
+    eglGetConfigAttrib(display, config, EGL_DEPTH_SIZE,   &depthSize);
+    eglGetConfigAttrib(display, config, EGL_STENCIL_SIZE, &stencilSize);
+    eglGetConfigAttrib(display, config, EGL_SAMPLES,      &sampleCount);
+    eglGetConfigAttrib(display, config, EGL_RENDERABLE_TYPE, &renderableType);
+
+    if (referenceFormat.renderableType() == QSurfaceFormat::OpenVG && (renderableType & EGL_OPENVG_BIT))
+        format.setRenderableType(QSurfaceFormat::OpenVG);
+#ifdef EGL_VERSION_1_4
+    else if (referenceFormat.renderableType() == QSurfaceFormat::OpenGL
+             && (renderableType & EGL_OPENGL_BIT))
+        format.setRenderableType(QSurfaceFormat::OpenGL);
+    else if (referenceFormat.renderableType() == QSurfaceFormat::DefaultRenderableType
+#ifndef QT_NO_OPENGL
+             && QOpenGLContext::openGLModuleType() == QOpenGLContext::LibGL
+             && !strstr(eglQueryString(display, EGL_VENDOR), "NVIDIA")
+#endif
+             && (renderableType & EGL_OPENGL_BIT))
+        format.setRenderableType(QSurfaceFormat::OpenGL);
+#endif
+    else
+        format.setRenderableType(QSurfaceFormat::OpenGLES);
+
+    format.setRedBufferSize(redSize);
+    format.setGreenBufferSize(greenSize);
+    format.setBlueBufferSize(blueSize);
+    format.setAlphaBufferSize(alphaSize);
+    format.setDepthBufferSize(depthSize);
+    format.setStencilBufferSize(stencilSize);
+    format.setSamples(sampleCount);
+    format.setStereo(false);         // EGL doesn't support stereo buffers
+    format.setSwapInterval(referenceFormat.swapInterval());
+
+    // Clear the EGL error state because some of the above may
+    // have errored out because the attribute is not applicable
+    // to the surface type.  Such errors don't matter.
+    eglGetError();
+
+    return format;
+}
+
+bool q_hasEglExtension(EGLDisplay display, const char* extensionName)
+{
+    QList<QByteArray> extensions =
+        QByteArray(reinterpret_cast<const char *>
+            (eglQueryString(display, EGL_EXTENSIONS))).split(' ');
+    return extensions.contains(extensionName);
+}
+
+struct AttrInfo { EGLint attr; const char *name; };
+static struct AttrInfo attrs[] = {
+    {EGL_BUFFER_SIZE, "EGL_BUFFER_SIZE"},
+    {EGL_ALPHA_SIZE, "EGL_ALPHA_SIZE"},
+    {EGL_BLUE_SIZE, "EGL_BLUE_SIZE"},
+    {EGL_GREEN_SIZE, "EGL_GREEN_SIZE"},
+    {EGL_RED_SIZE, "EGL_RED_SIZE"},
+    {EGL_DEPTH_SIZE, "EGL_DEPTH_SIZE"},
+    {EGL_STENCIL_SIZE, "EGL_STENCIL_SIZE"},
+    {EGL_CONFIG_CAVEAT, "EGL_CONFIG_CAVEAT"},
+    {EGL_CONFIG_ID, "EGL_CONFIG_ID"},
+    {EGL_LEVEL, "EGL_LEVEL"},
+    {EGL_MAX_PBUFFER_HEIGHT, "EGL_MAX_PBUFFER_HEIGHT"},
+    {EGL_MAX_PBUFFER_PIXELS, "EGL_MAX_PBUFFER_PIXELS"},
+    {EGL_MAX_PBUFFER_WIDTH, "EGL_MAX_PBUFFER_WIDTH"},
+    {EGL_NATIVE_RENDERABLE, "EGL_NATIVE_RENDERABLE"},
+    {EGL_NATIVE_VISUAL_ID, "EGL_NATIVE_VISUAL_ID"},
+    {EGL_NATIVE_VISUAL_TYPE, "EGL_NATIVE_VISUAL_TYPE"},
+    {EGL_SAMPLES, "EGL_SAMPLES"},
+    {EGL_SAMPLE_BUFFERS, "EGL_SAMPLE_BUFFERS"},
+    {EGL_SURFACE_TYPE, "EGL_SURFACE_TYPE"},
+    {EGL_TRANSPARENT_TYPE, "EGL_TRANSPARENT_TYPE"},
+    {EGL_TRANSPARENT_BLUE_VALUE, "EGL_TRANSPARENT_BLUE_VALUE"},
+    {EGL_TRANSPARENT_GREEN_VALUE, "EGL_TRANSPARENT_GREEN_VALUE"},
+    {EGL_TRANSPARENT_RED_VALUE, "EGL_TRANSPARENT_RED_VALUE"},
+    {EGL_BIND_TO_TEXTURE_RGB, "EGL_BIND_TO_TEXTURE_RGB"},
+    {EGL_BIND_TO_TEXTURE_RGBA, "EGL_BIND_TO_TEXTURE_RGBA"},
+    {EGL_MIN_SWAP_INTERVAL, "EGL_MIN_SWAP_INTERVAL"},
+    {EGL_MAX_SWAP_INTERVAL, "EGL_MAX_SWAP_INTERVAL"},
+    {-1, nullptr}};
+
+void q_printEglConfig(EGLDisplay display, EGLConfig config)
+{
+    EGLint index;
+    for (index = 0; attrs[index].attr != -1; ++index) {
+        EGLint value;
+        if (eglGetConfigAttrib(display, config, attrs[index].attr, &value)) {
+            qDebug("\t%s: %d", attrs[index].name, (int)value);
+        }
+    }
+}
+
+#ifdef Q_OS_UNIX
+
+QSizeF q_physicalScreenSizeFromFb(int framebufferDevice, const QSize &screenSize)
+{
+#ifndef Q_OS_LINUX
+    Q_UNUSED(framebufferDevice);
+#endif
+    const int defaultPhysicalDpi = 100;
+    static QSizeF size;
+
+    if (size.isEmpty()) {
+        // Note: in millimeters
+        int width = qEnvironmentVariableIntValue("QT_QPA_EGLFS_PHYSICAL_WIDTH");
+        int height = qEnvironmentVariableIntValue("QT_QPA_EGLFS_PHYSICAL_HEIGHT");
+
+        if (width && height) {
+            size.setWidth(width);
+            size.setHeight(height);
+            return size;
+        }
+
+        int w = -1;
+        int h = -1;
+        QSize screenResolution;
+#ifdef Q_OS_LINUX
+        struct fb_var_screeninfo vinfo;
+
+        if (framebufferDevice != -1) {
+            if (ioctl(framebufferDevice, FBIOGET_VSCREENINFO, &vinfo) == -1) {
+                qWarning("eglconvenience: Could not query screen info");
+            } else {
+                w = vinfo.width;
+                h = vinfo.height;
+                screenResolution = QSize(vinfo.xres, vinfo.yres);
+            }
+        } else
+#endif
+        {
+            // Use the provided screen size, when available, since some platforms may have their own
+            // specific way to query it. Otherwise try querying it from the framebuffer.
+            screenResolution = screenSize.isEmpty() ? q_screenSizeFromFb(framebufferDevice) : screenSize;
+        }
+
+        size.setWidth(w <= 0 ? screenResolution.width() * Q_MM_PER_INCH / defaultPhysicalDpi : qreal(w));
+        size.setHeight(h <= 0 ? screenResolution.height() * Q_MM_PER_INCH / defaultPhysicalDpi : qreal(h));
+
+        if (w <= 0 || h <= 0)
+            qWarning("Unable to query physical screen size, defaulting to %d dpi.\n"
+                     "To override, set QT_QPA_EGLFS_PHYSICAL_WIDTH "
+                     "and QT_QPA_EGLFS_PHYSICAL_HEIGHT (in millimeters).", defaultPhysicalDpi);
+    }
+
+    return size;
+}
+
+QSize q_screenSizeFromFb(int framebufferDevice)
+{
+#ifndef Q_OS_LINUX
+    Q_UNUSED(framebufferDevice);
+#endif
+    const int defaultWidth = 800;
+    const int defaultHeight = 600;
+    static QSize size;
+
+    if (size.isEmpty()) {
+        int width = qEnvironmentVariableIntValue("QT_QPA_EGLFS_WIDTH");
+        int height = qEnvironmentVariableIntValue("QT_QPA_EGLFS_HEIGHT");
+
+        if (width && height) {
+            size.setWidth(width);
+            size.setHeight(height);
+            return size;
+        }
+
+#ifdef Q_OS_LINUX
+        struct fb_var_screeninfo vinfo;
+        int xres = -1;
+        int yres = -1;
+
+        if (framebufferDevice != -1) {
+            if (ioctl(framebufferDevice, FBIOGET_VSCREENINFO, &vinfo) == -1) {
+                qWarning("eglconvenience: Could not read screen info");
+            } else {
+                xres = vinfo.xres;
+                yres = vinfo.yres;
+            }
+        }
+
+        size.setWidth(xres <= 0 ? defaultWidth : xres);
+        size.setHeight(yres <= 0 ? defaultHeight : yres);
+#else
+        size.setWidth(defaultWidth);
+        size.setHeight(defaultHeight);
+#endif
+    }
+
+    return size;
+}
+
+int q_screenDepthFromFb(int framebufferDevice)
+{
+#ifndef Q_OS_LINUX
+    Q_UNUSED(framebufferDevice);
+#endif
+    const int defaultDepth = 32;
+    static int depth = qEnvironmentVariableIntValue("QT_QPA_EGLFS_DEPTH");
+
+    if (depth == 0) {
+#ifdef Q_OS_LINUX
+        struct fb_var_screeninfo vinfo;
+
+        if (framebufferDevice != -1) {
+            if (ioctl(framebufferDevice, FBIOGET_VSCREENINFO, &vinfo) == -1)
+                qWarning("eglconvenience: Could not query screen info");
+            else
+                depth = vinfo.bits_per_pixel;
+        }
+
+        if (depth <= 0)
+            depth = defaultDepth;
+#else
+        depth = defaultDepth;
+#endif
+    }
+
+    return depth;
+}
+
+qreal q_refreshRateFromFb(int framebufferDevice)
+{
+#ifndef Q_OS_LINUX
+    Q_UNUSED(framebufferDevice);
+#endif
+
+    static qreal rate = 0;
+
+#ifdef Q_OS_LINUX
+    if (rate == 0) {
+        if (framebufferDevice != -1) {
+            struct fb_var_screeninfo vinfo;
+            if (ioctl(framebufferDevice, FBIOGET_VSCREENINFO, &vinfo) != -1) {
+                const quint64 quot = quint64(vinfo.left_margin + vinfo.right_margin + vinfo.xres + vinfo.hsync_len)
+                    * quint64(vinfo.upper_margin + vinfo.lower_margin + vinfo.yres + vinfo.vsync_len)
+                    * vinfo.pixclock;
+                if (quot)
+                    rate = 1000000000000LLU / quot;
+            } else {
+                qWarning("eglconvenience: Could not query screen info");
+            }
+        }
+    }
+#endif
+
+    if (rate == 0)
+        rate = 60;
+
+    return rate;
+}
+
+#endif // Q_OS_UNIX
+
+QT_END_NAMESPACE
diff --git a/src/gui/opengl/platform/egl/qeglconvenience_p.h b/src/gui/opengl/platform/egl/qeglconvenience_p.h
new file mode 100644
index 0000000000..d4a250c90f
--- /dev/null
+++ b/src/gui/opengl/platform/egl/qeglconvenience_p.h
@@ -0,0 +1,91 @@
+// Copyright (C) 2020 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QEGLCONVENIENCE_H
+#define QEGLCONVENIENCE_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 <QtGui/qsurfaceformat.h>
+#include <QtCore/qlist.h>
+#include <QtCore/qsize.h>
+
+#include <QtGui/private/qt_egl_p.h>
+
+
+QT_BEGIN_NAMESPACE
+
+Q_GUI_EXPORT QList<EGLint> q_createConfigAttributesFromFormat(const QSurfaceFormat &format);
+
+Q_GUI_EXPORT bool q_reduceConfigAttributes(QList<EGLint> *configAttributes);
+
+Q_GUI_EXPORT EGLConfig q_configFromGLFormat(EGLDisplay display,
+                                               const QSurfaceFormat &format,
+                                               bool highestPixelFormat = false,
+                                               int surfaceType = EGL_WINDOW_BIT);
+
+Q_GUI_EXPORT QSurfaceFormat q_glFormatFromConfig(EGLDisplay display, const EGLConfig config,
+                                                    const QSurfaceFormat &referenceFormat = {});
+
+Q_GUI_EXPORT bool q_hasEglExtension(EGLDisplay display,const char* extensionName);
+
+Q_GUI_EXPORT void q_printEglConfig(EGLDisplay display, EGLConfig config);
+
+#ifdef Q_OS_UNIX
+Q_GUI_EXPORT QSizeF q_physicalScreenSizeFromFb(int framebufferDevice,
+                                                  const QSize &screenSize = {});
+
+Q_GUI_EXPORT  QSize q_screenSizeFromFb(int framebufferDevice);
+
+Q_GUI_EXPORT int q_screenDepthFromFb(int framebufferDevice);
+
+Q_GUI_EXPORT  qreal q_refreshRateFromFb(int framebufferDevice);
+
+#endif
+
+class Q_GUI_EXPORT QEglConfigChooser
+{
+public:
+    QEglConfigChooser(EGLDisplay display);
+    virtual ~QEglConfigChooser();
+
+    EGLDisplay display() const { return m_display; }
+
+    void setSurfaceType(EGLint surfaceType) { m_surfaceType = surfaceType; }
+    EGLint surfaceType() const { return m_surfaceType; }
+
+    void setSurfaceFormat(const QSurfaceFormat &format) { m_format = format; }
+    QSurfaceFormat surfaceFormat() const { return m_format; }
+
+    void setIgnoreColorChannels(bool ignore) { m_ignore = ignore; }
+    bool ignoreColorChannels() const { return m_ignore; }
+
+    EGLConfig chooseConfig();
+
+protected:
+    virtual bool filterConfig(EGLConfig config) const;
+
+    QSurfaceFormat m_format;
+    EGLDisplay m_display;
+    EGLint m_surfaceType;
+    bool m_ignore;
+
+    int m_confAttrRed;
+    int m_confAttrGreen;
+    int m_confAttrBlue;
+    int m_confAttrAlpha;
+};
+
+
+QT_END_NAMESPACE
+
+#endif //QEGLCONVENIENCE_H
diff --git a/src/gui/opengl/platform/egl/qeglpbuffer.cpp b/src/gui/opengl/platform/egl/qeglpbuffer.cpp
new file mode 100644
index 0000000000..6a79d88f8c
--- /dev/null
+++ b/src/gui/opengl/platform/egl/qeglpbuffer.cpp
@@ -0,0 +1,63 @@
+// Copyright (C) 2020 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#include <QtGui/qoffscreensurface.h>
+#include "qeglpbuffer_p.h"
+#include "qeglconvenience_p.h"
+
+QT_BEGIN_NAMESPACE
+
+/*!
+    \class QEGLPbuffer
+    \brief A pbuffer-based implementation of QPlatformOffscreenSurface for EGL.
+    \since 5.2
+    \internal
+    \ingroup qpa
+
+    To use this implementation in the platform plugin simply
+    reimplement QPlatformIntegration::createPlatformOffscreenSurface()
+    and return a new instance of this class.
+*/
+
+QEGLPbuffer::QEGLPbuffer(EGLDisplay display, const QSurfaceFormat &format, QOffscreenSurface *offscreenSurface,
+                         QEGLPlatformContext::Flags flags)
+    : QPlatformOffscreenSurface(offscreenSurface)
+    , m_format(format)
+    , m_display(display)
+    , m_pbuffer(EGL_NO_SURFACE)
+{
+    m_hasSurfaceless = !flags.testFlag(QEGLPlatformContext::NoSurfaceless)
+        && q_hasEglExtension(display, "EGL_KHR_surfaceless_context");
+
+    if (m_hasSurfaceless)
+        return;
+
+    EGLConfig config = q_configFromGLFormat(m_display, m_format, false, EGL_PBUFFER_BIT);
+
+    if (config) {
+        const EGLint attributes[] = {
+            EGL_WIDTH, offscreenSurface->size().width(),
+            EGL_HEIGHT, offscreenSurface->size().height(),
+            EGL_LARGEST_PBUFFER, EGL_FALSE,
+            EGL_NONE
+        };
+
+        m_pbuffer = eglCreatePbufferSurface(m_display, config, attributes);
+
+        if (m_pbuffer != EGL_NO_SURFACE)
+            m_format = q_glFormatFromConfig(m_display, config);
+    }
+}
+
+QEGLPbuffer::~QEGLPbuffer()
+{
+    if (m_pbuffer != EGL_NO_SURFACE)
+        eglDestroySurface(m_display, m_pbuffer);
+}
+
+bool QEGLPbuffer::isValid() const
+{
+    return m_pbuffer != EGL_NO_SURFACE || m_hasSurfaceless;
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/opengl/platform/egl/qeglpbuffer_p.h b/src/gui/opengl/platform/egl/qeglpbuffer_p.h
new file mode 100644
index 0000000000..e6b6db1f38
--- /dev/null
+++ b/src/gui/opengl/platform/egl/qeglpbuffer_p.h
@@ -0,0 +1,44 @@
+// Copyright (C) 2020 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QEGLPBUFFER_H
+#define QEGLPBUFFER_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 <qpa/qplatformoffscreensurface.h>
+#include <QtGui/private/qeglplatformcontext_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class Q_GUI_EXPORT QEGLPbuffer : public QPlatformOffscreenSurface
+{
+public:
+    QEGLPbuffer(EGLDisplay display, const QSurfaceFormat &format, QOffscreenSurface *offscreenSurface,
+                QEGLPlatformContext::Flags flags = { });
+    ~QEGLPbuffer();
+
+    QSurfaceFormat format() const override { return m_format; }
+    bool isValid() const override;
+
+    EGLSurface pbuffer() const { return m_pbuffer; }
+
+private:
+    QSurfaceFormat m_format;
+    EGLDisplay m_display;
+    EGLSurface m_pbuffer;
+    bool m_hasSurfaceless;
+};
+
+QT_END_NAMESPACE
+
+#endif // QEGLPBUFFER_H
diff --git a/src/gui/opengl/platform/egl/qeglplatformcontext.cpp b/src/gui/opengl/platform/egl/qeglplatformcontext.cpp
new file mode 100644
index 0000000000..0a6e83e875
--- /dev/null
+++ b/src/gui/opengl/platform/egl/qeglplatformcontext.cpp
@@ -0,0 +1,838 @@
+// Copyright (C) 2021 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#include "qeglplatformcontext_p.h"
+#include "qeglconvenience_p.h"
+#include "qeglpbuffer_p.h"
+#include <qpa/qplatformwindow.h>
+#include <QtGui/qopenglcontext.h>
+#include <QtCore/qdebug.h>
+
+#ifdef Q_OS_ANDROID
+#include <QtCore/private/qjnihelpers_p.h>
+#endif
+#ifndef Q_OS_WIN
+#include <dlfcn.h>
+#endif
+
+QT_BEGIN_NAMESPACE
+
+/*!
+    \class QEGLPlatformContext
+    \brief An EGL context implementation.
+    \since 5.2
+    \internal
+    \ingroup qpa
+
+    Implement QPlatformOpenGLContext using EGL. To use it in platform
+    plugins a subclass must be created since
+    eglSurfaceForPlatformSurface() has to be reimplemented. This
+    function is used for mapping platform surfaces (windows) to EGL
+    surfaces and is necessary since different platform plugins may
+    have different ways of handling native windows (for example, a
+    plugin may choose not to back every platform window by a real EGL
+    surface). Other than that, no further customization is necessary.
+ */
+
+// Constants from EGL_KHR_create_context
+#ifndef EGL_CONTEXT_MINOR_VERSION_KHR
+#define EGL_CONTEXT_MINOR_VERSION_KHR 0x30FB
+#endif
+#ifndef EGL_CONTEXT_FLAGS_KHR
+#define EGL_CONTEXT_FLAGS_KHR 0x30FC
+#endif
+#ifndef EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR
+#define EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR 0x30FD
+#endif
+#ifndef EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR
+#define EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR 0x00000001
+#endif
+#ifndef EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR
+#define EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR 0x00000002
+#endif
+#ifndef EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR
+#define EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR 0x00000001
+#endif
+#ifndef EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR
+#define EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR 0x00000002
+#endif
+
+// Constants for OpenGL which are not available in the ES headers.
+#ifndef GL_CONTEXT_FLAGS
+#define GL_CONTEXT_FLAGS 0x821E
+#endif
+#ifndef GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT
+#define GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT 0x0001
+#endif
+#ifndef GL_CONTEXT_FLAG_DEBUG_BIT
+#define GL_CONTEXT_FLAG_DEBUG_BIT 0x00000002
+#endif
+#ifndef GL_CONTEXT_PROFILE_MASK
+#define GL_CONTEXT_PROFILE_MASK 0x9126
+#endif
+#ifndef GL_CONTEXT_CORE_PROFILE_BIT
+#define GL_CONTEXT_CORE_PROFILE_BIT 0x00000001
+#endif
+#ifndef GL_CONTEXT_COMPATIBILITY_PROFILE_BIT
+#define GL_CONTEXT_COMPATIBILITY_PROFILE_BIT 0x00000002
+#endif
+
+QEGLPlatformContext::QEGLPlatformContext(const QSurfaceFormat &format, QPlatformOpenGLContext *share, EGLDisplay display,
+                                         EGLConfig *config, Flags flags)
+    : m_eglDisplay(display)
+    , m_flags(flags)
+    , m_ownsContext(true)
+{
+    m_eglConfig = config ? *config : q_configFromGLFormat(display, format);
+
+    m_format = q_glFormatFromConfig(m_eglDisplay, m_eglConfig, format);
+    // m_format now has the renderableType() resolved (it cannot be Default anymore)
+    // but does not yet contain version, profile, options.
+    m_shareContext = share ? static_cast<QEGLPlatformContext *>(share)->m_eglContext : nullptr;
+
+    QList<EGLint> contextAttrs;
+    contextAttrs.append(EGL_CONTEXT_CLIENT_VERSION);
+    contextAttrs.append(format.majorVersion());
+    const bool hasKHRCreateContext = q_hasEglExtension(m_eglDisplay, "EGL_KHR_create_context");
+    if (hasKHRCreateContext) {
+        contextAttrs.append(EGL_CONTEXT_MINOR_VERSION_KHR);
+        contextAttrs.append(format.minorVersion());
+        int flags = 0;
+        // The debug bit is supported both for OpenGL and OpenGL ES.
+        if (format.testOption(QSurfaceFormat::DebugContext))
+            flags |= EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR;
+        // The fwdcompat bit is only for OpenGL 3.0+.
+        if (m_format.renderableType() == QSurfaceFormat::OpenGL
+            && format.majorVersion() >= 3
+            && !format.testOption(QSurfaceFormat::DeprecatedFunctions))
+            flags |= EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR;
+        if (flags) {
+            contextAttrs.append(EGL_CONTEXT_FLAGS_KHR);
+            contextAttrs.append(flags);
+        }
+        // Profiles are OpenGL only and mandatory in 3.2+. The value is silently ignored for < 3.2.
+        if (m_format.renderableType() == QSurfaceFormat::OpenGL) {
+            contextAttrs.append(EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR);
+            contextAttrs.append(format.profile() == QSurfaceFormat::CoreProfile
+                                ? EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR
+                                : EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR);
+        }
+    }
+
+#ifdef EGL_EXT_protected_content
+    if (format.testOption(QSurfaceFormat::ProtectedContent)) {
+        if (q_hasEglExtension(m_eglDisplay, "EGL_EXT_protected_content")) {
+            contextAttrs.append(EGL_PROTECTED_CONTENT_EXT);
+            contextAttrs.append(EGL_TRUE);
+        } else {
+            m_format.setOption(QSurfaceFormat::ProtectedContent, false);
+        }
+    }
+#endif
+
+    // Special Options for OpenVG surfaces
+    if (m_format.renderableType() == QSurfaceFormat::OpenVG) {
+        contextAttrs.append(EGL_ALPHA_MASK_SIZE);
+        contextAttrs.append(8);
+    }
+
+    contextAttrs.append(EGL_NONE);
+    m_contextAttrs = contextAttrs;
+
+    switch (m_format.renderableType()) {
+    case QSurfaceFormat::OpenVG:
+        m_api = EGL_OPENVG_API;
+        break;
+#ifdef EGL_VERSION_1_4
+    case QSurfaceFormat::OpenGL:
+        m_api = EGL_OPENGL_API;
+        break;
+#endif // EGL_VERSION_1_4
+    default:
+        m_api = EGL_OPENGL_ES_API;
+        break;
+    }
+
+    eglBindAPI(m_api);
+    m_eglContext = eglCreateContext(m_eglDisplay, m_eglConfig, m_shareContext, contextAttrs.constData());
+    if (m_eglContext == EGL_NO_CONTEXT && m_shareContext != EGL_NO_CONTEXT) {
+        m_shareContext = nullptr;
+        m_eglContext = eglCreateContext(m_eglDisplay, m_eglConfig, nullptr, contextAttrs.constData());
+    }
+
+    if (m_eglContext == EGL_NO_CONTEXT) {
+        qWarning("QEGLPlatformContext: Failed to create context: %x", eglGetError());
+        return;
+    }
+
+    static const bool printConfig = qEnvironmentVariableIntValue("QT_QPA_EGLFS_DEBUG");
+    if (printConfig) {
+        qDebug() << "Created context for format" << format << "with config:";
+        q_printEglConfig(m_eglDisplay, m_eglConfig);
+
+        static const bool printAllConfigs = qEnvironmentVariableIntValue("QT_QPA_EGLFS_DEBUG") > 1;
+        if (printAllConfigs) {
+            EGLint numConfigs = 0;
+            eglGetConfigs(m_eglDisplay, nullptr, 0, &numConfigs);
+            QVector<EGLConfig> configs;
+            configs.resize(numConfigs);
+            eglGetConfigs(m_eglDisplay, configs.data(), numConfigs, &numConfigs);
+            qDebug("\nAll EGLConfigs: count=%d", numConfigs);
+            for (EGLint i = 0; i < numConfigs; ++i) {
+                qDebug("EGLConfig #%d", i);
+                q_printEglConfig(m_eglDisplay, configs[i]);
+            }
+            qDebug("\n");
+        }
+    }
+
+    // Cannot just call updateFormatFromGL() since it relies on virtuals. Defer it to initialize().
+}
+
+void QEGLPlatformContext::adopt(EGLContext context, EGLDisplay display, QPlatformOpenGLContext *share)
+{
+    Q_ASSERT(!m_ownsContext);
+
+    m_eglDisplay = display;
+
+    // Figure out the EGLConfig.
+    EGLint value = 0;
+    eglQueryContext(m_eglDisplay, context, EGL_CONFIG_ID, &value);
+    EGLint n = 0;
+    EGLConfig cfg;
+    const EGLint attribs[] = { EGL_CONFIG_ID, value, EGL_NONE };
+    if (eglChooseConfig(m_eglDisplay, attribs, &cfg, 1, &n) && n == 1) {
+        m_eglConfig = cfg;
+        m_format = q_glFormatFromConfig(m_eglDisplay, m_eglConfig);
+    } else {
+        qWarning("QEGLPlatformContext: Failed to get framebuffer configuration for context");
+    }
+
+    // Fetch client API type.
+    value = 0;
+    eglQueryContext(m_eglDisplay, context, EGL_CONTEXT_CLIENT_TYPE, &value);
+    if (value == EGL_OPENGL_API || value == EGL_OPENGL_ES_API) {
+        // if EGL config supports both OpenGL and OpenGL ES render type,
+        // q_glFormatFromConfig() with the default "referenceFormat" parameter
+        // will always figure it out as OpenGL render type.
+        // We can override it to match user's real render type.
+        if (value == EGL_OPENGL_ES_API)
+            m_format.setRenderableType(QSurfaceFormat::OpenGLES);
+        m_api = value;
+        eglBindAPI(m_api);
+    } else {
+        qWarning("QEGLPlatformContext: Failed to get client API type");
+        m_api = EGL_OPENGL_ES_API;
+    }
+
+    m_eglContext = context;
+    m_shareContext = share ? static_cast<QEGLPlatformContext *>(share)->m_eglContext : nullptr;
+    updateFormatFromGL();
+}
+
+void QEGLPlatformContext::initialize()
+{
+    if (m_eglContext != EGL_NO_CONTEXT)
+        updateFormatFromGL();
+}
+
+// Base implementation for pbuffers. Subclasses will handle the specialized cases for
+// platforms without pbuffers.
+EGLSurface QEGLPlatformContext::createTemporaryOffscreenSurface()
+{
+    // Make the context current to ensure the GL version query works. This needs a surface too.
+    const EGLint pbufferAttributes[] = {
+        EGL_WIDTH, 1,
+        EGL_HEIGHT, 1,
+        EGL_LARGEST_PBUFFER, EGL_FALSE,
+        EGL_NONE
+    };
+
+    // Cannot just pass m_eglConfig because it may not be suitable for pbuffers. Instead,
+    // do what QEGLPbuffer would do: request a config with the same attributes but with
+    // PBUFFER_BIT set.
+    EGLConfig config = q_configFromGLFormat(m_eglDisplay, m_format, false, EGL_PBUFFER_BIT);
+
+    return eglCreatePbufferSurface(m_eglDisplay, config, pbufferAttributes);
+}
+
+void QEGLPlatformContext::destroyTemporaryOffscreenSurface(EGLSurface surface)
+{
+    eglDestroySurface(m_eglDisplay, surface);
+}
+
+void QEGLPlatformContext::runGLChecks()
+{
+    // Nothing to do here, subclasses may override in order to perform OpenGL
+    // queries needing a context.
+}
+
+void QEGLPlatformContext::updateFormatFromGL()
+{
+#ifndef QT_NO_OPENGL
+    // Have to save & restore to prevent QOpenGLContext::currentContext() from becoming
+    // inconsistent after QOpenGLContext::create().
+    EGLDisplay prevDisplay = eglGetCurrentDisplay();
+    if (prevDisplay == EGL_NO_DISPLAY) // when no context is current
+        prevDisplay = m_eglDisplay;
+    EGLContext prevContext = eglGetCurrentContext();
+    EGLSurface prevSurfaceDraw = eglGetCurrentSurface(EGL_DRAW);
+    EGLSurface prevSurfaceRead = eglGetCurrentSurface(EGL_READ);
+
+    // Rely on the surfaceless extension, if available. This is beneficial since we can
+    // avoid creating an extra pbuffer surface which is apparently troublesome with some
+    // drivers (Mesa) when certain attributes are present (multisampling).
+    EGLSurface tempSurface = EGL_NO_SURFACE;
+    EGLContext tempContext = EGL_NO_CONTEXT;
+    if (m_flags.testFlag(NoSurfaceless) || !q_hasEglExtension(m_eglDisplay, "EGL_KHR_surfaceless_context"))
+        tempSurface = createTemporaryOffscreenSurface();
+
+    EGLBoolean ok = eglMakeCurrent(m_eglDisplay, tempSurface, tempSurface, m_eglContext);
+    if (!ok) {
+        EGLConfig config = q_configFromGLFormat(m_eglDisplay, m_format, false, EGL_PBUFFER_BIT);
+        tempContext = eglCreateContext(m_eglDisplay, config, nullptr, m_contextAttrs.constData());
+        if (tempContext != EGL_NO_CONTEXT)
+            ok = eglMakeCurrent(m_eglDisplay, tempSurface, tempSurface, tempContext);
+    }
+    if (ok) {
+        if (m_format.renderableType() == QSurfaceFormat::OpenGL
+            || m_format.renderableType() == QSurfaceFormat::OpenGLES) {
+            const GLubyte *s = glGetString(GL_VERSION);
+            if (s) {
+                QByteArray version = QByteArray(reinterpret_cast<const char *>(s));
+                int major, minor;
+                if (QPlatformOpenGLContext::parseOpenGLVersion(version, major, minor)) {
+                    m_format.setMajorVersion(major);
+                    m_format.setMinorVersion(minor);
+                }
+            }
+            m_format.setProfile(QSurfaceFormat::NoProfile);
+            m_format.setOptions(QSurfaceFormat::FormatOptions());
+            if (m_format.renderableType() == QSurfaceFormat::OpenGL) {
+                // Check profile and options.
+                if (m_format.majorVersion() < 3) {
+                    m_format.setOption(QSurfaceFormat::DeprecatedFunctions);
+                } else {
+                    GLint value = 0;
+                    glGetIntegerv(GL_CONTEXT_FLAGS, &value);
+                    if (!(value & GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT))
+                        m_format.setOption(QSurfaceFormat::DeprecatedFunctions);
+                    if (value & GL_CONTEXT_FLAG_DEBUG_BIT)
+                        m_format.setOption(QSurfaceFormat::DebugContext);
+                    if (m_format.version() >= qMakePair(3, 2)) {
+                        value = 0;
+                        glGetIntegerv(GL_CONTEXT_PROFILE_MASK, &value);
+                        if (value & GL_CONTEXT_CORE_PROFILE_BIT)
+                            m_format.setProfile(QSurfaceFormat::CoreProfile);
+                        else if (value & GL_CONTEXT_COMPATIBILITY_PROFILE_BIT)
+                            m_format.setProfile(QSurfaceFormat::CompatibilityProfile);
+                    }
+                }
+            }
+        }
+        runGLChecks();
+        eglMakeCurrent(prevDisplay, prevSurfaceDraw, prevSurfaceRead, prevContext);
+    } else {
+        qWarning("QEGLPlatformContext: Failed to make temporary surface current, format not updated (%x)", eglGetError());
+    }
+    if (tempSurface != EGL_NO_SURFACE)
+        destroyTemporaryOffscreenSurface(tempSurface);
+    if (tempContext != EGL_NO_CONTEXT)
+        eglDestroyContext(m_eglDisplay, tempContext);
+#endif // QT_NO_OPENGL
+}
+
+bool QEGLPlatformContext::makeCurrent(QPlatformSurface *surface)
+{
+    Q_ASSERT(surface->surface()->supportsOpenGL());
+
+    eglBindAPI(m_api);
+
+    EGLSurface eglSurface = eglSurfaceForPlatformSurface(surface);
+
+    // shortcut: on some GPUs, eglMakeCurrent is not a cheap operation
+    if (eglGetCurrentContext() == m_eglContext &&
+        eglGetCurrentDisplay() == m_eglDisplay &&
+        eglGetCurrentSurface(EGL_READ) == eglSurface &&
+        eglGetCurrentSurface(EGL_DRAW) == eglSurface) {
+        return true;
+    }
+
+    const bool ok = eglMakeCurrent(m_eglDisplay, eglSurface, eglSurface, m_eglContext);
+    if (ok) {
+        if (!m_swapIntervalEnvChecked) {
+            m_swapIntervalEnvChecked = true;
+            if (qEnvironmentVariableIsSet("QT_QPA_EGLFS_SWAPINTERVAL")) {
+                QByteArray swapIntervalString = qgetenv("QT_QPA_EGLFS_SWAPINTERVAL");
+                bool intervalOk;
+                const int swapInterval = swapIntervalString.toInt(&intervalOk);
+                if (intervalOk)
+                    m_swapIntervalFromEnv = swapInterval;
+            }
+        }
+        const int requestedSwapInterval = m_swapIntervalFromEnv >= 0
+            ? m_swapIntervalFromEnv
+            : surface->format().swapInterval();
+        if (requestedSwapInterval >= 0 && m_swapInterval != requestedSwapInterval) {
+            m_swapInterval = requestedSwapInterval;
+            if (eglSurface != EGL_NO_SURFACE) // skip if using surfaceless context
+                eglSwapInterval(eglDisplay(), m_swapInterval);
+        }
+    } else {
+        qWarning("QEGLPlatformContext: eglMakeCurrent failed: %x", eglGetError());
+    }
+
+    return ok;
+}
+
+QEGLPlatformContext::~QEGLPlatformContext()
+{
+    if (m_ownsContext && m_eglContext != EGL_NO_CONTEXT)
+        eglDestroyContext(m_eglDisplay, m_eglContext);
+
+    m_eglContext = EGL_NO_CONTEXT;
+}
+
+void QEGLPlatformContext::doneCurrent()
+{
+    eglBindAPI(m_api);
+    bool ok = eglMakeCurrent(m_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+    if (!ok)
+        qWarning("QEGLPlatformContext: eglMakeCurrent failed: %x", eglGetError());
+}
+
+void QEGLPlatformContext::swapBuffers(QPlatformSurface *surface)
+{
+    eglBindAPI(m_api);
+    EGLSurface eglSurface = eglSurfaceForPlatformSurface(surface);
+    if (eglSurface != EGL_NO_SURFACE) { // skip if using surfaceless context
+        bool ok = eglSwapBuffers(m_eglDisplay, eglSurface);
+        if (!ok)
+            qWarning("QEGLPlatformContext: eglSwapBuffers failed: %x", eglGetError());
+    }
+}
+
+QFunctionPointer QEGLPlatformContext::getProcAddress(const char *procName)
+{
+    eglBindAPI(m_api);
+    QFunctionPointer proc = (QFunctionPointer) eglGetProcAddress(procName);
+#if !defined(Q_OS_WIN) && !defined(Q_OS_INTEGRITY)
+    if (!proc)
+        proc = (QFunctionPointer) dlsym(RTLD_DEFAULT, procName);
+#elif !defined(QT_OPENGL_DYNAMIC)
+    // On systems without KHR_get_all_proc_addresses and without
+    // dynamic linking there still has to be a way to access the
+    // standard GLES functions. QOpenGL(Extra)Functions never makes
+    // direct GL API calls since Qt 5.7, so all such workarounds are
+    // expected to be handled in the platform plugin.
+    if (!proc) {
+        static struct StdFunc {
+            const char *name;
+            QFunctionPointer func;
+        } standardFuncs[] = {
+#if QT_CONFIG(opengles2)
+            { "glBindTexture", (QFunctionPointer) ::glBindTexture },
+            { "glBlendFunc", (QFunctionPointer) ::glBlendFunc },
+            { "glClear", (QFunctionPointer) ::glClear },
+            { "glClearColor", (QFunctionPointer) ::glClearColor },
+            { "glClearStencil", (QFunctionPointer) ::glClearStencil },
+            { "glColorMask", (QFunctionPointer) ::glColorMask },
+            { "glCopyTexImage2D", (QFunctionPointer) ::glCopyTexImage2D },
+            { "glCopyTexSubImage2D", (QFunctionPointer) ::glCopyTexSubImage2D },
+            { "glCullFace", (QFunctionPointer) ::glCullFace },
+            { "glDeleteTextures", (QFunctionPointer) ::glDeleteTextures },
+            { "glDepthFunc", (QFunctionPointer) ::glDepthFunc },
+            { "glDepthMask", (QFunctionPointer) ::glDepthMask },
+            { "glDisable", (QFunctionPointer) ::glDisable },
+            { "glDrawArrays", (QFunctionPointer) ::glDrawArrays },
+            { "glDrawElements", (QFunctionPointer) ::glDrawElements },
+            { "glEnable", (QFunctionPointer) ::glEnable },
+            { "glFinish", (QFunctionPointer) ::glFinish },
+            { "glFlush", (QFunctionPointer) ::glFlush },
+            { "glFrontFace", (QFunctionPointer) ::glFrontFace },
+            { "glGenTextures", (QFunctionPointer) ::glGenTextures },
+            { "glGetBooleanv", (QFunctionPointer) ::glGetBooleanv },
+            { "glGetError", (QFunctionPointer) ::glGetError },
+            { "glGetFloatv", (QFunctionPointer) ::glGetFloatv },
+            { "glGetIntegerv", (QFunctionPointer) ::glGetIntegerv },
+            { "glGetString", (QFunctionPointer) ::glGetString },
+            { "glGetTexParameterfv", (QFunctionPointer) ::glGetTexParameterfv },
+            { "glGetTexParameteriv", (QFunctionPointer) ::glGetTexParameteriv },
+            { "glHint", (QFunctionPointer) ::glHint },
+            { "glIsEnabled", (QFunctionPointer) ::glIsEnabled },
+            { "glIsTexture", (QFunctionPointer) ::glIsTexture },
+            { "glLineWidth", (QFunctionPointer) ::glLineWidth },
+            { "glPixelStorei", (QFunctionPointer) ::glPixelStorei },
+            { "glPolygonOffset", (QFunctionPointer) ::glPolygonOffset },
+            { "glReadPixels", (QFunctionPointer) ::glReadPixels },
+            { "glScissor", (QFunctionPointer) ::glScissor },
+            { "glStencilFunc", (QFunctionPointer) ::glStencilFunc },
+            { "glStencilMask", (QFunctionPointer) ::glStencilMask },
+            { "glStencilOp", (QFunctionPointer) ::glStencilOp },
+            { "glTexImage2D", (QFunctionPointer) ::glTexImage2D },
+            { "glTexParameterf", (QFunctionPointer) ::glTexParameterf },
+            { "glTexParameterfv", (QFunctionPointer) ::glTexParameterfv },
+            { "glTexParameteri", (QFunctionPointer) ::glTexParameteri },
+            { "glTexParameteriv", (QFunctionPointer) ::glTexParameteriv },
+            { "glTexSubImage2D", (QFunctionPointer) ::glTexSubImage2D },
+            { "glViewport", (QFunctionPointer) ::glViewport },
+
+            { "glActiveTexture", (QFunctionPointer) ::glActiveTexture },
+            { "glAttachShader", (QFunctionPointer) ::glAttachShader },
+            { "glBindAttribLocation", (QFunctionPointer) ::glBindAttribLocation },
+            { "glBindBuffer", (QFunctionPointer) ::glBindBuffer },
+            { "glBindFramebuffer", (QFunctionPointer) ::glBindFramebuffer },
+            { "glBindRenderbuffer", (QFunctionPointer) ::glBindRenderbuffer },
+            { "glBlendColor", (QFunctionPointer) ::glBlendColor },
+            { "glBlendEquation", (QFunctionPointer) ::glBlendEquation },
+            { "glBlendEquationSeparate", (QFunctionPointer) ::glBlendEquationSeparate },
+            { "glBlendFuncSeparate", (QFunctionPointer) ::glBlendFuncSeparate },
+            { "glBufferData", (QFunctionPointer) ::glBufferData },
+            { "glBufferSubData", (QFunctionPointer) ::glBufferSubData },
+            { "glCheckFramebufferStatus", (QFunctionPointer) ::glCheckFramebufferStatus },
+            { "glCompileShader", (QFunctionPointer) ::glCompileShader },
+            { "glCompressedTexImage2D", (QFunctionPointer) ::glCompressedTexImage2D },
+            { "glCompressedTexSubImage2D", (QFunctionPointer) ::glCompressedTexSubImage2D },
+            { "glCreateProgram", (QFunctionPointer) ::glCreateProgram },
+            { "glCreateShader", (QFunctionPointer) ::glCreateShader },
+            { "glDeleteBuffers", (QFunctionPointer) ::glDeleteBuffers },
+            { "glDeleteFramebuffers", (QFunctionPointer) ::glDeleteFramebuffers },
+            { "glDeleteProgram", (QFunctionPointer) ::glDeleteProgram },
+            { "glDeleteRenderbuffers", (QFunctionPointer) ::glDeleteRenderbuffers },
+            { "glDeleteShader", (QFunctionPointer) ::glDeleteShader },
+            { "glDetachShader", (QFunctionPointer) ::glDetachShader },
+            { "glDisableVertexAttribArray", (QFunctionPointer) ::glDisableVertexAttribArray },
+            { "glEnableVertexAttribArray", (QFunctionPointer) ::glEnableVertexAttribArray },
+            { "glFramebufferRenderbuffer", (QFunctionPointer) ::glFramebufferRenderbuffer },
+            { "glFramebufferTexture2D", (QFunctionPointer) ::glFramebufferTexture2D },
+            { "glGenBuffers", (QFunctionPointer) ::glGenBuffers },
+            { "glGenerateMipmap", (QFunctionPointer) ::glGenerateMipmap },
+            { "glGenFramebuffers", (QFunctionPointer) ::glGenFramebuffers },
+            { "glGenRenderbuffers", (QFunctionPointer) ::glGenRenderbuffers },
+            { "glGetActiveAttrib", (QFunctionPointer) ::glGetActiveAttrib },
+            { "glGetActiveUniform", (QFunctionPointer) ::glGetActiveUniform },
+            { "glGetAttachedShaders", (QFunctionPointer) ::glGetAttachedShaders },
+            { "glGetAttribLocation", (QFunctionPointer) ::glGetAttribLocation },
+            { "glGetBufferParameteriv", (QFunctionPointer) ::glGetBufferParameteriv },
+            { "glGetFramebufferAttachmentParameteriv", (QFunctionPointer) ::glGetFramebufferAttachmentParameteriv },
+            { "glGetProgramiv", (QFunctionPointer) ::glGetProgramiv },
+            { "glGetProgramInfoLog", (QFunctionPointer) ::glGetProgramInfoLog },
+            { "glGetRenderbufferParameteriv", (QFunctionPointer) ::glGetRenderbufferParameteriv },
+            { "glGetShaderiv", (QFunctionPointer) ::glGetShaderiv },
+            { "glGetShaderInfoLog", (QFunctionPointer) ::glGetShaderInfoLog },
+            { "glGetShaderPrecisionFormat", (QFunctionPointer) ::glGetShaderPrecisionFormat },
+            { "glGetShaderSource", (QFunctionPointer) ::glGetShaderSource },
+            { "glGetUniformfv", (QFunctionPointer) ::glGetUniformfv },
+            { "glGetUniformiv", (QFunctionPointer) ::glGetUniformiv },
+            { "glGetUniformLocation", (QFunctionPointer) ::glGetUniformLocation },
+            { "glGetVertexAttribfv", (QFunctionPointer) ::glGetVertexAttribfv },
+            { "glGetVertexAttribiv", (QFunctionPointer) ::glGetVertexAttribiv },
+            { "glGetVertexAttribPointerv", (QFunctionPointer) ::glGetVertexAttribPointerv },
+            { "glIsBuffer", (QFunctionPointer) ::glIsBuffer },
+            { "glIsFramebuffer", (QFunctionPointer) ::glIsFramebuffer },
+            { "glIsProgram", (QFunctionPointer) ::glIsProgram },
+            { "glIsRenderbuffer", (QFunctionPointer) ::glIsRenderbuffer },
+            { "glIsShader", (QFunctionPointer) ::glIsShader },
+            { "glLinkProgram", (QFunctionPointer) ::glLinkProgram },
+            { "glReleaseShaderCompiler", (QFunctionPointer) ::glReleaseShaderCompiler },
+            { "glRenderbufferStorage", (QFunctionPointer) ::glRenderbufferStorage },
+            { "glSampleCoverage", (QFunctionPointer) ::glSampleCoverage },
+            { "glShaderBinary", (QFunctionPointer) ::glShaderBinary },
+            { "glShaderSource", (QFunctionPointer) ::glShaderSource },
+            { "glStencilFuncSeparate", (QFunctionPointer) ::glStencilFuncSeparate },
+            { "glStencilMaskSeparate", (QFunctionPointer) ::glStencilMaskSeparate },
+            { "glStencilOpSeparate", (QFunctionPointer) ::glStencilOpSeparate },
+            { "glUniform1f", (QFunctionPointer) ::glUniform1f },
+            { "glUniform1fv", (QFunctionPointer) ::glUniform1fv },
+            { "glUniform1i", (QFunctionPointer) ::glUniform1i },
+            { "glUniform1iv", (QFunctionPointer) ::glUniform1iv },
+            { "glUniform2f", (QFunctionPointer) ::glUniform2f },
+            { "glUniform2fv", (QFunctionPointer) ::glUniform2fv },
+            { "glUniform2i", (QFunctionPointer) ::glUniform2i },
+            { "glUniform2iv", (QFunctionPointer) ::glUniform2iv },
+            { "glUniform3f", (QFunctionPointer) ::glUniform3f },
+            { "glUniform3fv", (QFunctionPointer) ::glUniform3fv },
+            { "glUniform3i", (QFunctionPointer) ::glUniform3i },
+            { "glUniform3iv", (QFunctionPointer) ::glUniform3iv },
+            { "glUniform4f", (QFunctionPointer) ::glUniform4f },
+            { "glUniform4fv", (QFunctionPointer) ::glUniform4fv },
+            { "glUniform4i", (QFunctionPointer) ::glUniform4i },
+            { "glUniform4iv", (QFunctionPointer) ::glUniform4iv },
+            { "glUniformMatrix2fv", (QFunctionPointer) ::glUniformMatrix2fv },
+            { "glUniformMatrix3fv", (QFunctionPointer) ::glUniformMatrix3fv },
+            { "glUniformMatrix4fv", (QFunctionPointer) ::glUniformMatrix4fv },
+            { "glUseProgram", (QFunctionPointer) ::glUseProgram },
+            { "glValidateProgram", (QFunctionPointer) ::glValidateProgram },
+            { "glVertexAttrib1f", (QFunctionPointer) ::glVertexAttrib1f },
+            { "glVertexAttrib1fv", (QFunctionPointer) ::glVertexAttrib1fv },
+            { "glVertexAttrib2f", (QFunctionPointer) ::glVertexAttrib2f },
+            { "glVertexAttrib2fv", (QFunctionPointer) ::glVertexAttrib2fv },
+            { "glVertexAttrib3f", (QFunctionPointer) ::glVertexAttrib3f },
+            { "glVertexAttrib3fv", (QFunctionPointer) ::glVertexAttrib3fv },
+            { "glVertexAttrib4f", (QFunctionPointer) ::glVertexAttrib4f },
+            { "glVertexAttrib4fv", (QFunctionPointer) ::glVertexAttrib4fv },
+            { "glVertexAttribPointer", (QFunctionPointer) ::glVertexAttribPointer },
+
+            { "glClearDepthf", (QFunctionPointer) ::glClearDepthf },
+            { "glDepthRangef", (QFunctionPointer) ::glDepthRangef },
+#endif // QT_CONFIG(opengles2)
+
+#if QT_CONFIG(opengles3)
+            { "glBeginQuery", (QFunctionPointer) ::glBeginQuery },
+            { "glBeginTransformFeedback", (QFunctionPointer) ::glBeginTransformFeedback },
+            { "glBindBufferBase", (QFunctionPointer) ::glBindBufferBase },
+            { "glBindBufferRange", (QFunctionPointer) ::glBindBufferRange },
+            { "glBindSampler", (QFunctionPointer) ::glBindSampler },
+            { "glBindTransformFeedback", (QFunctionPointer) ::glBindTransformFeedback },
+            { "glBindVertexArray", (QFunctionPointer) ::glBindVertexArray },
+            { "glBlitFramebuffer", (QFunctionPointer) ::glBlitFramebuffer },
+            { "glClearBufferfi", (QFunctionPointer) ::glClearBufferfi },
+            { "glClearBufferfv", (QFunctionPointer) ::glClearBufferfv },
+            { "glClearBufferiv", (QFunctionPointer) ::glClearBufferiv },
+            { "glClearBufferuiv", (QFunctionPointer) ::glClearBufferuiv },
+            { "glClientWaitSync", (QFunctionPointer) ::glClientWaitSync },
+            { "glCompressedTexImage3D", (QFunctionPointer) ::glCompressedTexImage3D },
+            { "glCompressedTexSubImage3D", (QFunctionPointer) ::glCompressedTexSubImage3D },
+            { "glCopyBufferSubData", (QFunctionPointer) ::glCopyBufferSubData },
+            { "glCopyTexSubImage3D", (QFunctionPointer) ::glCopyTexSubImage3D },
+            { "glDeleteQueries", (QFunctionPointer) ::glDeleteQueries },
+            { "glDeleteSamplers", (QFunctionPointer) ::glDeleteSamplers },
+            { "glDeleteSync", (QFunctionPointer) ::glDeleteSync },
+            { "glDeleteTransformFeedbacks", (QFunctionPointer) ::glDeleteTransformFeedbacks },
+            { "glDeleteVertexArrays", (QFunctionPointer) ::glDeleteVertexArrays },
+            { "glDrawArraysInstanced", (QFunctionPointer) ::glDrawArraysInstanced },
+            { "glDrawBuffers", (QFunctionPointer) ::glDrawBuffers },
+            { "glDrawElementsInstanced", (QFunctionPointer) ::glDrawElementsInstanced },
+            { "glDrawRangeElements", (QFunctionPointer) ::glDrawRangeElements },
+            { "glEndQuery", (QFunctionPointer) ::glEndQuery },
+            { "glEndTransformFeedback", (QFunctionPointer) ::glEndTransformFeedback },
+            { "glFenceSync", (QFunctionPointer) ::glFenceSync },
+            { "glFlushMappedBufferRange", (QFunctionPointer) ::glFlushMappedBufferRange },
+            { "glFramebufferTextureLayer", (QFunctionPointer) ::glFramebufferTextureLayer },
+            { "glGenQueries", (QFunctionPointer) ::glGenQueries },
+            { "glGenSamplers", (QFunctionPointer) ::glGenSamplers },
+            { "glGenTransformFeedbacks", (QFunctionPointer) ::glGenTransformFeedbacks },
+            { "glGenVertexArrays", (QFunctionPointer) ::glGenVertexArrays },
+            { "glGetActiveUniformBlockName", (QFunctionPointer) ::glGetActiveUniformBlockName },
+            { "glGetActiveUniformBlockiv", (QFunctionPointer) ::glGetActiveUniformBlockiv },
+            { "glGetActiveUniformsiv", (QFunctionPointer) ::glGetActiveUniformsiv },
+            { "glGetBufferParameteri64v", (QFunctionPointer) ::glGetBufferParameteri64v },
+            { "glGetBufferPointerv", (QFunctionPointer) ::glGetBufferPointerv },
+            { "glGetFragDataLocation", (QFunctionPointer) ::glGetFragDataLocation },
+            { "glGetInteger64i_v", (QFunctionPointer) ::glGetInteger64i_v },
+            { "glGetInteger64v", (QFunctionPointer) ::glGetInteger64v },
+            { "glGetIntegeri_v", (QFunctionPointer) ::glGetIntegeri_v },
+            { "glGetInternalformativ", (QFunctionPointer) ::glGetInternalformativ },
+            { "glGetProgramBinary", (QFunctionPointer) ::glGetProgramBinary },
+            { "glGetQueryObjectuiv", (QFunctionPointer) ::glGetQueryObjectuiv },
+            { "glGetQueryiv", (QFunctionPointer) ::glGetQueryiv },
+            { "glGetSamplerParameterfv", (QFunctionPointer) ::glGetSamplerParameterfv },
+            { "glGetSamplerParameteriv", (QFunctionPointer) ::glGetSamplerParameteriv },
+            { "glGetStringi", (QFunctionPointer) ::glGetStringi },
+            { "glGetSynciv", (QFunctionPointer) ::glGetSynciv },
+            { "glGetTransformFeedbackVarying", (QFunctionPointer) ::glGetTransformFeedbackVarying },
+            { "glGetUniformBlockIndex", (QFunctionPointer) ::glGetUniformBlockIndex },
+            { "glGetUniformIndices", (QFunctionPointer) ::glGetUniformIndices },
+            { "glGetUniformuiv", (QFunctionPointer) ::glGetUniformuiv },
+            { "glGetVertexAttribIiv", (QFunctionPointer) ::glGetVertexAttribIiv },
+            { "glGetVertexAttribIuiv", (QFunctionPointer) ::glGetVertexAttribIuiv },
+            { "glInvalidateFramebuffer", (QFunctionPointer) ::glInvalidateFramebuffer },
+            { "glInvalidateSubFramebuffer", (QFunctionPointer) ::glInvalidateSubFramebuffer },
+            { "glIsQuery", (QFunctionPointer) ::glIsQuery },
+            { "glIsSampler", (QFunctionPointer) ::glIsSampler },
+            { "glIsSync", (QFunctionPointer) ::glIsSync },
+            { "glIsTransformFeedback", (QFunctionPointer) ::glIsTransformFeedback },
+            { "glIsVertexArray", (QFunctionPointer) ::glIsVertexArray },
+            { "glMapBufferRange", (QFunctionPointer) ::glMapBufferRange },
+            { "glPauseTransformFeedback", (QFunctionPointer) ::glPauseTransformFeedback },
+            { "glProgramBinary", (QFunctionPointer) ::glProgramBinary },
+            { "glProgramParameteri", (QFunctionPointer) ::glProgramParameteri },
+            { "glReadBuffer", (QFunctionPointer) ::glReadBuffer },
+            { "glRenderbufferStorageMultisample", (QFunctionPointer) ::glRenderbufferStorageMultisample },
+            { "glResumeTransformFeedback", (QFunctionPointer) ::glResumeTransformFeedback },
+            { "glSamplerParameterf", (QFunctionPointer) ::glSamplerParameterf },
+            { "glSamplerParameterfv", (QFunctionPointer) ::glSamplerParameterfv },
+            { "glSamplerParameteri", (QFunctionPointer) ::glSamplerParameteri },
+            { "glSamplerParameteriv", (QFunctionPointer) ::glSamplerParameteriv },
+            { "glTexImage3D", (QFunctionPointer) ::glTexImage3D },
+            { "glTexStorage2D", (QFunctionPointer) ::glTexStorage2D },
+            { "glTexStorage3D", (QFunctionPointer) ::glTexStorage3D },
+            { "glTexSubImage3D", (QFunctionPointer) ::glTexSubImage3D },
+            { "glTransformFeedbackVaryings", (QFunctionPointer) ::glTransformFeedbackVaryings },
+            { "glUniform1ui", (QFunctionPointer) ::glUniform1ui },
+            { "glUniform1uiv", (QFunctionPointer) ::glUniform1uiv },
+            { "glUniform2ui", (QFunctionPointer) ::glUniform2ui },
+            { "glUniform2uiv", (QFunctionPointer) ::glUniform2uiv },
+            { "glUniform3ui", (QFunctionPointer) ::glUniform3ui },
+            { "glUniform3uiv", (QFunctionPointer) ::glUniform3uiv },
+            { "glUniform4ui", (QFunctionPointer) ::glUniform4ui },
+            { "glUniform4uiv", (QFunctionPointer) ::glUniform4uiv },
+            { "glUniformBlockBinding", (QFunctionPointer) ::glUniformBlockBinding },
+            { "glUniformMatrix2x3fv", (QFunctionPointer) ::glUniformMatrix2x3fv },
+            { "glUniformMatrix2x4fv", (QFunctionPointer) ::glUniformMatrix2x4fv },
+            { "glUniformMatrix3x2fv", (QFunctionPointer) ::glUniformMatrix3x2fv },
+            { "glUniformMatrix3x4fv", (QFunctionPointer) ::glUniformMatrix3x4fv },
+            { "glUniformMatrix4x2fv", (QFunctionPointer) ::glUniformMatrix4x2fv },
+            { "glUniformMatrix4x3fv", (QFunctionPointer) ::glUniformMatrix4x3fv },
+            { "glUnmapBuffer", (QFunctionPointer) ::glUnmapBuffer },
+            { "glVertexAttribDivisor", (QFunctionPointer) ::glVertexAttribDivisor },
+            { "glVertexAttribI4i", (QFunctionPointer) ::glVertexAttribI4i },
+            { "glVertexAttribI4iv", (QFunctionPointer) ::glVertexAttribI4iv },
+            { "glVertexAttribI4ui", (QFunctionPointer) ::glVertexAttribI4ui },
+            { "glVertexAttribI4uiv", (QFunctionPointer) ::glVertexAttribI4uiv },
+            { "glVertexAttribIPointer", (QFunctionPointer) ::glVertexAttribIPointer },
+            { "glWaitSync", (QFunctionPointer) ::glWaitSync },
+#endif // QT_CONFIG(opengles3)
+
+#if QT_CONFIG(opengles31)
+            { "glActiveShaderProgram", (QFunctionPointer) ::glActiveShaderProgram },
+            { "glBindImageTexture", (QFunctionPointer) ::glBindImageTexture },
+            { "glBindProgramPipeline", (QFunctionPointer) ::glBindProgramPipeline },
+            { "glBindVertexBuffer", (QFunctionPointer) ::glBindVertexBuffer },
+            { "glCreateShaderProgramv", (QFunctionPointer) ::glCreateShaderProgramv },
+            { "glDeleteProgramPipelines", (QFunctionPointer) ::glDeleteProgramPipelines },
+            { "glDispatchCompute", (QFunctionPointer) ::glDispatchCompute },
+            { "glDispatchComputeIndirect", (QFunctionPointer) ::glDispatchComputeIndirect },
+            { "glDrawArraysIndirect", (QFunctionPointer) ::glDrawArraysIndirect },
+            { "glDrawElementsIndirect", (QFunctionPointer) ::glDrawElementsIndirect },
+            { "glFramebufferParameteri", (QFunctionPointer) ::glFramebufferParameteri },
+            { "glGenProgramPipelines", (QFunctionPointer) ::glGenProgramPipelines },
+            { "glGetBooleani_v", (QFunctionPointer) ::glGetBooleani_v },
+            { "glGetFramebufferParameteriv", (QFunctionPointer) ::glGetFramebufferParameteriv },
+            { "glGetMultisamplefv", (QFunctionPointer) ::glGetMultisamplefv },
+            { "glGetProgramInterfaceiv", (QFunctionPointer) ::glGetProgramInterfaceiv },
+            { "glGetProgramPipelineInfoLog", (QFunctionPointer) ::glGetProgramPipelineInfoLog },
+            { "glGetProgramPipelineiv", (QFunctionPointer) ::glGetProgramPipelineiv },
+            { "glGetProgramResourceIndex", (QFunctionPointer) ::glGetProgramResourceIndex },
+            { "glGetProgramResourceLocation", (QFunctionPointer) ::glGetProgramResourceLocation },
+            { "glGetProgramResourceName", (QFunctionPointer) ::glGetProgramResourceName },
+            { "glGetProgramResourceiv", (QFunctionPointer) ::glGetProgramResourceiv },
+            { "glGetTexLevelParameterfv", (QFunctionPointer) ::glGetTexLevelParameterfv },
+            { "glGetTexLevelParameteriv", (QFunctionPointer) ::glGetTexLevelParameteriv },
+            { "glIsProgramPipeline", (QFunctionPointer) ::glIsProgramPipeline },
+            { "glMemoryBarrier", (QFunctionPointer) ::glMemoryBarrier },
+            { "glMemoryBarrierByRegion", (QFunctionPointer) ::glMemoryBarrierByRegion },
+            { "glProgramUniform1f", (QFunctionPointer) ::glProgramUniform1f },
+            { "glProgramUniform1fv", (QFunctionPointer) ::glProgramUniform1fv },
+            { "glProgramUniform1i", (QFunctionPointer) ::glProgramUniform1i },
+            { "glProgramUniform1iv", (QFunctionPointer) ::glProgramUniform1iv },
+            { "glProgramUniform1ui", (QFunctionPointer) ::glProgramUniform1ui },
+            { "glProgramUniform1uiv", (QFunctionPointer) ::glProgramUniform1uiv },
+            { "glProgramUniform2f", (QFunctionPointer) ::glProgramUniform2f },
+            { "glProgramUniform2fv", (QFunctionPointer) ::glProgramUniform2fv },
+            { "glProgramUniform2i", (QFunctionPointer) ::glProgramUniform2i },
+            { "glProgramUniform2iv", (QFunctionPointer) ::glProgramUniform2iv },
+            { "glProgramUniform2ui", (QFunctionPointer) ::glProgramUniform2ui },
+            { "glProgramUniform2uiv", (QFunctionPointer) ::glProgramUniform2uiv },
+            { "glProgramUniform3f", (QFunctionPointer) ::glProgramUniform3f },
+            { "glProgramUniform3fv", (QFunctionPointer) ::glProgramUniform3fv },
+            { "glProgramUniform3i", (QFunctionPointer) ::glProgramUniform3i },
+            { "glProgramUniform3iv", (QFunctionPointer) ::glProgramUniform3iv },
+            { "glProgramUniform3ui", (QFunctionPointer) ::glProgramUniform3ui },
+            { "glProgramUniform3uiv", (QFunctionPointer) ::glProgramUniform3uiv },
+            { "glProgramUniform4f", (QFunctionPointer) ::glProgramUniform4f },
+            { "glProgramUniform4fv", (QFunctionPointer) ::glProgramUniform4fv },
+            { "glProgramUniform4i", (QFunctionPointer) ::glProgramUniform4i },
+            { "glProgramUniform4iv", (QFunctionPointer) ::glProgramUniform4iv },
+            { "glProgramUniform4ui", (QFunctionPointer) ::glProgramUniform4ui },
+            { "glProgramUniform4uiv", (QFunctionPointer) ::glProgramUniform4uiv },
+            { "glProgramUniformMatrix2fv", (QFunctionPointer) ::glProgramUniformMatrix2fv },
+            { "glProgramUniformMatrix2x3fv", (QFunctionPointer) ::glProgramUniformMatrix2x3fv },
+            { "glProgramUniformMatrix2x4fv", (QFunctionPointer) ::glProgramUniformMatrix2x4fv },
+            { "glProgramUniformMatrix3fv", (QFunctionPointer) ::glProgramUniformMatrix3fv },
+            { "glProgramUniformMatrix3x2fv", (QFunctionPointer) ::glProgramUniformMatrix3x2fv },
+            { "glProgramUniformMatrix3x4fv", (QFunctionPointer) ::glProgramUniformMatrix3x4fv },
+            { "glProgramUniformMatrix4fv", (QFunctionPointer) ::glProgramUniformMatrix4fv },
+            { "glProgramUniformMatrix4x2fv", (QFunctionPointer) ::glProgramUniformMatrix4x2fv },
+            { "glProgramUniformMatrix4x3fv", (QFunctionPointer) ::glProgramUniformMatrix4x3fv },
+            { "glSampleMaski", (QFunctionPointer) ::glSampleMaski },
+            { "glTexStorage2DMultisample", (QFunctionPointer) ::glTexStorage2DMultisample },
+            { "glUseProgramStages", (QFunctionPointer) ::glUseProgramStages },
+            { "glValidateProgramPipeline", (QFunctionPointer) ::glValidateProgramPipeline },
+            { "glVertexAttribBinding", (QFunctionPointer) ::glVertexAttribBinding },
+            { "glVertexAttribFormat", (QFunctionPointer) ::glVertexAttribFormat },
+            { "glVertexAttribIFormat", (QFunctionPointer) ::glVertexAttribIFormat },
+            { "glVertexBindingDivisor", (QFunctionPointer) ::glVertexBindingDivisor },
+#endif // QT_CONFIG(opengles31)
+
+#if QT_CONFIG(opengles32)
+            { "glBlendBarrier", (QFunctionPointer) ::glBlendBarrier },
+            { "glCopyImageSubData", (QFunctionPointer) ::glCopyImageSubData },
+            { "glDebugMessageControl", (QFunctionPointer) ::glDebugMessageControl },
+            { "glDebugMessageInsert", (QFunctionPointer) ::glDebugMessageInsert },
+            { "glDebugMessageCallback", (QFunctionPointer) ::glDebugMessageCallback },
+            { "glGetDebugMessageLog", (QFunctionPointer) ::glGetDebugMessageLog },
+            { "glPushDebugGroup", (QFunctionPointer) ::glPushDebugGroup },
+            { "glPopDebugGroup", (QFunctionPointer) ::glPopDebugGroup },
+            { "glObjectLabel", (QFunctionPointer) ::glObjectLabel },
+            { "glGetObjectLabel", (QFunctionPointer) ::glGetObjectLabel },
+            { "glObjectPtrLabel", (QFunctionPointer) ::glObjectPtrLabel },
+            { "glGetObjectPtrLabel", (QFunctionPointer) ::glGetObjectPtrLabel },
+            { "glGetPointerv", (QFunctionPointer) ::glGetPointerv },
+            { "glEnablei", (QFunctionPointer) ::glEnablei },
+            { "glDisablei", (QFunctionPointer) ::glDisablei },
+            { "glBlendEquationi", (QFunctionPointer) ::glBlendEquationi },
+            { "glBlendEquationSeparatei", (QFunctionPointer) ::glBlendEquationSeparatei },
+            { "glBlendFunci", (QFunctionPointer) ::glBlendFunci },
+            { "glBlendFuncSeparatei", (QFunctionPointer) ::glBlendFuncSeparatei },
+            { "glColorMaski", (QFunctionPointer) ::glColorMaski },
+            { "glIsEnabledi", (QFunctionPointer) ::glIsEnabledi },
+            { "glDrawElementsBaseVertex", (QFunctionPointer) ::glDrawElementsBaseVertex },
+            { "glDrawRangeElementsBaseVertex", (QFunctionPointer) ::glDrawRangeElementsBaseVertex },
+            { "glDrawElementsInstancedBaseVertex", (QFunctionPointer) ::glDrawElementsInstancedBaseVertex },
+            { "glFramebufferTexture", (QFunctionPointer) ::glFramebufferTexture },
+            { "glPrimitiveBoundingBox", (QFunctionPointer) ::glPrimitiveBoundingBox },
+            { "glGetGraphicsResetStatus", (QFunctionPointer) ::glGetGraphicsResetStatus },
+            { "glReadnPixels", (QFunctionPointer) ::glReadnPixels },
+            { "glGetnUniformfv", (QFunctionPointer) ::glGetnUniformfv },
+            { "glGetnUniformiv", (QFunctionPointer) ::glGetnUniformiv },
+            { "glGetnUniformuiv", (QFunctionPointer) ::glGetnUniformuiv },
+            { "glMinSampleShading", (QFunctionPointer) ::glMinSampleShading },
+            { "glPatchParameteri", (QFunctionPointer) ::glPatchParameteri },
+            { "glTexParameterIiv", (QFunctionPointer) ::glTexParameterIiv },
+            { "glTexParameterIuiv", (QFunctionPointer) ::glTexParameterIuiv },
+            { "glGetTexParameterIiv", (QFunctionPointer) ::glGetTexParameterIiv },
+            { "glGetTexParameterIuiv", (QFunctionPointer) ::glGetTexParameterIuiv },
+            { "glSamplerParameterIiv", (QFunctionPointer) ::glSamplerParameterIiv },
+            { "glSamplerParameterIuiv", (QFunctionPointer) ::glSamplerParameterIuiv },
+            { "glGetSamplerParameterIiv", (QFunctionPointer) ::glGetSamplerParameterIiv },
+            { "glGetSamplerParameterIuiv", (QFunctionPointer) ::glGetSamplerParameterIuiv },
+            { "glTexBuffer", (QFunctionPointer) ::glTexBuffer },
+            { "glTexBufferRange", (QFunctionPointer) ::glTexBufferRange },
+            { "glTexStorage3DMultisample", (QFunctionPointer) ::glTexStorage3DMultisample },
+#endif // QT_CONFIG(opengles32)
+        };
+
+        for (size_t i = 0; i < sizeof(standardFuncs) / sizeof(StdFunc); ++i) {
+            if (!qstrcmp(procName, standardFuncs[i].name)) {
+                proc = standardFuncs[i].func;
+                break;
+            }
+        }
+    }
+#endif
+
+    return proc;
+}
+
+QSurfaceFormat QEGLPlatformContext::format() const
+{
+    return m_format;
+}
+
+EGLContext QEGLPlatformContext::eglContext() const
+{
+    return m_eglContext;
+}
+
+EGLDisplay QEGLPlatformContext::eglDisplay() const
+{
+    return m_eglDisplay;
+}
+
+EGLConfig QEGLPlatformContext::eglConfig() const
+{
+    return m_eglConfig;
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/opengl/platform/egl/qeglplatformcontext_p.h b/src/gui/opengl/platform/egl/qeglplatformcontext_p.h
new file mode 100644
index 0000000000..b1e9c4b4c2
--- /dev/null
+++ b/src/gui/opengl/platform/egl/qeglplatformcontext_p.h
@@ -0,0 +1,115 @@
+// Copyright (C) 2020 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QEGLPLATFORMCONTEXT_H
+#define QEGLPLATFORMCONTEXT_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 <QtCore/qtextstream.h>
+#include <qpa/qplatformwindow.h>
+#include <qpa/qplatformopenglcontext.h>
+#include <QtCore/qvariant.h>
+#include <QtGui/private/qt_egl_p.h>
+#include <QtGui/private/qopenglcontext_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class Q_GUI_EXPORT QEGLPlatformContext : public QPlatformOpenGLContext,
+                                            public QNativeInterface::QEGLContext
+{
+public:
+    enum Flag {
+        NoSurfaceless = 0x01
+    };
+    Q_DECLARE_FLAGS(Flags, Flag)
+
+    QEGLPlatformContext(const QSurfaceFormat &format, QPlatformOpenGLContext *share, EGLDisplay display,
+                        EGLConfig *config = nullptr, Flags flags = { });
+
+    template <typename T>
+    static QOpenGLContext *createFrom(EGLContext context, EGLDisplay contextDisplay,
+            EGLDisplay platformDisplay, QOpenGLContext *shareContext)
+    {
+        if (!context)
+            return nullptr;
+
+        // A context belonging to a given EGLDisplay cannot be used with another one
+        if (contextDisplay != platformDisplay) {
+            qWarning("QEGLPlatformContext: Cannot adopt context from different display");
+            return nullptr;
+        }
+
+        QPlatformOpenGLContext *shareHandle = shareContext ? shareContext->handle() : nullptr;
+
+        auto *resultingContext = new QOpenGLContext;
+        auto *contextPrivate = QOpenGLContextPrivate::get(resultingContext);
+        auto *platformContext = new T;
+        platformContext->adopt(context, contextDisplay, shareHandle);
+        contextPrivate->adopt(platformContext);
+        return resultingContext;
+    }
+
+    ~QEGLPlatformContext();
+
+    void initialize() override;
+    bool makeCurrent(QPlatformSurface *surface) override;
+    void doneCurrent() override;
+    void swapBuffers(QPlatformSurface *surface) override;
+    QFunctionPointer getProcAddress(const char *procName) override;
+
+    QSurfaceFormat format() const override;
+    bool isSharing() const override { return m_shareContext != EGL_NO_CONTEXT; }
+    bool isValid() const override { return m_eglContext != EGL_NO_CONTEXT && !m_markedInvalid; }
+
+    EGLContext nativeContext() const override { return eglContext(); }
+    EGLConfig config() const override { return eglConfig(); }
+    EGLDisplay display() const override { return eglDisplay(); }
+
+    virtual void invalidateContext() override { m_markedInvalid = true; }
+
+    EGLContext eglContext() const;
+    EGLDisplay eglDisplay() const;
+    EGLConfig eglConfig() const;
+
+protected:
+    QEGLPlatformContext() {} // For adoption
+    virtual EGLSurface eglSurfaceForPlatformSurface(QPlatformSurface *surface) = 0;
+    virtual EGLSurface createTemporaryOffscreenSurface();
+    virtual void destroyTemporaryOffscreenSurface(EGLSurface surface);
+    virtual void runGLChecks();
+
+private:
+    void adopt(EGLContext context, EGLDisplay display, QPlatformOpenGLContext *shareContext);
+    void updateFormatFromGL();
+
+    EGLContext m_eglContext;
+    EGLContext m_shareContext;
+    EGLDisplay m_eglDisplay;
+    EGLConfig m_eglConfig;
+    QSurfaceFormat m_format;
+    EGLenum m_api;
+    int m_swapInterval = -1;
+    bool m_swapIntervalEnvChecked = false;
+    int m_swapIntervalFromEnv = -1;
+    Flags m_flags;
+    bool m_ownsContext = false;
+    QList<EGLint> m_contextAttrs;
+
+    bool m_markedInvalid = false;
+};
+
+Q_DECLARE_OPERATORS_FOR_FLAGS(QEGLPlatformContext::Flags)
+
+QT_END_NAMESPACE
+
+#endif //QEGLPLATFORMCONTEXT_H
diff --git a/src/gui/opengl/platform/egl/qeglstreamconvenience.cpp b/src/gui/opengl/platform/egl/qeglstreamconvenience.cpp
new file mode 100644
index 0000000000..869e763bb8
--- /dev/null
+++ b/src/gui/opengl/platform/egl/qeglstreamconvenience.cpp
@@ -0,0 +1,87 @@
+// Copyright (C) 2020 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#include "qeglstreamconvenience_p.h"
+#include <string.h>
+
+QT_BEGIN_NAMESPACE
+
+QEGLStreamConvenience::QEGLStreamConvenience()
+    : initialized(false),
+      has_egl_platform_device(false),
+      has_egl_device_base(false),
+      has_egl_stream(false),
+      has_egl_stream_producer_eglsurface(false),
+      has_egl_stream_consumer_egloutput(false),
+      has_egl_output_drm(false),
+      has_egl_output_base(false),
+      has_egl_stream_cross_process_fd(false),
+      has_egl_stream_consumer_gltexture(false)
+{
+    const char *extensions = eglQueryString(EGL_NO_DISPLAY, EGL_EXTENSIONS);
+    if (!extensions) {
+        qWarning("Failed to query EGL extensions");
+        return;
+    }
+
+    query_devices = reinterpret_cast<PFNEGLQUERYDEVICESEXTPROC>(eglGetProcAddress("eglQueryDevicesEXT"));
+    query_device_string = reinterpret_cast<PFNEGLQUERYDEVICESTRINGEXTPROC>(eglGetProcAddress("eglQueryDeviceStringEXT"));
+    get_platform_display = reinterpret_cast<PFNEGLGETPLATFORMDISPLAYEXTPROC>(eglGetProcAddress("eglGetPlatformDisplayEXT"));
+
+    has_egl_device_base = strstr(extensions, "EGL_EXT_device_base");
+    has_egl_platform_device = strstr(extensions, "EGL_EXT_platform_device");
+}
+
+void QEGLStreamConvenience::initialize(EGLDisplay dpy)
+{
+    if (initialized)
+        return;
+
+    if (!eglBindAPI(EGL_OPENGL_ES_API)) {
+        qWarning("Failed to bind OpenGL ES API");
+        return;
+    }
+
+    const char *extensions = eglQueryString(dpy, EGL_EXTENSIONS);
+    if (!extensions) {
+        qWarning("Failed to query EGL extensions");
+        return;
+    }
+
+    create_stream = reinterpret_cast<PFNEGLCREATESTREAMKHRPROC>(eglGetProcAddress("eglCreateStreamKHR"));
+    destroy_stream = reinterpret_cast<PFNEGLDESTROYSTREAMKHRPROC>(eglGetProcAddress("eglDestroyStreamKHR"));
+    stream_attrib = reinterpret_cast<PFNEGLSTREAMATTRIBKHRPROC>(eglGetProcAddress("eglStreamAttribKHR"));
+    query_stream = reinterpret_cast<PFNEGLQUERYSTREAMKHRPROC>(eglGetProcAddress("eglQueryStreamKHR"));
+    query_stream_u64 = reinterpret_cast<PFNEGLQUERYSTREAMU64KHRPROC>(eglGetProcAddress("eglQueryStreamu64KHR"));
+    create_stream_producer_surface = reinterpret_cast<PFNEGLCREATESTREAMPRODUCERSURFACEKHRPROC>(eglGetProcAddress("eglCreateStreamProducerSurfaceKHR"));
+    stream_consumer_output = reinterpret_cast<PFNEGLSTREAMCONSUMEROUTPUTEXTPROC>(eglGetProcAddress("eglStreamConsumerOutputEXT"));
+    get_output_layers = reinterpret_cast<PFNEGLGETOUTPUTLAYERSEXTPROC>(eglGetProcAddress("eglGetOutputLayersEXT"));
+    get_output_ports = reinterpret_cast<PFNEGLGETOUTPUTPORTSEXTPROC>(eglGetProcAddress("eglGetOutputPortsEXT"));
+    output_layer_attrib = reinterpret_cast<PFNEGLOUTPUTLAYERATTRIBEXTPROC>(eglGetProcAddress("eglOutputLayerAttribEXT"));
+    query_output_layer_attrib = reinterpret_cast<PFNEGLQUERYOUTPUTLAYERATTRIBEXTPROC>(eglGetProcAddress("eglQueryOutputLayerAttribEXT"));
+    query_output_layer_string = reinterpret_cast<PFNEGLQUERYOUTPUTLAYERSTRINGEXTPROC>(eglGetProcAddress("eglQueryOutputLayerStringEXT"));
+    query_output_port_attrib = reinterpret_cast<PFNEGLQUERYOUTPUTPORTATTRIBEXTPROC>(eglGetProcAddress("eglQueryOutputPortAttribEXT"));
+    query_output_port_string = reinterpret_cast<PFNEGLQUERYOUTPUTPORTSTRINGEXTPROC>(eglGetProcAddress("eglQueryOutputPortStringEXT"));
+    get_stream_file_descriptor = reinterpret_cast<PFNEGLGETSTREAMFILEDESCRIPTORKHRPROC>(eglGetProcAddress("eglGetStreamFileDescriptorKHR"));
+    create_stream_from_file_descriptor = reinterpret_cast<PFNEGLCREATESTREAMFROMFILEDESCRIPTORKHRPROC>(eglGetProcAddress("eglCreateStreamFromFileDescriptorKHR"));
+    stream_consumer_gltexture = reinterpret_cast<PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALKHRPROC>(eglGetProcAddress("eglStreamConsumerGLTextureExternalKHR"));
+    stream_consumer_acquire = reinterpret_cast<PFNEGLSTREAMCONSUMERACQUIREKHRPROC>(eglGetProcAddress("eglStreamConsumerAcquireKHR"));
+    stream_consumer_release = reinterpret_cast<PFNEGLSTREAMCONSUMERRELEASEKHRPROC>(eglGetProcAddress("eglStreamConsumerReleaseKHR"));
+    create_stream_attrib_nv = reinterpret_cast<PFNEGLCREATESTREAMATTRIBNVPROC>(eglGetProcAddress("eglCreateStreamAttribNV"));
+    set_stream_attrib_nv = reinterpret_cast<PFNEGLSETSTREAMATTRIBNVPROC>(eglGetProcAddress("eglSetStreamAttribNV"));
+    query_stream_attrib_nv = reinterpret_cast<PFNEGLQUERYSTREAMATTRIBNVPROC>(eglGetProcAddress("eglQueryStreamAttribNV"));
+    acquire_stream_attrib_nv = reinterpret_cast<PFNEGLSTREAMCONSUMERACQUIREATTRIBNVPROC>(eglGetProcAddress("eglStreamConsumerAcquireAttribNV"));
+    release_stream_attrib_nv = reinterpret_cast<PFNEGLSTREAMCONSUMERRELEASEATTRIBNVPROC>(eglGetProcAddress("eglStreamConsumerReleaseAttribNV"));
+
+    has_egl_stream = strstr(extensions, "EGL_KHR_stream");
+    has_egl_stream_producer_eglsurface = strstr(extensions, "EGL_KHR_stream_producer_eglsurface");
+    has_egl_stream_consumer_egloutput = strstr(extensions, "EGL_EXT_stream_consumer_egloutput");
+    has_egl_output_drm = strstr(extensions, "EGL_EXT_output_drm");
+    has_egl_output_base = strstr(extensions, "EGL_EXT_output_base");
+    has_egl_stream_cross_process_fd = strstr(extensions, "EGL_KHR_stream_cross_process_fd");
+    has_egl_stream_consumer_gltexture = strstr(extensions, "EGL_KHR_stream_consumer_gltexture");
+
+    initialized = true;
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/opengl/platform/egl/qeglstreamconvenience_p.h b/src/gui/opengl/platform/egl/qeglstreamconvenience_p.h
new file mode 100644
index 0000000000..edf73fe981
--- /dev/null
+++ b/src/gui/opengl/platform/egl/qeglstreamconvenience_p.h
@@ -0,0 +1,179 @@
+// Copyright (C) 2020 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QEGLSTREAMCONVENIENCE_H
+#define QEGLSTREAMCONVENIENCE_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 <QtGui/qtguiglobal.h>
+
+#include <QtGui/private/qt_egl_p.h>
+
+// This provides runtime EGLDevice/Output/Stream support even when eglext.h in
+// the sysroot is not up-to-date.
+
+#ifndef EGL_VERSION_1_5
+typedef intptr_t EGLAttrib;
+#endif
+
+#ifndef EGL_EXT_platform_base
+typedef EGLDisplay (EGLAPIENTRYP PFNEGLGETPLATFORMDISPLAYEXTPROC) (EGLenum platform, void *native_display, const EGLint *attrib_list);
+#endif
+
+#ifndef EGL_EXT_device_base
+typedef void *EGLDeviceEXT;
+#define EGL_NO_DEVICE_EXT                 ((EGLDeviceEXT)(0))
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYDEVICESEXTPROC) (EGLint max_devices, EGLDeviceEXT *devices, EGLint *num_devices);
+typedef const char *(EGLAPIENTRYP PFNEGLQUERYDEVICESTRINGEXTPROC) (EGLDeviceEXT device, EGLint name);
+#endif
+
+#ifndef EGL_EXT_output_base
+typedef void *EGLOutputLayerEXT;
+typedef void *EGLOutputPortEXT;
+#define EGL_NO_OUTPUT_LAYER_EXT           ((EGLOutputLayerEXT)0)
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETOUTPUTLAYERSEXTPROC) (EGLDisplay dpy, const EGLAttrib *attrib_list, EGLOutputLayerEXT *layers, EGLint max_layers, EGLint *num_layers);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETOUTPUTPORTSEXTPROC) (EGLDisplay dpy, const EGLAttrib *attrib_list, EGLOutputPortEXT *ports, EGLint max_ports, EGLint *num_ports);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLOUTPUTLAYERATTRIBEXTPROC) (EGLDisplay dpy, EGLOutputLayerEXT layer, EGLint attribute, EGLAttrib value);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYOUTPUTLAYERATTRIBEXTPROC) (EGLDisplay dpy, EGLOutputLayerEXT layer, EGLint attribute, EGLAttrib *value);
+typedef const char *(EGLAPIENTRYP PFNEGLQUERYOUTPUTLAYERSTRINGEXTPROC) (EGLDisplay dpy, EGLOutputLayerEXT layer, EGLint name);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYOUTPUTPORTATTRIBEXTPROC) (EGLDisplay dpy, EGLOutputPortEXT port, EGLint attribute, EGLAttrib *value);
+typedef const char *(EGLAPIENTRYP PFNEGLQUERYOUTPUTPORTSTRINGEXTPROC) (EGLDisplay dpy, EGLOutputPortEXT port, EGLint name);
+#endif
+
+#ifndef EGL_KHR_stream
+typedef void *EGLStreamKHR;
+typedef quint64 EGLuint64KHR;
+#define EGL_NO_STREAM_KHR                 ((EGLStreamKHR)0)
+#define EGL_STREAM_STATE_KHR              0x3214
+#define EGL_STREAM_STATE_CREATED_KHR      0x3215
+#define EGL_STREAM_STATE_CONNECTING_KHR   0x3216
+#define EGL_STREAM_STATE_EMPTY_KHR        0x3217
+#define EGL_STREAM_STATE_NEW_FRAME_AVAILABLE_KHR 0x3218
+#define EGL_STREAM_STATE_OLD_FRAME_AVAILABLE_KHR 0x3219
+#define EGL_STREAM_STATE_DISCONNECTED_KHR 0x321A
+#define EGL_BAD_STREAM_KHR                0x321B
+#define EGL_BAD_STATE_KHR                 0x321C
+typedef EGLStreamKHR (EGLAPIENTRYP PFNEGLCREATESTREAMKHRPROC) (EGLDisplay dpy, const EGLint *attrib_list);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLDESTROYSTREAMKHRPROC) (EGLDisplay dpy, EGLStreamKHR stream);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLSTREAMATTRIBKHRPROC) (EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLint value);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYSTREAMKHRPROC) (EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLint *value);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYSTREAMU64KHRPROC) (EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLuint64KHR *value);
+#endif
+
+#ifndef EGL_KHR_stream_fifo
+#define EGL_STREAM_FIFO_LENGTH_KHR        0x31FC
+#endif
+
+#ifndef EGL_KHR_stream_producer_eglsurface
+#define EGL_STREAM_BIT_KHR                0x0800
+typedef EGLSurface (EGLAPIENTRYP PFNEGLCREATESTREAMPRODUCERSURFACEKHRPROC) (EGLDisplay dpy, EGLConfig config, EGLStreamKHR stream, const EGLint *attrib_list);
+#endif
+
+#ifndef EGL_KHR_stream_cross_process_fd
+typedef int EGLNativeFileDescriptorKHR;
+#define EGL_NO_FILE_DESCRIPTOR_KHR        ((EGLNativeFileDescriptorKHR)(-1))
+typedef EGLNativeFileDescriptorKHR (EGLAPIENTRYP PFNEGLGETSTREAMFILEDESCRIPTORKHRPROC) (EGLDisplay dpy, EGLStreamKHR stream);
+typedef EGLStreamKHR (EGLAPIENTRYP PFNEGLCREATESTREAMFROMFILEDESCRIPTORKHRPROC) (EGLDisplay dpy, EGLNativeFileDescriptorKHR file_descriptor);
+#endif
+
+#ifndef EGL_KHR_stream_consumer_gltexture
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALKHRPROC) (EGLDisplay dpy, EGLStreamKHR stream);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLSTREAMCONSUMERACQUIREKHRPROC) (EGLDisplay dpy, EGLStreamKHR stream);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLSTREAMCONSUMERRELEASEKHRPROC) (EGLDisplay dpy, EGLStreamKHR stream);
+#endif
+
+#ifndef EGL_EXT_stream_consumer_egloutput
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLSTREAMCONSUMEROUTPUTEXTPROC) (EGLDisplay dpy, EGLStreamKHR stream, EGLOutputLayerEXT layer);
+#endif
+
+#ifndef EGL_EXT_platform_device
+#define EGL_PLATFORM_DEVICE_EXT           0x313F
+#endif
+
+#ifndef EGL_EXT_device_drm
+#define EGL_DRM_DEVICE_FILE_EXT           0x3233
+#endif
+
+#ifndef EGL_EXT_output_drm
+#define EGL_DRM_CRTC_EXT                  0x3234
+#define EGL_DRM_PLANE_EXT                 0x3235
+#endif
+
+#ifndef EGL_PLATFORM_X11_KHR
+#define EGL_PLATFORM_X11_KHR              0x31D5
+#endif
+
+#ifndef EGL_PLATFORM_XCB_KHR
+#define EGL_PLATFORM_XCB_KHR              0x31DC
+#endif
+
+#ifndef EGL_NV_stream_attrib
+typedef EGLStreamKHR (EGLAPIENTRYP PFNEGLCREATESTREAMATTRIBNVPROC) (EGLDisplay dpy, const EGLAttrib *attrib_list);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLSETSTREAMATTRIBNVPROC) (EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLAttrib value);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYSTREAMATTRIBNVPROC) (EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLAttrib *value);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLSTREAMCONSUMERACQUIREATTRIBNVPROC) (EGLDisplay dpy, EGLStreamKHR stream, const EGLAttrib *attrib_list);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLSTREAMCONSUMERRELEASEATTRIBNVPROC) (EGLDisplay dpy, EGLStreamKHR stream, const EGLAttrib *attrib_list);
+#endif
+
+QT_BEGIN_NAMESPACE
+
+class Q_GUI_EXPORT QEGLStreamConvenience
+{
+public:
+    QEGLStreamConvenience();
+    void initialize(EGLDisplay dpy);
+
+    PFNEGLGETPLATFORMDISPLAYEXTPROC get_platform_display;
+    PFNEGLQUERYDEVICESEXTPROC query_devices;
+    PFNEGLQUERYDEVICESTRINGEXTPROC query_device_string;
+    PFNEGLCREATESTREAMKHRPROC create_stream;
+    PFNEGLCREATESTREAMATTRIBNVPROC create_stream_attrib_nv;
+    PFNEGLSETSTREAMATTRIBNVPROC set_stream_attrib_nv;
+    PFNEGLQUERYSTREAMATTRIBNVPROC query_stream_attrib_nv;
+    PFNEGLSTREAMCONSUMERACQUIREATTRIBNVPROC acquire_stream_attrib_nv;
+    PFNEGLSTREAMCONSUMERRELEASEATTRIBNVPROC release_stream_attrib_nv;
+    PFNEGLDESTROYSTREAMKHRPROC destroy_stream;
+    PFNEGLSTREAMATTRIBKHRPROC stream_attrib;
+    PFNEGLQUERYSTREAMKHRPROC query_stream;
+    PFNEGLQUERYSTREAMU64KHRPROC query_stream_u64;
+    PFNEGLCREATESTREAMPRODUCERSURFACEKHRPROC create_stream_producer_surface;
+    PFNEGLSTREAMCONSUMEROUTPUTEXTPROC stream_consumer_output;
+    PFNEGLGETOUTPUTLAYERSEXTPROC get_output_layers;
+    PFNEGLGETOUTPUTPORTSEXTPROC get_output_ports;
+    PFNEGLOUTPUTLAYERATTRIBEXTPROC output_layer_attrib;
+    PFNEGLQUERYOUTPUTLAYERATTRIBEXTPROC query_output_layer_attrib;
+    PFNEGLQUERYOUTPUTLAYERSTRINGEXTPROC query_output_layer_string;
+    PFNEGLQUERYOUTPUTPORTATTRIBEXTPROC query_output_port_attrib;
+    PFNEGLQUERYOUTPUTPORTSTRINGEXTPROC query_output_port_string;
+    PFNEGLGETSTREAMFILEDESCRIPTORKHRPROC get_stream_file_descriptor;
+    PFNEGLCREATESTREAMFROMFILEDESCRIPTORKHRPROC create_stream_from_file_descriptor;
+    PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALKHRPROC stream_consumer_gltexture;
+    PFNEGLSTREAMCONSUMERACQUIREKHRPROC stream_consumer_acquire;
+    PFNEGLSTREAMCONSUMERRELEASEKHRPROC stream_consumer_release;
+
+    bool initialized;
+
+    bool has_egl_platform_device;
+    bool has_egl_device_base;
+    bool has_egl_stream;
+    bool has_egl_stream_producer_eglsurface;
+    bool has_egl_stream_consumer_egloutput;
+    bool has_egl_output_drm;
+    bool has_egl_output_base;
+    bool has_egl_stream_cross_process_fd;
+    bool has_egl_stream_consumer_gltexture;
+};
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/gui/opengl/platform/egl/qt_egl_p.h b/src/gui/opengl/platform/egl/qt_egl_p.h
new file mode 100644
index 0000000000..1f538e22af
--- /dev/null
+++ b/src/gui/opengl/platform/egl/qt_egl_p.h
@@ -0,0 +1,97 @@
+// Copyright (C) 2020 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QT_EGL_P_H
+#define QT_EGL_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.
+//
+
+// q(data/text)stream.h must be included before any header file that defines Status
+#include <QtCore/qdatastream.h>
+#include <QtCore/qtextstream.h>
+#include <QtCore/private/qglobal_p.h>
+
+#ifdef QT_EGL_NO_X11
+# ifndef EGL_NO_X11
+#  define EGL_NO_X11
+# endif
+# ifndef MESA_EGL_NO_X11_HEADERS
+#  define MESA_EGL_NO_X11_HEADERS // MESA
+# endif
+# if !defined(Q_OS_INTEGRITY)
+#  define WIN_INTERFACE_CUSTOM   // NV
+# endif // Q_OS_INTEGRITY
+#else // QT_EGL_NO_X11
+// If one has an eglplatform.h with https://github.com/KhronosGroup/EGL-Registry/pull/130
+// that needs USE_X11 to be defined.
+# define USE_X11
+#endif
+
+#ifdef QT_EGL_WAYLAND
+# define WAYLAND // NV
+#endif // QT_EGL_WAYLAND
+
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
+
+#include <stdint.h>
+
+QT_BEGIN_NAMESPACE
+
+namespace QtInternal {
+
+template <class FromType, class ToType>
+struct QtEglConverter
+{
+    static inline ToType convert(FromType v)
+    { return v; }
+};
+
+template <>
+struct QtEglConverter<uint32_t, uintptr_t>
+{
+    static inline uintptr_t convert(uint32_t v)
+    { return v; }
+};
+
+#if QT_POINTER_SIZE > 4
+template <>
+struct QtEglConverter<uintptr_t, uint32_t>
+{
+    static inline uint32_t convert(uintptr_t v)
+    { return uint32_t(v); }
+};
+#endif
+
+template <>
+struct QtEglConverter<uint32_t, void *>
+{
+    static inline void *convert(uint32_t v)
+    { return reinterpret_cast<void *>(uintptr_t(v)); }
+};
+
+template <>
+struct QtEglConverter<void *, uint32_t>
+{
+    static inline uint32_t convert(void *v)
+    { return uintptr_t(v); }
+};
+
+} // QtInternal
+
+template <class ToType, class FromType>
+static inline ToType qt_egl_cast(FromType from)
+{ return QtInternal::QtEglConverter<FromType, ToType>::convert(from); }
+
+QT_END_NAMESPACE
+
+#endif // QT_EGL_P_H
diff --git a/src/gui/opengl/platform/unix/qglxconvenience.cpp b/src/gui/opengl/platform/unix/qglxconvenience.cpp
new file mode 100644
index 0000000000..ce70818042
--- /dev/null
+++ b/src/gui/opengl/platform/unix/qglxconvenience.cpp
@@ -0,0 +1,437 @@
+// Copyright (C) 2020 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+// We have to include this before the X11 headers dragged in by
+// qglxconvenience_p.h.
+#include <QtCore/qbytearray.h>
+#include <QtCore/qmetatype.h>
+#include <QtCore/qscopedpointer.h>
+#include <QtCore/qtextstream.h>
+#include <QtGui/qcolorspace.h>
+#include "qglxconvenience_p.h"
+
+#include <QtCore/qloggingcategory.h>
+#include <QtCore/qvarlengtharray.h>
+
+
+#include <GL/glxext.h>
+
+enum {
+    XFocusOut = FocusOut,
+    XFocusIn = FocusIn,
+    XKeyPress = KeyPress,
+    XKeyRelease = KeyRelease,
+    XNone = None,
+    XRevertToParent = RevertToParent,
+    XGrayScale = GrayScale,
+    XCursorShape = CursorShape
+};
+#undef FocusOut
+#undef FocusIn
+#undef KeyPress
+#undef KeyRelease
+#undef None
+#undef RevertToParent
+#undef GrayScale
+#undef CursorShape
+
+#ifdef FontChange
+#undef FontChange
+#endif
+
+#ifndef GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB
+#define GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB 0x20B2
+#endif
+
+QT_BEGIN_NAMESPACE
+
+Q_LOGGING_CATEGORY(lcGlx, "qt.glx")
+
+QList<int> qglx_buildSpec(const QSurfaceFormat &format, int drawableBit, int flags)
+{
+    QList<int> spec;
+
+    spec << GLX_LEVEL
+         << 0
+
+         << GLX_RENDER_TYPE
+         << GLX_RGBA_BIT
+
+         << GLX_RED_SIZE
+         << qMax(1, format.redBufferSize())
+
+         << GLX_GREEN_SIZE
+         << qMax(1, format.greenBufferSize())
+
+         << GLX_BLUE_SIZE
+         << qMax(1, format.blueBufferSize())
+
+         << GLX_ALPHA_SIZE
+         << qMax(0, format.alphaBufferSize());
+
+    if (format.swapBehavior() != QSurfaceFormat::SingleBuffer)
+        spec << GLX_DOUBLEBUFFER
+             << True;
+
+    if (format.stereo())
+        spec << GLX_STEREO
+             << True;
+
+    if (format.depthBufferSize() != -1)
+        spec << GLX_DEPTH_SIZE
+             << format.depthBufferSize();
+
+    if (format.stencilBufferSize() != -1)
+        spec << GLX_STENCIL_SIZE
+             << format.stencilBufferSize();
+
+    if (format.samples() > 1)
+        spec << GLX_SAMPLE_BUFFERS_ARB
+             << 1
+             << GLX_SAMPLES_ARB
+             << format.samples();
+
+    if ((flags & QGLX_SUPPORTS_SRGB) && format.colorSpace() == QColorSpace::SRgb)
+        spec << GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB
+             << True;
+
+    spec << GLX_DRAWABLE_TYPE
+         << drawableBit
+
+         << XNone;
+
+    return spec;
+}
+
+namespace  {
+struct QXcbSoftwareOpenGLEnforcer {
+    QXcbSoftwareOpenGLEnforcer() {
+        // Allow forcing LIBGL_ALWAYS_SOFTWARE for Qt 5 applications only.
+        // This is most useful with drivers that only support OpenGL 1.
+        // We need OpenGL 2, but the user probably doesn't want
+        // LIBGL_ALWAYS_SOFTWARE in OpenGL 1 apps.
+
+        if (!checkedForceSoftwareOpenGL) {
+            // If LIBGL_ALWAYS_SOFTWARE is already set, don't mess with it.
+            // We want to unset LIBGL_ALWAYS_SOFTWARE at the end so it does not
+            // get inherited by other processes, of course only if it wasn't
+            // already set before.
+            if (!qEnvironmentVariableIsEmpty("QT_XCB_FORCE_SOFTWARE_OPENGL")
+                && !qEnvironmentVariableIsSet("LIBGL_ALWAYS_SOFTWARE"))
+                forceSoftwareOpenGL = true;
+
+            checkedForceSoftwareOpenGL = true;
+        }
+
+        if (forceSoftwareOpenGL)
+            qputenv("LIBGL_ALWAYS_SOFTWARE", "1");
+    }
+
+    ~QXcbSoftwareOpenGLEnforcer() {
+        // unset LIBGL_ALWAYS_SOFTWARE now so other processes don't inherit it
+        if (forceSoftwareOpenGL)
+            qunsetenv("LIBGL_ALWAYS_SOFTWARE");
+    }
+
+    static bool checkedForceSoftwareOpenGL;
+    static bool forceSoftwareOpenGL;
+};
+
+bool QXcbSoftwareOpenGLEnforcer::checkedForceSoftwareOpenGL = false;
+bool QXcbSoftwareOpenGLEnforcer::forceSoftwareOpenGL = false;
+
+template <class T>
+struct QXlibScopedPointerDeleter {
+    static inline void cleanup(T *pointer) {
+        if (pointer)
+            XFree(pointer);
+    }
+};
+
+template <class T>
+using QXlibPointer = QScopedPointer<T, QXlibScopedPointerDeleter<T>>;
+
+template <class T>
+using QXlibArrayPointer = QScopedArrayPointer<T, QXlibScopedPointerDeleter<T>>;
+}
+
+GLXFBConfig qglx_findConfig(Display *display, int screen , QSurfaceFormat format, bool highestPixelFormat, int drawableBit, int flags)
+{
+    QXcbSoftwareOpenGLEnforcer softwareOpenGLEnforcer;
+
+    GLXFBConfig config = nullptr;
+
+    do {
+        const QList<int> spec = qglx_buildSpec(format, drawableBit, flags);
+
+        int confcount = 0;
+        QXlibArrayPointer<GLXFBConfig> configs(glXChooseFBConfig(display, screen, spec.constData(), &confcount));
+
+        if (!config && confcount > 0) {
+            config = configs[0];
+            if (highestPixelFormat && !format.hasAlpha())
+                break;
+        }
+
+        const int requestedRed = qMax(0, format.redBufferSize());
+        const int requestedGreen = qMax(0, format.greenBufferSize());
+        const int requestedBlue = qMax(0, format.blueBufferSize());
+        const int requestedAlpha = qMax(0, format.alphaBufferSize());
+
+        GLXFBConfig compatibleCandidate = nullptr;
+        for (int i = 0; i < confcount; i++) {
+            GLXFBConfig candidate = configs[i];
+
+            if ((flags & QGLX_SUPPORTS_SRGB) && format.colorSpace() == QColorSpace::SRgb) {
+                int srgbCapable = 0;
+                glXGetFBConfigAttrib(display, candidate, GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB, &srgbCapable);
+                if (!srgbCapable)
+                    continue;
+            }
+
+            QXlibPointer<XVisualInfo> visual(glXGetVisualFromFBConfig(display, candidate));
+            if (!visual)
+                continue;
+            int actualRed;
+            int actualGreen;
+            int actualBlue;
+            int actualAlpha;
+            glXGetFBConfigAttrib(display, candidate, GLX_RED_SIZE, &actualRed);
+            glXGetFBConfigAttrib(display, candidate, GLX_GREEN_SIZE, &actualGreen);
+            glXGetFBConfigAttrib(display, candidate, GLX_BLUE_SIZE, &actualBlue);
+            glXGetFBConfigAttrib(display, candidate, GLX_ALPHA_SIZE, &actualAlpha);
+            // Sometimes the visuals don't have a depth that includes the alpha channel.
+            actualAlpha = qMin(actualAlpha, visual->depth - actualRed - actualGreen - actualBlue);
+
+            if (requestedRed && actualRed < requestedRed)
+                continue;
+            if (requestedGreen && actualGreen < requestedGreen)
+                continue;
+            if (requestedBlue && actualBlue < requestedBlue)
+                continue;
+            if (requestedAlpha && actualAlpha < requestedAlpha)
+                continue;
+            if (!compatibleCandidate) // Only pick up the first compatible one offered by the server
+                compatibleCandidate = candidate;
+
+            if (requestedRed && actualRed != requestedRed)
+                continue;
+            if (requestedGreen && actualGreen != requestedGreen)
+                continue;
+            if (requestedBlue && actualBlue != requestedBlue)
+                continue;
+            if (requestedAlpha && actualAlpha != requestedAlpha)
+                continue;
+
+            return candidate;
+        }
+        if (compatibleCandidate) {
+            qCDebug(lcGlx) << "qglx_findConfig: Found non-matching but compatible FBConfig";
+            return compatibleCandidate;
+        }
+    } while (qglx_reduceFormat(&format));
+
+    if (!config)
+        qCWarning(lcGlx) << "qglx_findConfig: Failed to finding matching FBConfig for" << format;
+
+    return config;
+}
+
+XVisualInfo *qglx_findVisualInfo(Display *display, int screen, QSurfaceFormat *format, int drawableBit, int flags)
+{
+    Q_ASSERT(format);
+
+    XVisualInfo *visualInfo = nullptr;
+
+    GLXFBConfig config = qglx_findConfig(display, screen, *format, false, drawableBit, flags);
+    if (config)
+        visualInfo = glXGetVisualFromFBConfig(display, config);
+
+    if (visualInfo) {
+        qglx_surfaceFormatFromGLXFBConfig(format, display, config, flags);
+        return visualInfo;
+    }
+
+    // attempt to fall back to glXChooseVisual
+    do {
+        QList<int> attribs = qglx_buildSpec(*format, drawableBit, flags);
+        visualInfo = glXChooseVisual(display, screen, attribs.data());
+
+        if (visualInfo) {
+            qglx_surfaceFormatFromVisualInfo(format, display, visualInfo, flags);
+            return visualInfo;
+        }
+    } while (qglx_reduceFormat(format));
+
+    return visualInfo;
+}
+
+void qglx_surfaceFormatFromGLXFBConfig(QSurfaceFormat *format, Display *display, GLXFBConfig config, int flags)
+{
+    int redSize     = 0;
+    int greenSize   = 0;
+    int blueSize    = 0;
+    int alphaSize   = 0;
+    int depthSize   = 0;
+    int stencilSize = 0;
+    int sampleBuffers = 0;
+    int sampleCount = 0;
+    int stereo      = 0;
+    int srgbCapable = 0;
+
+    glXGetFBConfigAttrib(display, config, GLX_RED_SIZE,     &redSize);
+    glXGetFBConfigAttrib(display, config, GLX_GREEN_SIZE,   &greenSize);
+    glXGetFBConfigAttrib(display, config, GLX_BLUE_SIZE,    &blueSize);
+    glXGetFBConfigAttrib(display, config, GLX_ALPHA_SIZE,   &alphaSize);
+    glXGetFBConfigAttrib(display, config, GLX_DEPTH_SIZE,   &depthSize);
+    glXGetFBConfigAttrib(display, config, GLX_STENCIL_SIZE, &stencilSize);
+    glXGetFBConfigAttrib(display, config, GLX_SAMPLE_BUFFERS_ARB, &sampleBuffers);
+    glXGetFBConfigAttrib(display, config, GLX_STEREO,       &stereo);
+    if (flags & QGLX_SUPPORTS_SRGB)
+        glXGetFBConfigAttrib(display, config, GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB, &srgbCapable);
+
+    format->setRedBufferSize(redSize);
+    format->setGreenBufferSize(greenSize);
+    format->setBlueBufferSize(blueSize);
+    format->setAlphaBufferSize(alphaSize);
+    format->setDepthBufferSize(depthSize);
+    format->setStencilBufferSize(stencilSize);
+    if (sampleBuffers) {
+        glXGetFBConfigAttrib(display, config, GLX_SAMPLES_ARB, &sampleCount);
+        format->setSamples(sampleCount);
+    }
+    if (srgbCapable)
+        format->setColorSpace(QColorSpace::SRgb);
+    else
+        format->setColorSpace(QColorSpace());
+
+    format->setStereo(stereo);
+}
+
+void qglx_surfaceFormatFromVisualInfo(QSurfaceFormat *format, Display *display, XVisualInfo *visualInfo, int flags)
+{
+    int redSize     = 0;
+    int greenSize   = 0;
+    int blueSize    = 0;
+    int alphaSize   = 0;
+    int depthSize   = 0;
+    int stencilSize = 0;
+    int sampleBuffers = 0;
+    int sampleCount = 0;
+    int stereo      = 0;
+    int srgbCapable = 0;
+
+    glXGetConfig(display, visualInfo, GLX_RED_SIZE,     &redSize);
+    glXGetConfig(display, visualInfo, GLX_GREEN_SIZE,   &greenSize);
+    glXGetConfig(display, visualInfo, GLX_BLUE_SIZE,    &blueSize);
+    glXGetConfig(display, visualInfo, GLX_ALPHA_SIZE,   &alphaSize);
+    glXGetConfig(display, visualInfo, GLX_DEPTH_SIZE,   &depthSize);
+    glXGetConfig(display, visualInfo, GLX_STENCIL_SIZE, &stencilSize);
+    glXGetConfig(display, visualInfo, GLX_SAMPLE_BUFFERS_ARB, &sampleBuffers);
+    glXGetConfig(display, visualInfo, GLX_STEREO,       &stereo);
+    if (flags & QGLX_SUPPORTS_SRGB)
+        glXGetConfig(display, visualInfo, GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB, &srgbCapable);
+
+    format->setRedBufferSize(redSize);
+    format->setGreenBufferSize(greenSize);
+    format->setBlueBufferSize(blueSize);
+    format->setAlphaBufferSize(alphaSize);
+    format->setDepthBufferSize(depthSize);
+    format->setStencilBufferSize(stencilSize);
+    if (sampleBuffers) {
+        glXGetConfig(display, visualInfo, GLX_SAMPLES_ARB, &sampleCount);
+        format->setSamples(sampleCount);
+    }
+    if (srgbCapable)
+        format->setColorSpace(QColorSpace::SRgb);
+    else
+        format->setColorSpace(QColorSpace());
+
+    format->setStereo(stereo);
+}
+
+bool qglx_reduceFormat(QSurfaceFormat *format)
+{
+    Q_ASSERT(format);
+    if (std::max(std::max(format->redBufferSize(), format->greenBufferSize()), format->blueBufferSize()) > 8) {
+        if (format->alphaBufferSize() > 2) {
+            // First try to match 10 10 10 2
+            format->setAlphaBufferSize(2);
+            return true;
+        }
+
+        format->setRedBufferSize(std::min(format->redBufferSize(), 8));
+        format->setGreenBufferSize(std::min(format->greenBufferSize(), 8));
+        format->setBlueBufferSize(std::min(format->blueBufferSize(), 8));
+        return true;
+    }
+
+    if (format->redBufferSize() > 1) {
+        format->setRedBufferSize(1);
+        return true;
+    }
+
+    if (format->greenBufferSize() > 1) {
+        format->setGreenBufferSize(1);
+        return true;
+    }
+
+    if (format->blueBufferSize() > 1) {
+        format->setBlueBufferSize(1);
+        return true;
+    }
+
+    if (format->swapBehavior() != QSurfaceFormat::SingleBuffer){
+        format->setSwapBehavior(QSurfaceFormat::SingleBuffer);
+        return true;
+    }
+
+    if (format->samples() > 1) {
+        format->setSamples(qMin(16, format->samples() / 2));
+        return true;
+    }
+
+    if (format->depthBufferSize() >= 32) {
+        format->setDepthBufferSize(24);
+        return true;
+    }
+
+    if (format->depthBufferSize() > 1) {
+        format->setDepthBufferSize(1);
+        return true;
+    }
+
+    if (format->depthBufferSize() > 0) {
+        format->setDepthBufferSize(0);
+        return true;
+    }
+
+    if (format->hasAlpha()) {
+        format->setAlphaBufferSize(0);
+        return true;
+    }
+
+    if (format->stencilBufferSize() > 1) {
+        format->setStencilBufferSize(1);
+        return true;
+    }
+
+    if (format->stencilBufferSize() > 0) {
+        format->setStencilBufferSize(0);
+        return true;
+    }
+
+    if (format->stereo()) {
+        format->setStereo(false);
+        return true;
+    }
+
+    if (format->colorSpace() == QColorSpace::SRgb) {
+        format->setColorSpace(QColorSpace());
+        return true;
+    }
+
+    return false;
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/opengl/platform/unix/qglxconvenience_p.h b/src/gui/opengl/platform/unix/qglxconvenience_p.h
new file mode 100644
index 0000000000..c755356c50
--- /dev/null
+++ b/src/gui/opengl/platform/unix/qglxconvenience_p.h
@@ -0,0 +1,57 @@
+// Copyright (C) 2020 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QGLXCONVENIENCE_H
+#define QGLXCONVENIENCE_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 <QtCore/qlist.h>
+#include <QtGui/qsurfaceformat.h>
+#include <QtCore/private/qglobal_p.h>
+
+#include <X11/Xlib.h>
+#include <GL/glx.h>
+
+QT_BEGIN_NAMESPACE
+
+enum QGlxFlags
+{
+    QGLX_SUPPORTS_SRGB = 0x01
+};
+
+Q_GUI_EXPORT QList<int> qglx_buildSpec(const QSurfaceFormat &format,
+                                       int drawableBit = GLX_WINDOW_BIT,
+                                       int flags = 0);
+
+Q_GUI_EXPORT XVisualInfo *qglx_findVisualInfo(Display *display, int screen,
+                                              QSurfaceFormat *format,
+                                              int drawableBit = GLX_WINDOW_BIT,
+                                              int flags = 0);
+
+Q_GUI_EXPORT GLXFBConfig qglx_findConfig(Display *display, int screen,
+                                         QSurfaceFormat format,
+                                         bool highestPixelFormat = false,
+                                         int drawableBit = GLX_WINDOW_BIT,
+                                         int flags = 0);
+
+Q_GUI_EXPORT void qglx_surfaceFormatFromGLXFBConfig(QSurfaceFormat *format, Display *display,
+                                                    GLXFBConfig config, int flags = 0);
+
+Q_GUI_EXPORT void qglx_surfaceFormatFromVisualInfo(QSurfaceFormat *format, Display *display,
+                                                   XVisualInfo *visualInfo, int flags = 0);
+
+Q_GUI_EXPORT bool qglx_reduceFormat(QSurfaceFormat *format);
+
+QT_END_NAMESPACE
+
+#endif // QGLXCONVENIENCE_H
diff --git a/src/gui/opengl/qopengl.cpp b/src/gui/opengl/qopengl.cpp
index adca536797..587975085a 100644
--- a/src/gui/opengl/qopengl.cpp
+++ b/src/gui/opengl/qopengl.cpp
@@ -1,41 +1,5 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-****************************************************************************/
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
 #include "qopengl.h"
 #include "qopengl_p.h"
@@ -56,6 +20,8 @@
 
 QT_BEGIN_NAMESPACE
 
+using namespace Qt::StringLiterals;
+
 #if defined(QT_OPENGL_3)
 typedef const GLubyte * (QOPENGLF_APIENTRYP qt_glGetStringi)(GLenum, GLuint);
 #endif
@@ -210,10 +176,10 @@ VersionTerm VersionTerm::fromJson(const QJsonValue &v)
     if (!v.isObject())
         return result;
     const QJsonObject o = v.toObject();
-    result.number = QVersionNumber::fromString(o.value(QLatin1String("value")).toString());
-    const QString opS = o.value(QLatin1String("op")).toString();
+    result.number = QVersionNumber::fromString(o.value("value"_L1).toString());
+    const QString opS = o.value("op"_L1).toString();
     for (size_t i = 0; i < sizeof(operators) / sizeof(operators[0]); ++i) {
-        if (opS == QLatin1String(operators[i])) {
+        if (opS == QLatin1StringView(operators[i])) {
             result.op = static_cast<Operator>(i);
             break;
         }
@@ -229,29 +195,13 @@ struct OsTypeTerm
     static QString hostOs();
     static QVersionNumber hostKernelVersion() { return QVersionNumber::fromString(QSysInfo::kernelVersion()); }
     static QString hostOsRelease() {
-        QString ver;
 #ifdef Q_OS_WIN
-        const auto osver = QOperatingSystemVersion::current();
-#define Q_WINVER(major, minor) (major << 8 | minor)
-        switch (Q_WINVER(osver.majorVersion(), osver.minorVersion())) {
-        case Q_WINVER(6, 1):
-            ver = QStringLiteral("7");
-            break;
-        case Q_WINVER(6, 2):
-            ver = QStringLiteral("8");
-            break;
-        case Q_WINVER(6, 3):
-            ver = QStringLiteral("8.1");
-            break;
-        case Q_WINVER(10, 0):
-            ver = QStringLiteral("10");
-            break;
-        default:
-            break;
-        }
-#undef Q_WINVER
+        if (QOperatingSystemVersion::current() >= QOperatingSystemVersion::Windows11)
+            return u"11"_s;
+        return u"10"_s;
+#else
+        return {};
 #endif
-        return ver;
     }
 
     bool isNull() const { return type.isEmpty(); }
@@ -282,9 +232,9 @@ OsTypeTerm OsTypeTerm::fromJson(const QJsonValue &v)
     if (!v.isObject())
         return result;
     const QJsonObject o = v.toObject();
-    result.type = o.value(QLatin1String("type")).toString();
-    result.versionTerm = VersionTerm::fromJson(o.value(QLatin1String("version")));
-    result.release = o.value(QLatin1String("release")).toArray();
+    result.type = o.value("type"_L1).toString();
+    result.versionTerm = VersionTerm::fromJson(o.value("version"_L1));
+    result.release = o.value("release"_L1).toArray();
     return result;
 }
 
@@ -295,7 +245,7 @@ QString OsTypeTerm::hostOs()
     return  QStringLiteral("win");
 #elif defined(Q_OS_LINUX)
     return QStringLiteral("linux");
-#elif defined(Q_OS_OSX)
+#elif defined(Q_OS_MACOS)
     return  QStringLiteral("macosx");
 #elif defined(Q_OS_ANDROID)
     return  QStringLiteral("android");
@@ -308,8 +258,8 @@ QString OsTypeTerm::hostOs()
 static QString msgSyntaxWarning(const QJsonObject &object, const QString &what)
 {
     QString result;
-    QTextStream(&result) << "Id " << object.value(QLatin1String("id")).toInt()
-        << " (\"" << object.value(QLatin1String("description")).toString()
+    QTextStream(&result) << "Id " << object.value("id"_L1).toInt()
+        << " (\"" << object.value("description"_L1).toString()
         << "\"): " << what;
     return result;
 }
@@ -323,11 +273,11 @@ static bool matches(const QJsonObject &object,
                     const QString &osRelease,
                     const QOpenGLConfig::Gpu &gpu)
 {
-    const OsTypeTerm os = OsTypeTerm::fromJson(object.value(QLatin1String("os")));
+    const OsTypeTerm os = OsTypeTerm::fromJson(object.value("os"_L1));
     if (!os.isNull() && !os.matches(osName, kernelVersion, osRelease))
         return false;
 
-    const QJsonValue exceptionsV = object.value(QLatin1String("exceptions"));
+    const QJsonValue exceptionsV = object.value("exceptions"_L1);
     if (exceptionsV.isArray()) {
         const QJsonArray exceptionsA = exceptionsV.toArray();
         for (JsonArrayConstIt it = exceptionsA.constBegin(), cend = exceptionsA.constEnd(); it != cend; ++it) {
@@ -336,20 +286,20 @@ static bool matches(const QJsonObject &object,
         }
     }
 
-    const QJsonValue vendorV = object.value(QLatin1String("vendor_id"));
+    const QJsonValue vendorV = object.value("vendor_id"_L1);
     if (vendorV.isString()) {
         if (gpu.vendorId != vendorV.toString().toUInt(nullptr, /* base */ 0))
             return false;
     } else {
-        if (object.contains(QLatin1String("gl_vendor"))) {
-            const QByteArray glVendorV = object.value(QLatin1String("gl_vendor")).toString().toUtf8();
+        if (object.contains("gl_vendor"_L1)) {
+            const QByteArray glVendorV = object.value("gl_vendor"_L1).toString().toUtf8();
             if (!gpu.glVendor.contains(glVendorV))
                 return false;
         }
     }
 
     if (gpu.deviceId) {
-        const QJsonValue deviceIdV = object.value(QLatin1String("device_id"));
+        const QJsonValue deviceIdV = object.value("device_id"_L1);
         switch (deviceIdV.type()) {
         case QJsonValue::Array:
             if (!contains(deviceIdV.toArray(), gpu.deviceId))
@@ -360,12 +310,11 @@ static bool matches(const QJsonObject &object,
             break;
         default:
             qWarning().noquote()
-                << msgSyntaxWarning(object,
-                                    QLatin1String("Device ID must be of type array."));
+                << msgSyntaxWarning(object, "Device ID must be of type array."_L1);
         }
     }
     if (!gpu.driverVersion.isNull()) {
-        const QJsonValue driverVersionV = object.value(QLatin1String("driver_version"));
+        const QJsonValue driverVersionV = object.value("driver_version"_L1);
         switch (driverVersionV.type()) {
         case QJsonValue::Object:
             if (!VersionTerm::fromJson(driverVersionV).matches(gpu.driverVersion))
@@ -376,13 +325,12 @@ static bool matches(const QJsonObject &object,
             break;
         default:
             qWarning().noquote()
-                << msgSyntaxWarning(object,
-                                    QLatin1String("Driver version must be of type object."));
+                << msgSyntaxWarning(object, "Driver version must be of type object."_L1);
         }
     }
 
     if (!gpu.driverDescription.isEmpty()) {
-        const QJsonValue driverDescriptionV = object.value(QLatin1String("driver_description"));
+        const QJsonValue driverDescriptionV = object.value("driver_description"_L1);
         if (driverDescriptionV.isString()) {
             if (!gpu.driverDescription.contains(driverDescriptionV.toString().toUtf8()))
                 return false;
@@ -402,9 +350,9 @@ static bool readGpuFeatures(const QOpenGLConfig::Gpu &gpu,
 {
     result->clear();
     errorMessage->clear();
-    const QJsonValue entriesV = doc.object().value(QLatin1String("entries"));
+    const QJsonValue entriesV = doc.object().value("entries"_L1);
     if (!entriesV.isArray()) {
-        *errorMessage = QLatin1String("No entries read.");
+        *errorMessage = "No entries read."_L1;
         return false;
     }
 
@@ -413,7 +361,7 @@ static bool readGpuFeatures(const QOpenGLConfig::Gpu &gpu,
         if (eit->isObject()) {
             const QJsonObject object = eit->toObject();
             if (matches(object, osName, kernelVersion, osRelease, gpu)) {
-                const QJsonValue featuresListV = object.value(QLatin1String("features"));
+                const QJsonValue featuresListV = object.value("features"_L1);
                 if (featuresListV.isArray()) {
                     const QJsonArray featuresListA = featuresListV.toArray();
                     for (JsonArrayConstIt fit = featuresListA.constBegin(), fcend = featuresListA.constEnd(); fit != fcend; ++fit)
@@ -437,7 +385,8 @@ static bool readGpuFeatures(const QOpenGLConfig::Gpu &gpu,
     QJsonParseError error;
     const QJsonDocument document = QJsonDocument::fromJson(jsonAsciiData, &error);
     if (document.isNull()) {
-        const int lineNumber = 1 + jsonAsciiData.left(error.offset).count('\n');
+        const qsizetype lineNumber =
+                QByteArrayView(jsonAsciiData).left(error.offset).count('\n') + 1;
         QTextStream str(errorMessage);
         str << "Failed to parse data: \"" << error.errorString()
             << "\" at line " << lineNumber << " (offset: "
@@ -465,9 +414,9 @@ static bool readGpuFeatures(const QOpenGLConfig::Gpu &gpu,
     }
     const bool success = readGpuFeatures(gpu, osName, kernelVersion, osRelease, file.readAll(), result, errorMessage);
     if (!success) {
-        errorMessage->prepend(QLatin1String("Error reading \"")
+        errorMessage->prepend("Error reading \""_L1
                               + QDir::toNativeSeparators(fileName)
-                              + QLatin1String("\": "));
+                              + "\": "_L1);
     }
     return success;
 }
diff --git a/src/gui/opengl/qopengl.h b/src/gui/opengl/qopengl.h
index 3a2393ea58..e9a11080ce 100644
--- a/src/gui/opengl/qopengl.h
+++ b/src/gui/opengl/qopengl.h
@@ -1,41 +1,5 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-****************************************************************************/
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
 #ifndef QOPENGL_H
 #define QOPENGL_H
@@ -44,9 +8,19 @@
 
 #ifndef QT_NO_OPENGL
 
-// Windows always needs this to ensure that APIENTRY gets defined
+// On Windows we need to ensure that APIENTRY and WINGDIAPI are defined before
+// we can include gl.h. But we do not want to include <windows.h> in this public
+// Qt header, as it pollutes the global namespace with macros.
 #if defined(Q_OS_WIN)
-# include <QtCore/qt_windows.h>
+# ifndef APIENTRY
+#  define APIENTRY __stdcall
+#  define Q_UNDEF_APIENTRY
+# endif // APIENTRY
+# ifndef WINGDIAPI
+#  define WINGDIAPI __declspec(dllimport)
+#  define Q_UNDEF_WINGDIAPI
+# endif // WINGDIAPI
+# define QT_APIENTRY __stdcall
 #endif
 
 // Note: Apple is a "controlled platform" for OpenGL ABI so we
@@ -63,9 +37,9 @@
 // access to additional functionality the drivers may expose but
 // which the system headers do not.
 
-#if defined(QT_OPENGL_ES_2)
+#if QT_CONFIG(opengles2)
 # if defined(Q_OS_IOS) || defined(Q_OS_TVOS)
-#  if defined(QT_OPENGL_ES_3)
+#  if QT_CONFIG(opengles3)
 #   include <OpenGLES/ES3/gl.h>
 #   include <OpenGLES/ES3/glext.h>
 #  else
@@ -83,7 +57,7 @@ typedef void* GLeglImageOES;
 
 # elif !defined(Q_OS_DARWIN) // "uncontrolled" ES2 platforms
 
-// In "es2" builds (QT_OPENGL_ES_2) additional defines indicate GLES 3.0 or
+// In "es2" builds (QT_CONFIG(opengles2)) additional defines indicate GLES 3.0 or
 // higher is available *at build time*. In this case include the corresponding
 // header. These are backwards compatible and it should be safe to include
 // headers on top of each other, meaning that applications can include gl2.h
@@ -101,20 +75,20 @@ typedef void* GLeglImageOES;
 #   define QGL_TEMP_GLEXT_PROTO
 #  endif
 
-#  if defined(QT_OPENGL_ES_3_2)
+#  if QT_CONFIG(opengles32)
 #   include <GLES3/gl32.h>
-#  elif defined(QT_OPENGL_ES_3_1)
+#  elif QT_CONFIG(opengles31)
 #   include <GLES3/gl31.h>
-#  elif defined(QT_OPENGL_ES_3)
+#  elif QT_CONFIG(opengles3)
 #   include <GLES3/gl3.h>
 #  else
 #   include <GLES2/gl2.h>
-#endif
+#  endif
 
 #  ifdef QGL_TEMP_GLEXT_PROTO
 #   undef GL_GLEXT_PROTOTYPES
 #   undef QGL_TEMP_GLEXT_PROTO
-# endif
+#  endif
 
 /*
    Some GLES2 implementations (like the one on Harmattan) are missing the
@@ -125,9 +99,9 @@ typedef void* GLeglImageOES;
 typedef char GLchar;
 
 #  include <QtGui/qopengles2ext.h>
-# endif // Q_OS_MAC
+# endif
 #else // non-ES2 platforms
-# if defined(Q_OS_MAC)
+# if defined(Q_OS_MACOS)
 #  include <OpenGL/gl.h>
 #  define GL_DO_NOT_WARN_IF_MULTI_GL_VERSION_HEADERS_INCLUDED
 #  include <OpenGL/gl3.h>
@@ -144,11 +118,11 @@ typedef char GLchar;
 #   include <GL/gl.h>
 #  endif
 #  include <QtGui/qopenglext.h>
-# endif // Q_OS_MAC
-#endif // QT_OPENGL_ES_2
+# endif
+#endif // !QT_CONFIG(opengles2)
 
 // Desktops can support OpenGL 4.
-#if !defined(QT_OPENGL_ES_2)
+#if !QT_CONFIG(opengles2)
 #define QT_OPENGL_3
 #define QT_OPENGL_3_2
 #define QT_OPENGL_4
@@ -157,20 +131,18 @@ typedef char GLchar;
 # endif
 #endif
 
-QT_BEGIN_NAMESPACE
-
 
 // When all else fails we provide sensible fallbacks - this is needed to
 // allow compilation on OS X 10.6
-#if !defined(QT_OPENGL_ES_2)
+#if !QT_CONFIG(opengles2)
 
 // OS X 10.6 doesn't define these which are needed below
-// OS X 10.7 and later defien them in gl3.h
-#ifndef APIENTRY
-#define APIENTRY
+// OS X 10.7 and later define them in gl3.h
+#ifndef QT_APIENTRY
+#define QT_APIENTRY
 #endif
-#ifndef APIENTRYP
-#define APIENTRYP APIENTRY *
+#ifndef QT_APIENTRYP
+#define QT_APIENTRYP QT_APIENTRY *
 #endif
 #ifndef GLAPI
 #define GLAPI extern
@@ -269,15 +241,15 @@ struct _cl_event;
 #endif
 
 #ifndef GL_ARB_debug_output
-typedef void (APIENTRY *GLDEBUGPROCARB)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const GLvoid *userParam);
+typedef void (QT_APIENTRY *GLDEBUGPROCARB)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const GLvoid *userParam);
 #endif
 
 #ifndef GL_AMD_debug_output
-typedef void (APIENTRY *GLDEBUGPROCAMD)(GLuint id,GLenum category,GLenum severity,GLsizei length,const GLchar *message,GLvoid *userParam);
+typedef void (QT_APIENTRY *GLDEBUGPROCAMD)(GLuint id,GLenum category,GLenum severity,GLsizei length,const GLchar *message,GLvoid *userParam);
 #endif
 
 #ifndef GL_KHR_debug
-typedef void (APIENTRY *GLDEBUGPROC)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const GLvoid *userParam);
+typedef void (QT_APIENTRY *GLDEBUGPROC)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const GLvoid *userParam);
 #endif
 
 #ifndef GL_NV_vdpau_interop
@@ -287,14 +259,15 @@ typedef GLintptr GLvdpauSurfaceNV;
 // End of block copied from glext.h
 #endif
 
+QT_BEGIN_NAMESPACE
 
 // Types that aren't defined in all system's gl.h files.
 typedef ptrdiff_t qopengl_GLintptr;
 typedef ptrdiff_t qopengl_GLsizeiptr;
 
 
-#if defined(APIENTRY) && !defined(QOPENGLF_APIENTRY)
-#   define QOPENGLF_APIENTRY APIENTRY
+#if defined(QT_APIENTRY) && !defined(QOPENGLF_APIENTRY)
+#   define QOPENGLF_APIENTRY QT_APIENTRY
 #endif
 
 # ifndef QOPENGLF_APIENTRYP
@@ -308,6 +281,15 @@ typedef ptrdiff_t qopengl_GLsizeiptr;
 
 QT_END_NAMESPACE
 
+#ifdef Q_UNDEF_WINGDIAPI
+# undef WINGDIAPI
+# undef Q_UNDEF_WINGDIAPI
+#endif
+#ifdef Q_UNDEF_APIENTRY
+# undef APIENTRY
+# undef Q_UNDEF_APIENTRY
+#endif
+
 #endif // QT_NO_OPENGL
 
 #endif // QOPENGL_H
diff --git a/src/gui/opengl/qopengl2pexvertexarray.cpp b/src/gui/opengl/qopengl2pexvertexarray.cpp
deleted file mode 100644
index 04781f63c7..0000000000
--- a/src/gui/opengl/qopengl2pexvertexarray.cpp
+++ /dev/null
@@ -1,173 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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/gui/opengl/qopengl2pexvertexarray_p.h b/src/gui/opengl/qopengl2pexvertexarray_p.h
deleted file mode 100644
index 5dc060ff3d..0000000000
--- a/src/gui/opengl/qopengl2pexvertexarray_p.h
+++ /dev/null
@@ -1,168 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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 <QtGui/private/qtguiglobal_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/gui/opengl/qopengl_p.h b/src/gui/opengl/qopengl_p.h
index cda062eacf..a3b2be7b49 100644
--- a/src/gui/opengl/qopengl_p.h
+++ b/src/gui/opengl/qopengl_p.h
@@ -1,41 +1,5 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-****************************************************************************/
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
 #ifndef QOPENGL_P_H
 #define QOPENGL_P_H
@@ -133,9 +97,9 @@ inline bool operator!=(const QOpenGLConfig::Gpu &a, const QOpenGLConfig::Gpu &b)
     return !a.equals(b);
 }
 
-inline uint qHash(const QOpenGLConfig::Gpu &gpu)
+inline size_t qHash(const QOpenGLConfig::Gpu &gpu, size_t seed = 0)
 {
-    return qHash(gpu.vendorId) + qHash(gpu.deviceId) + qHash(gpu.driverVersion);
+    return (qHash(gpu.vendorId) + qHash(gpu.deviceId) + qHash(gpu.driverVersion)) ^ seed;
 }
 
 QT_END_NAMESPACE
diff --git a/src/gui/opengl/qopenglbuffer.cpp b/src/gui/opengl/qopenglbuffer.cpp
deleted file mode 100644
index 5387cc06e3..0000000000
--- a/src/gui/opengl/qopenglbuffer.cpp
+++ /dev/null
@@ -1,618 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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 <QtGui/qopengl.h>
-#include <QtGui/private/qopenglcontext_p.h>
-#include <QtCore/qatomic.h>
-#include "qopenglbuffer.h"
-#include <private/qopenglextensions_p.h>
-
-#ifndef GL_CONTEXT_LOST
-#define GL_CONTEXT_LOST                   0x0507
-#endif
-
-QT_BEGIN_NAMESPACE
-
-/*!
-    \class QOpenGLBuffer
-    \brief The QOpenGLBuffer class provides functions for creating and managing OpenGL buffer objects.
-    \since 5.0
-    \ingroup painting-3D
-    \inmodule QtGui
-
-    Buffer objects are created in the OpenGL server so that the
-    client application can avoid uploading vertices, indices,
-    texture image data, etc every time they are needed.
-
-    QOpenGLBuffer objects can be copied around as a reference to the
-    underlying OpenGL buffer object:
-
-    \snippet code/src_gui_opengl_qopenglbuffer.cpp 0
-
-    QOpenGLBuffer performs a shallow copy when objects are copied in this
-    manner, but does not implement copy-on-write semantics.  The original
-    object will be affected whenever the copy is modified.
-*/
-
-/*!
-    \enum QOpenGLBuffer::Type
-    This enum defines the type of OpenGL buffer object to create with QOpenGLBuffer.
-
-    \value VertexBuffer Vertex buffer object for use when specifying
-           vertex arrays.
-    \value IndexBuffer Index buffer object for use with \c{glDrawElements()}.
-    \value PixelPackBuffer Pixel pack buffer object for reading pixel
-           data from the OpenGL server (for example, with \c{glReadPixels()}).
-           Not supported under OpenGL/ES.
-    \value PixelUnpackBuffer Pixel unpack buffer object for writing pixel
-           data to the OpenGL server (for example, with \c{glTexImage2D()}).
-           Not supported under OpenGL/ES.
-*/
-
-/*!
-    \enum QOpenGLBuffer::UsagePattern
-    This enum defines the usage pattern of a QOpenGLBuffer object.
-
-    \value StreamDraw The data will be set once and used a few times
-           for drawing operations.  Under OpenGL/ES 1.1 this is identical
-           to StaticDraw.
-    \value StreamRead The data will be set once and used a few times
-           for reading data back from the OpenGL server.  Not supported
-           under OpenGL/ES.
-    \value StreamCopy The data will be set once and used a few times
-           for reading data back from the OpenGL server for use in further
-           drawing operations.  Not supported under OpenGL/ES.
-    \value StaticDraw The data will be set once and used many times
-           for drawing operations.
-    \value StaticRead The data will be set once and used many times
-           for reading data back from the OpenGL server.  Not supported
-           under OpenGL/ES.
-    \value StaticCopy The data will be set once and used many times
-           for reading data back from the OpenGL server for use in further
-           drawing operations.  Not supported under OpenGL/ES.
-    \value DynamicDraw The data will be modified repeatedly and used
-           many times for drawing operations.
-    \value DynamicRead The data will be modified repeatedly and used
-           many times for reading data back from the OpenGL server.
-           Not supported under OpenGL/ES.
-    \value DynamicCopy The data will be modified repeatedly and used
-           many times for reading data back from the OpenGL server for
-           use in further drawing operations.  Not supported under OpenGL/ES.
-*/
-
-/*!
-    \enum QOpenGLBuffer::Access
-    This enum defines the access mode for QOpenGLBuffer::map().
-
-    \value ReadOnly The buffer will be mapped for reading only.
-    \value WriteOnly The buffer will be mapped for writing only.
-    \value ReadWrite The buffer will be mapped for reading and writing.
-*/
-
-/*!
-    \enum QOpenGLBuffer::RangeAccessFlag
-    This enum defines the access mode bits for QOpenGLBuffer::mapRange().
-
-    \value RangeRead The buffer will be mapped for reading.
-    \value RangeWrite The buffer will be mapped for writing.
-    \value RangeInvalidate Discard the previous contents of the specified range.
-    \value RangeInvalidateBuffer Discard the previous contents of the entire buffer.
-    \value RangeFlushExplicit Indicates that modifications are to be flushed explicitly via \c glFlushMappedBufferRange.
-    \value RangeUnsynchronized Indicates that pending operations should not be synchronized before returning from mapRange().
-*/
-
-class QOpenGLBufferPrivate
-{
-public:
-    QOpenGLBufferPrivate(QOpenGLBuffer::Type t)
-        : ref(1),
-          type(t),
-          guard(nullptr),
-          usagePattern(QOpenGLBuffer::StaticDraw),
-          actualUsagePattern(QOpenGLBuffer::StaticDraw),
-          funcs(nullptr)
-    {
-    }
-
-    QAtomicInt ref;
-    QOpenGLBuffer::Type type;
-    QOpenGLSharedResourceGuard *guard;
-    QOpenGLBuffer::UsagePattern usagePattern;
-    QOpenGLBuffer::UsagePattern actualUsagePattern;
-    QOpenGLExtensions *funcs;
-};
-
-/*!
-    Constructs a new buffer object of type QOpenGLBuffer::VertexBuffer.
-
-    Note: this constructor just creates the QOpenGLBuffer instance.  The actual
-    buffer object in the OpenGL server is not created until create() is called.
-
-    \sa create()
-*/
-QOpenGLBuffer::QOpenGLBuffer()
-    : d_ptr(new QOpenGLBufferPrivate(QOpenGLBuffer::VertexBuffer))
-{
-}
-
-/*!
-    Constructs a new buffer object of \a type.
-
-    Note: this constructor just creates the QOpenGLBuffer instance.  The actual
-    buffer object in the OpenGL server is not created until create() is called.
-
-    \sa create()
-*/
-QOpenGLBuffer::QOpenGLBuffer(QOpenGLBuffer::Type type)
-    : d_ptr(new QOpenGLBufferPrivate(type))
-{
-}
-
-/*!
-    Constructs a shallow copy of \a other.
-
-    Note: QOpenGLBuffer does not implement copy-on-write semantics,
-    so \a other will be affected whenever the copy is modified.
-*/
-QOpenGLBuffer::QOpenGLBuffer(const QOpenGLBuffer &other)
-    : d_ptr(other.d_ptr)
-{
-    d_ptr->ref.ref();
-}
-
-/*!
-    Destroys this buffer object, including the storage being
-    used in the OpenGL server.
-*/
-QOpenGLBuffer::~QOpenGLBuffer()
-{
-    if (!d_ptr->ref.deref()) {
-        destroy();
-        delete d_ptr;
-    }
-}
-
-/*!
-    Assigns a shallow copy of \a other to this object.
-
-    Note: QOpenGLBuffer does not implement copy-on-write semantics,
-    so \a other will be affected whenever the copy is modified.
-*/
-QOpenGLBuffer &QOpenGLBuffer::operator=(const QOpenGLBuffer &other)
-{
-    if (d_ptr != other.d_ptr) {
-        other.d_ptr->ref.ref();
-        if (!d_ptr->ref.deref()) {
-            destroy();
-            delete d_ptr;
-        }
-        d_ptr = other.d_ptr;
-    }
-    return *this;
-}
-
-/*!
-    Returns the type of buffer represented by this object.
-*/
-QOpenGLBuffer::Type QOpenGLBuffer::type() const
-{
-    Q_D(const QOpenGLBuffer);
-    return d->type;
-}
-
-/*!
-    Returns the usage pattern for this buffer object.
-    The default value is StaticDraw.
-
-    \sa setUsagePattern()
-*/
-QOpenGLBuffer::UsagePattern QOpenGLBuffer::usagePattern() const
-{
-    Q_D(const QOpenGLBuffer);
-    return d->usagePattern;
-}
-
-/*!
-    Sets the usage pattern for this buffer object to \a value.
-    This function must be called before allocate() or write().
-
-    \sa usagePattern(), allocate(), write()
-*/
-void QOpenGLBuffer::setUsagePattern(QOpenGLBuffer::UsagePattern value)
-{
-    Q_D(QOpenGLBuffer);
-    d->usagePattern = d->actualUsagePattern = value;
-}
-
-namespace {
-    void freeBufferFunc(QOpenGLFunctions *funcs, GLuint id)
-    {
-        funcs->glDeleteBuffers(1, &id);
-    }
-}
-
-/*!
-    Creates the buffer object in the OpenGL server.  Returns \c true if
-    the object was created; false otherwise.
-
-    This function must be called with a current QOpenGLContext.
-    The buffer will be bound to and can only be used in
-    that context (or any other context that is shared with it).
-
-    This function will return false if the OpenGL implementation
-    does not support buffers, or there is no current QOpenGLContext.
-
-    \sa isCreated(), allocate(), write(), destroy()
-*/
-bool QOpenGLBuffer::create()
-{
-    Q_D(QOpenGLBuffer);
-    if (d->guard && d->guard->id())
-        return true;
-    QOpenGLContext *ctx = QOpenGLContext::currentContext();
-    if (ctx) {
-        delete d->funcs;
-        d->funcs = new QOpenGLExtensions(ctx);
-        GLuint bufferId = 0;
-        d->funcs->glGenBuffers(1, &bufferId);
-        if (bufferId) {
-            if (d->guard)
-                d->guard->free();
-
-            d->guard = new QOpenGLSharedResourceGuard(ctx, bufferId, freeBufferFunc);
-            return true;
-        }
-    }
-    return false;
-}
-
-/*!
-    Returns \c true if this buffer has been created; false otherwise.
-
-    \sa create(), destroy()
-*/
-bool QOpenGLBuffer::isCreated() const
-{
-    Q_D(const QOpenGLBuffer);
-    return d->guard && d->guard->id();
-}
-
-/*!
-    Destroys this buffer object, including the storage being
-    used in the OpenGL server.  All references to the buffer will
-    become invalid.
-*/
-void QOpenGLBuffer::destroy()
-{
-    Q_D(QOpenGLBuffer);
-    if (d->guard) {
-        d->guard->free();
-        d->guard = nullptr;
-    }
-    delete d->funcs;
-    d->funcs = nullptr;
-}
-
-/*!
-    Reads the \a count bytes in this buffer starting at \a offset
-    into \a data.  Returns \c true on success; false if reading from
-    the buffer is not supported.  Buffer reading is not supported
-    under OpenGL/ES.
-
-    It is assumed that this buffer has been bound to the current context.
-
-    \sa write(), bind()
-*/
-bool QOpenGLBuffer::read(int offset, void *data, int count)
-{
-#if !defined(QT_OPENGL_ES)
-    Q_D(QOpenGLBuffer);
-    if (!d->funcs->hasOpenGLFeature(QOpenGLFunctions::Buffers) || !d->guard->id())
-        return false;
-
-    while (true) { // Clear error state.
-        GLenum error = d->funcs->glGetError();
-        if (error == GL_NO_ERROR)
-            break;
-        if (error == GL_CONTEXT_LOST)
-            return false;
-    };
-    d->funcs->glGetBufferSubData(d->type, offset, count, data);
-    return d->funcs->glGetError() == GL_NO_ERROR;
-#else
-    Q_UNUSED(offset);
-    Q_UNUSED(data);
-    Q_UNUSED(count);
-    return false;
-#endif
-}
-
-/*!
-    Replaces the \a count bytes of this buffer starting at \a offset
-    with the contents of \a data.  Any other bytes in the buffer
-    will be left unmodified.
-
-    It is assumed that create() has been called on this buffer and that
-    it has been bound to the current context.
-
-    \sa create(), read(), allocate()
-*/
-void QOpenGLBuffer::write(int offset, const void *data, int count)
-{
-#ifndef QT_NO_DEBUG
-    if (!isCreated())
-        qWarning("QOpenGLBuffer::write(): buffer not created");
-#endif
-    Q_D(QOpenGLBuffer);
-    if (d->guard && d->guard->id())
-        d->funcs->glBufferSubData(d->type, offset, count, data);
-}
-
-/*!
-    Allocates \a count bytes of space to the buffer, initialized to
-    the contents of \a data.  Any previous contents will be removed.
-
-    It is assumed that create() has been called on this buffer and that
-    it has been bound to the current context.
-
-    \sa create(), read(), write()
-*/
-void QOpenGLBuffer::allocate(const void *data, int count)
-{
-#ifndef QT_NO_DEBUG
-    if (!isCreated())
-        qWarning("QOpenGLBuffer::allocate(): buffer not created");
-#endif
-    Q_D(QOpenGLBuffer);
-    if (d->guard && d->guard->id())
-        d->funcs->glBufferData(d->type, count, data, d->actualUsagePattern);
-}
-
-/*!
-    \fn void QOpenGLBuffer::allocate(int count)
-    \overload
-
-    Allocates \a count bytes of space to the buffer.  Any previous
-    contents will be removed.
-
-    It is assumed that create() has been called on this buffer and that
-    it has been bound to the current context.
-
-    \sa create(), write()
-*/
-
-/*!
-    Binds the buffer associated with this object to the current
-    OpenGL context.  Returns \c false if binding was not possible, usually because
-    type() is not supported on this OpenGL implementation.
-
-    The buffer must be bound to the same QOpenGLContext current when create()
-    was called, or to another QOpenGLContext that is sharing with it.
-    Otherwise, false will be returned from this function.
-
-    \sa release(), create()
-*/
-bool QOpenGLBuffer::bind()
-{
-#ifndef QT_NO_DEBUG
-    if (!isCreated())
-        qWarning("QOpenGLBuffer::bind(): buffer not created");
-#endif
-    Q_D(const QOpenGLBuffer);
-    GLuint bufferId = d->guard ? d->guard->id() : 0;
-    if (bufferId) {
-        if (d->guard->group() != QOpenGLContextGroup::currentContextGroup()) {
-#ifndef QT_NO_DEBUG
-            qWarning("QOpenGLBuffer::bind: buffer is not valid in the current context");
-#endif
-            return false;
-        }
-        d->funcs->glBindBuffer(d->type, bufferId);
-        return true;
-    } else {
-        return false;
-    }
-}
-
-/*!
-    Releases the buffer associated with this object from the
-    current OpenGL context.
-
-    This function must be called with the same QOpenGLContext current
-    as when bind() was called on the buffer.
-
-    \sa bind()
-*/
-void QOpenGLBuffer::release()
-{
-#ifndef QT_NO_DEBUG
-    if (!isCreated())
-        qWarning("QOpenGLBuffer::release(): buffer not created");
-#endif
-    Q_D(const QOpenGLBuffer);
-    if (d->guard && d->guard->id())
-        d->funcs->glBindBuffer(d->type, 0);
-}
-
-/*!
-    Releases the buffer associated with \a type in the current
-    QOpenGLContext.
-
-    This function is a direct call to \c{glBindBuffer(type, 0)}
-    for use when the caller does not know which QOpenGLBuffer has
-    been bound to the context but wants to make sure that it
-    is released.
-
-    \snippet code/src_gui_opengl_qopenglbuffer.cpp 1
-*/
-void QOpenGLBuffer::release(QOpenGLBuffer::Type type)
-{
-    QOpenGLContext *ctx = QOpenGLContext::currentContext();
-    if (ctx)
-        ctx->functions()->glBindBuffer(GLenum(type), 0);
-}
-
-/*!
-    Returns the OpenGL identifier associated with this buffer; zero if
-    the buffer has not been created.
-
-    \sa isCreated()
-*/
-GLuint QOpenGLBuffer::bufferId() const
-{
-    Q_D(const QOpenGLBuffer);
-    return d->guard ? d->guard->id() : 0;
-}
-
-/*!
-    Returns the size of the data in this buffer, for reading operations.
-    Returns -1 if fetching the buffer size is not supported, or the
-    buffer has not been created.
-
-    It is assumed that this buffer has been bound to the current context.
-
-    \sa isCreated(), bind()
-*/
-int QOpenGLBuffer::size() const
-{
-    Q_D(const QOpenGLBuffer);
-    if (!d->guard || !d->guard->id())
-        return -1;
-    GLint value = -1;
-    d->funcs->glGetBufferParameteriv(d->type, GL_BUFFER_SIZE, &value);
-    return value;
-}
-
-/*!
-    Maps the contents of this buffer into the application's memory
-    space and returns a pointer to it.  Returns null if memory
-    mapping is not possible.  The \a access parameter indicates the
-    type of access to be performed.
-
-    It is assumed that create() has been called on this buffer and that
-    it has been bound to the current context.
-
-    \note This function is only supported under OpenGL ES 2.0 or
-    earlier if the \c GL_OES_mapbuffer extension is present.
-
-    \note On OpenGL ES 3.0 and newer, or, in case if desktop OpenGL,
-    if \c GL_ARB_map_buffer_range is supported, this function uses
-    \c glMapBufferRange instead of \c glMapBuffer.
-
-    \sa unmap(), create(), bind(), mapRange()
-*/
-void *QOpenGLBuffer::map(QOpenGLBuffer::Access access)
-{
-    Q_D(QOpenGLBuffer);
-#ifndef QT_NO_DEBUG
-    if (!isCreated())
-        qWarning("QOpenGLBuffer::map(): buffer not created");
-#endif
-    if (!d->guard || !d->guard->id())
-        return nullptr;
-    if (d->funcs->hasOpenGLExtension(QOpenGLExtensions::MapBufferRange)) {
-        QOpenGLBuffer::RangeAccessFlags rangeAccess;
-        switch (access) {
-        case QOpenGLBuffer::ReadOnly:
-            rangeAccess = QOpenGLBuffer::RangeRead;
-            break;
-        case QOpenGLBuffer::WriteOnly:
-            rangeAccess = QOpenGLBuffer::RangeWrite;
-            break;
-        case QOpenGLBuffer::ReadWrite:
-            rangeAccess = QOpenGLBuffer::RangeRead | QOpenGLBuffer::RangeWrite;
-            break;
-        }
-        return d->funcs->glMapBufferRange(d->type, 0, size(), rangeAccess);
-    } else {
-        return d->funcs->glMapBuffer(d->type, access);
-    }
-}
-
-/*!
-    Maps the range specified by \a offset and \a count of the contents
-    of this buffer into the application's memory space and returns a
-    pointer to it.  Returns null if memory mapping is not possible.
-    The \a access parameter specifies a combination of access flags.
-
-    It is assumed that create() has been called on this buffer and that
-    it has been bound to the current context.
-
-    \note This function is not available on OpenGL ES 2.0 and earlier.
-
-    \sa unmap(), create(), bind()
- */
-void *QOpenGLBuffer::mapRange(int offset, int count, QOpenGLBuffer::RangeAccessFlags access)
-{
-    Q_D(QOpenGLBuffer);
-#ifndef QT_NO_DEBUG
-    if (!isCreated())
-        qWarning("QOpenGLBuffer::mapRange(): buffer not created");
-#endif
-    if (!d->guard || !d->guard->id())
-        return nullptr;
-    return d->funcs->glMapBufferRange(d->type, offset, count, access);
-}
-
-/*!
-    Unmaps the buffer after it was mapped into the application's
-    memory space with a previous call to map().  Returns \c true if
-    the unmap succeeded; false otherwise.
-
-    It is assumed that this buffer has been bound to the current context,
-    and that it was previously mapped with map().
-
-    \note This function is only supported under OpenGL ES 2.0 and
-    earlier if the \c{GL_OES_mapbuffer} extension is present.
-
-    \sa map()
-*/
-bool QOpenGLBuffer::unmap()
-{
-    Q_D(QOpenGLBuffer);
-#ifndef QT_NO_DEBUG
-    if (!isCreated())
-        qWarning("QOpenGLBuffer::unmap(): buffer not created");
-#endif
-    if (!d->guard || !d->guard->id())
-        return false;
-    return d->funcs->glUnmapBuffer(d->type) == GL_TRUE;
-}
-
-QT_END_NAMESPACE
diff --git a/src/gui/opengl/qopenglbuffer.h b/src/gui/opengl/qopenglbuffer.h
deleted file mode 100644
index a810783731..0000000000
--- a/src/gui/opengl/qopenglbuffer.h
+++ /dev/null
@@ -1,145 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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 QOPENGLBUFFER_H
-#define QOPENGLBUFFER_H
-
-#include <QtGui/qtguiglobal.h>
-
-#ifndef QT_NO_OPENGL
-
-#include <QtCore/qscopedpointer.h>
-#include <QtGui/qopengl.h>
-
-QT_BEGIN_NAMESPACE
-
-
-class QOpenGLBufferPrivate;
-
-class Q_GUI_EXPORT QOpenGLBuffer
-{
-public:
-    enum Type
-    {
-        VertexBuffer        = 0x8892, // GL_ARRAY_BUFFER
-        IndexBuffer         = 0x8893, // GL_ELEMENT_ARRAY_BUFFER
-        PixelPackBuffer     = 0x88EB, // GL_PIXEL_PACK_BUFFER
-        PixelUnpackBuffer   = 0x88EC  // GL_PIXEL_UNPACK_BUFFER
-    };
-
-    QOpenGLBuffer();
-    explicit QOpenGLBuffer(QOpenGLBuffer::Type type);
-    QOpenGLBuffer(const QOpenGLBuffer &other);
-    ~QOpenGLBuffer();
-
-    QOpenGLBuffer &operator=(const QOpenGLBuffer &other);
-
-    enum UsagePattern
-    {
-        StreamDraw          = 0x88E0, // GL_STREAM_DRAW
-        StreamRead          = 0x88E1, // GL_STREAM_READ
-        StreamCopy          = 0x88E2, // GL_STREAM_COPY
-        StaticDraw          = 0x88E4, // GL_STATIC_DRAW
-        StaticRead          = 0x88E5, // GL_STATIC_READ
-        StaticCopy          = 0x88E6, // GL_STATIC_COPY
-        DynamicDraw         = 0x88E8, // GL_DYNAMIC_DRAW
-        DynamicRead         = 0x88E9, // GL_DYNAMIC_READ
-        DynamicCopy         = 0x88EA  // GL_DYNAMIC_COPY
-    };
-
-    enum Access
-    {
-        ReadOnly            = 0x88B8, // GL_READ_ONLY
-        WriteOnly           = 0x88B9, // GL_WRITE_ONLY
-        ReadWrite           = 0x88BA  // GL_READ_WRITE
-    };
-
-    enum RangeAccessFlag
-    {
-        RangeRead             = 0x0001, // GL_MAP_READ_BIT
-        RangeWrite            = 0x0002, // GL_MAP_WRITE_BIT
-        RangeInvalidate       = 0x0004, // GL_MAP_INVALIDATE_RANGE_BIT
-        RangeInvalidateBuffer = 0x0008, // GL_MAP_INVALIDATE_BUFFER_BIT
-        RangeFlushExplicit    = 0x0010, // GL_MAP_FLUSH_EXPLICIT_BIT
-        RangeUnsynchronized   = 0x0020  // GL_MAP_UNSYNCHRONIZED_BIT
-    };
-    Q_DECLARE_FLAGS(RangeAccessFlags, RangeAccessFlag)
-
-    QOpenGLBuffer::Type type() const;
-
-    QOpenGLBuffer::UsagePattern usagePattern() const;
-    void setUsagePattern(QOpenGLBuffer::UsagePattern value);
-
-    bool create();
-    bool isCreated() const;
-
-    void destroy();
-
-    bool bind();
-    void release();
-
-    static void release(QOpenGLBuffer::Type type);
-
-    GLuint bufferId() const;
-
-    int size() const;
-
-    bool read(int offset, void *data, int count);
-    void write(int offset, const void *data, int count);
-
-    void allocate(const void *data, int count);
-    inline void allocate(int count) { allocate(nullptr, count); }
-
-    void *map(QOpenGLBuffer::Access access);
-    void *mapRange(int offset, int count, QOpenGLBuffer::RangeAccessFlags access);
-    bool unmap();
-
-private:
-    QOpenGLBufferPrivate *d_ptr;
-
-    Q_DECLARE_PRIVATE(QOpenGLBuffer)
-};
-
-Q_DECLARE_OPERATORS_FOR_FLAGS(QOpenGLBuffer::RangeAccessFlags)
-
-QT_END_NAMESPACE
-
-#endif // QT_NO_OPENGL
-
-#endif
diff --git a/src/gui/opengl/qopenglcustomshaderstage.cpp b/src/gui/opengl/qopenglcustomshaderstage.cpp
deleted file mode 100644
index a95a0a5767..0000000000
--- a/src/gui/opengl/qopenglcustomshaderstage.cpp
+++ /dev/null
@@ -1,137 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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/gui/opengl/qopenglcustomshaderstage_p.h b/src/gui/opengl/qopenglcustomshaderstage_p.h
deleted file mode 100644
index ce3e9efd23..0000000000
--- a/src/gui/opengl/qopenglcustomshaderstage_p.h
+++ /dev/null
@@ -1,90 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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 <QtGui/private/qtguiglobal_p.h>
-#include <QOpenGLShaderProgram>
-
-QT_BEGIN_NAMESPACE
-
-
-class QPainter;
-class QOpenGLCustomShaderStagePrivate;
-class Q_GUI_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/gui/opengl/qopenglengineshadermanager.cpp b/src/gui/opengl/qopenglengineshadermanager.cpp
deleted file mode 100644
index a569975486..0000000000
--- a/src/gui/opengl/qopenglengineshadermanager.cpp
+++ /dev/null
@@ -1,898 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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 "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/gui/opengl/qopenglengineshadermanager_p.h b/src/gui/opengl/qopenglengineshadermanager_p.h
deleted file mode 100644
index 14c79f5de3..0000000000
--- a/src/gui/opengl/qopenglengineshadermanager_p.h
+++ /dev/null
@@ -1,507 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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 <QtGui/private/qtguiglobal_p.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_GUI_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_GUI_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/gui/opengl/qopenglengineshadersource_p.h b/src/gui/opengl/qopenglengineshadersource_p.h
deleted file mode 100644
index 3ac599b6c2..0000000000
--- a/src/gui/opengl/qopenglengineshadersource_p.h
+++ /dev/null
@@ -1,970 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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 <QtGui/private/qtguiglobal_p.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/gui/opengl/qopenglext.h b/src/gui/opengl/qopenglext.h
index e3f9205619..8264f9d357 100644
--- a/src/gui/opengl/qopenglext.h
+++ b/src/gui/opengl/qopenglext.h
@@ -44,7 +44,7 @@ extern "C" {
 #ifndef WIN32_LEAN_AND_MEAN
 #define WIN32_LEAN_AND_MEAN 1
 #endif
-#include <windows.h>
+#include <qt_windows.h>
 #endif
 
 #ifndef APIENTRY
diff --git a/src/gui/opengl/qopenglextensions_p.h b/src/gui/opengl/qopenglextensions_p.h
index 137f1e831f..a6c4a68c6c 100644
--- a/src/gui/opengl/qopenglextensions_p.h
+++ b/src/gui/opengl/qopenglextensions_p.h
@@ -1,41 +1,5 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-****************************************************************************/
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
 #ifndef QOPENGL_EXTENSIONS_P_H
 #define QOPENGL_EXTENSIONS_P_H
@@ -92,6 +56,12 @@ public:
         DiscardFramebuffer      = 0x00400000,
         Sized16Formats          = 0x00800000,
         TextureSwizzle          = 0x01000000,
+        StandardDerivatives     = 0x02000000,
+        ASTCTextureCompression  = 0x04000000,
+        ETC2TextureCompression  = 0x08000000,
+        HalfFloatVertex         = 0x10000000,
+        MultiView               = 0x20000000,
+        MultiViewExtended       = 0x40000000
     };
     Q_DECLARE_FLAGS(OpenGLExtensions, OpenGLExtension)
 
@@ -100,9 +70,9 @@ public:
 
     GLvoid *glMapBuffer(GLenum target, GLenum access);
     void glGetBufferSubData(GLenum target, qopengl_GLintptr offset, qopengl_GLsizeiptr size, GLvoid *data);
-    void glDiscardFramebufferEXT (GLenum target, GLsizei numAttachments, const GLenum *attachments);
 
     void flushShared();
+    void discardFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments);
 
     QOpenGLExtensionsPrivate *d() const;
 
@@ -147,14 +117,6 @@ inline void QOpenGLExtensions::glGetBufferSubData(GLenum target, qopengl_GLintpt
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
-
-inline void QOpenGLExtensions::glDiscardFramebufferEXT (GLenum target, GLsizei numAttachments, const GLenum *attachments)
-{
-    Q_D(QOpenGLExtensions);
-    Q_ASSERT(QOpenGLExtensions::isInitialized(d));
-    d->DiscardFramebuffer(target,numAttachments, attachments);
-    Q_OPENGL_FUNCTIONS_DEBUG
-}
 QT_END_NAMESPACE
 
 #endif // QOPENGL_EXTENSIONS_P_H
diff --git a/src/gui/opengl/qopenglextrafunctions.h b/src/gui/opengl/qopenglextrafunctions.h
index a68e269065..e2608e9946 100644
--- a/src/gui/opengl/qopenglextrafunctions.h
+++ b/src/gui/opengl/qopenglextrafunctions.h
@@ -1,41 +1,5 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-****************************************************************************/
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
 #ifndef QOPENGLEXTRAFUNCTIONS_H
 #define QOPENGLEXTRAFUNCTIONS_H
@@ -53,8 +17,8 @@
 #endif
 
 // GLES build without having included gl32.h -> GLDEBUGPROC is still need for the protos, define it here
-#if defined(QT_OPENGL_ES_2) && !defined(QT_OPENGL_ES_3_2)
-typedef void (QOPENGLF_APIENTRYP  *GLDEBUGPROC)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam);
+#if QT_CONFIG(opengles2) && !QT_CONFIG(opengles32)
+typedef void (QOPENGLF_APIENTRY  *GLDEBUGPROC)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam);
 #endif
 
 QT_BEGIN_NAMESPACE
diff --git a/src/gui/opengl/qopenglframebufferobject.cpp b/src/gui/opengl/qopenglframebufferobject.cpp
deleted file mode 100644
index d7a6d32218..0000000000
--- a/src/gui/opengl/qopenglframebufferobject.cpp
+++ /dev/null
@@ -1,1857 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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 "qopenglframebufferobject.h"
-#include "qopenglframebufferobject_p.h"
-
-#include <qdebug.h>
-#include <private/qopengl_p.h>
-#include <private/qopenglcontext_p.h>
-#include <private/qopenglextensions_p.h>
-#include <private/qfont_p.h>
-
-#include <qwindow.h>
-#include <qimage.h>
-#include <QtCore/qbytearray.h>
-
-QT_BEGIN_NAMESPACE
-
-#ifndef QT_NO_DEBUG
-#define QT_RESET_GLERROR()                                \
-{                                                         \
-    while (true) {\
-        GLenum error = QOpenGLContext::currentContext()->functions()->glGetError(); \
-        if (error == GL_NO_ERROR || error == GL_CONTEXT_LOST) \
-            break; \
-    } \
-}
-#define QT_CHECK_GLERROR()                                \
-{                                                         \
-    GLenum err = QOpenGLContext::currentContext()->functions()->glGetError(); \
-    if (err != GL_NO_ERROR && err != GL_CONTEXT_LOST) {                             \
-        qDebug("[%s line %d] OpenGL Error: %d",           \
-               __FILE__, __LINE__, (int)err);             \
-    }                                                     \
-}
-#else
-#define QT_RESET_GLERROR() {}
-#define QT_CHECK_GLERROR() {}
-#endif
-
-#ifndef GL_MAX_SAMPLES
-#define GL_MAX_SAMPLES 0x8D57
-#endif
-
-#ifndef GL_RENDERBUFFER_SAMPLES
-#define GL_RENDERBUFFER_SAMPLES 0x8CAB
-#endif
-
-#ifndef GL_DEPTH24_STENCIL8
-#define GL_DEPTH24_STENCIL8 0x88F0
-#endif
-
-#ifndef GL_DEPTH_COMPONENT24
-#define GL_DEPTH_COMPONENT24 0x81A6
-#endif
-
-#ifndef GL_DEPTH_COMPONENT24_OES
-#define GL_DEPTH_COMPONENT24_OES 0x81A6
-#endif
-
-#ifndef GL_READ_FRAMEBUFFER
-#define GL_READ_FRAMEBUFFER 0x8CA8
-#endif
-
-#ifndef GL_DRAW_FRAMEBUFFER
-#define GL_DRAW_FRAMEBUFFER 0x8CA9
-#endif
-
-#ifndef GL_RGB8
-#define GL_RGB8                           0x8051
-#endif
-
-#ifndef GL_RGB10
-#define GL_RGB10                          0x8052
-#endif
-
-#ifndef GL_RGB16
-#define GL_RGB16                          0x8054
-#endif
-
-#ifndef GL_RGBA8
-#define GL_RGBA8                          0x8058
-#endif
-
-#ifndef GL_RGB10_A2
-#define GL_RGB10_A2                       0x8059
-#endif
-
-#ifndef GL_RGBA16
-#define GL_RGBA16                         0x805B
-#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_CONTEXT_LOST
-#define GL_CONTEXT_LOST                   0x0507
-#endif
-
-#ifndef GL_DEPTH_STENCIL_ATTACHMENT
-#define GL_DEPTH_STENCIL_ATTACHMENT       0x821A
-#endif
-
-#ifndef GL_DEPTH_STENCIL
-#define GL_DEPTH_STENCIL                  0x84F9
-#endif
-
-
-
-/*!
-    \class QOpenGLFramebufferObjectFormat
-    \brief The QOpenGLFramebufferObjectFormat class specifies the format of an OpenGL
-    framebuffer object.
-    \inmodule QtGui
-
-    \since 5.0
-
-    \ingroup painting-3D
-
-    A framebuffer object has several characteristics:
-    \list
-    \li \l{setSamples()}{Number of samples per pixels.}
-    \li \l{setAttachment()}{Depth and/or stencil attachments.}
-    \li \l{setTextureTarget()}{Texture target.}
-    \li \l{setInternalTextureFormat()}{Internal texture format.}
-    \endlist
-
-    Note that the desired attachments or number of samples per pixels might not
-    be supported by the hardware driver. Call QOpenGLFramebufferObject::format()
-    after creating a QOpenGLFramebufferObject to find the exact format that was
-    used to create the frame buffer object.
-
-    \sa QOpenGLFramebufferObject
-*/
-
-/*!
-    \internal
-*/
-void QOpenGLFramebufferObjectFormat::detach()
-{
-    if (d->ref.loadRelaxed() != 1) {
-        QOpenGLFramebufferObjectFormatPrivate *newd
-            = new QOpenGLFramebufferObjectFormatPrivate(d);
-        if (!d->ref.deref())
-            delete d;
-        d = newd;
-    }
-}
-
-/*!
-    Creates a QOpenGLFramebufferObjectFormat object for specifying
-    the format of an OpenGL framebuffer object.
-
-    By default the format specifies a non-multisample framebuffer object with no
-    depth/stencil attachments, texture target \c GL_TEXTURE_2D, and internal format \c GL_RGBA8.
-    On OpenGL/ES systems, the default internal format is \c GL_RGBA.
-
-    \sa samples(), attachment(), internalTextureFormat()
-*/
-
-QOpenGLFramebufferObjectFormat::QOpenGLFramebufferObjectFormat()
-{
-    d = new QOpenGLFramebufferObjectFormatPrivate;
-}
-
-/*!
-    Constructs a copy of \a other.
-*/
-
-QOpenGLFramebufferObjectFormat::QOpenGLFramebufferObjectFormat(const QOpenGLFramebufferObjectFormat &other)
-{
-    d = other.d;
-    d->ref.ref();
-}
-
-/*!
-    Assigns \a other to this object.
-*/
-
-QOpenGLFramebufferObjectFormat &QOpenGLFramebufferObjectFormat::operator=(const QOpenGLFramebufferObjectFormat &other)
-{
-    if (d != other.d) {
-        other.d->ref.ref();
-        if (!d->ref.deref())
-            delete d;
-        d = other.d;
-    }
-    return *this;
-}
-
-/*!
-    Destroys the QOpenGLFramebufferObjectFormat.
-*/
-QOpenGLFramebufferObjectFormat::~QOpenGLFramebufferObjectFormat()
-{
-    if (!d->ref.deref())
-        delete d;
-}
-
-/*!
-    Sets the number of samples per pixel for a multisample framebuffer object
-    to \a samples.  The default sample count of 0 represents a regular
-    non-multisample framebuffer object.
-
-    If the desired amount of samples per pixel is not supported by the hardware
-    then the maximum number of samples per pixel will be used. Note that
-    multisample framebuffer objects cannot be bound as textures. Also, the
-    \c{GL_EXT_framebuffer_multisample} extension is required to create a
-    framebuffer with more than one sample per pixel.
-
-    \sa samples()
-*/
-void QOpenGLFramebufferObjectFormat::setSamples(int samples)
-{
-    detach();
-    d->samples = samples;
-}
-
-/*!
-    Returns the number of samples per pixel if a framebuffer object
-    is a multisample framebuffer object. Otherwise, returns 0.
-    The default value is 0.
-
-    \sa setSamples()
-*/
-int QOpenGLFramebufferObjectFormat::samples() const
-{
-    return d->samples;
-}
-
-/*!
-    Enables mipmapping if \a enabled is true; otherwise disables it.
-
-    Mipmapping is disabled by default.
-
-    If mipmapping is enabled, additional memory will be allocated for
-    the mipmap levels. The mipmap levels can be updated by binding the
-    texture and calling glGenerateMipmap(). Mipmapping cannot be enabled
-    for multisampled framebuffer objects.
-
-    \sa mipmap(), QOpenGLFramebufferObject::texture()
-*/
-void QOpenGLFramebufferObjectFormat::setMipmap(bool enabled)
-{
-    detach();
-    d->mipmap = enabled;
-}
-
-/*!
-    Returns \c true if mipmapping is enabled.
-
-    \sa setMipmap()
-*/
-bool QOpenGLFramebufferObjectFormat::mipmap() const
-{
-    return d->mipmap;
-}
-
-/*!
-    Sets the attachment configuration of a framebuffer object to \a attachment.
-
-    \sa attachment()
-*/
-void QOpenGLFramebufferObjectFormat::setAttachment(QOpenGLFramebufferObject::Attachment attachment)
-{
-    detach();
-    d->attachment = attachment;
-}
-
-/*!
-    Returns the configuration of the depth and stencil buffers attached to
-    a framebuffer object.  The default is QOpenGLFramebufferObject::NoAttachment.
-
-    \sa setAttachment()
-*/
-QOpenGLFramebufferObject::Attachment QOpenGLFramebufferObjectFormat::attachment() const
-{
-    return d->attachment;
-}
-
-/*!
-    Sets the texture target of the texture attached to a framebuffer object to
-    \a target. Ignored for multisample framebuffer objects.
-
-    \sa textureTarget(), samples()
-*/
-void QOpenGLFramebufferObjectFormat::setTextureTarget(GLenum target)
-{
-    detach();
-    d->target = target;
-}
-
-/*!
-    Returns the texture target of the texture attached to a framebuffer object.
-    Ignored for multisample framebuffer objects.  The default is
-    \c GL_TEXTURE_2D.
-
-    \sa setTextureTarget(), samples()
-*/
-GLenum QOpenGLFramebufferObjectFormat::textureTarget() const
-{
-    return d->target;
-}
-
-/*!
-    Sets the internal format of a framebuffer object's texture or
-    multisample framebuffer object's color buffer to
-    \a internalTextureFormat.
-
-    \sa internalTextureFormat()
-*/
-void QOpenGLFramebufferObjectFormat::setInternalTextureFormat(GLenum internalTextureFormat)
-{
-    detach();
-    d->internal_format = internalTextureFormat;
-}
-
-/*!
-    Returns the internal format of a framebuffer object's texture or
-    multisample framebuffer object's color buffer.  The default is
-    \c GL_RGBA8 on desktop OpenGL systems, and \c GL_RGBA on
-    OpenGL/ES systems.
-
-    \sa setInternalTextureFormat()
-*/
-GLenum QOpenGLFramebufferObjectFormat::internalTextureFormat() const
-{
-    return d->internal_format;
-}
-
-/*!
-    Returns \c true if all the options of this framebuffer object format
-    are the same as \a other; otherwise returns \c false.
-*/
-bool QOpenGLFramebufferObjectFormat::operator==(const QOpenGLFramebufferObjectFormat& other) const
-{
-    if (d == other.d)
-        return true;
-    else
-        return d->equals(other.d);
-}
-
-/*!
-    Returns \c false if all the options of this framebuffer object format
-    are the same as \a other; otherwise returns \c true.
-*/
-bool QOpenGLFramebufferObjectFormat::operator!=(const QOpenGLFramebufferObjectFormat& other) const
-{
-    return !(*this == other);
-}
-
-bool QOpenGLFramebufferObjectPrivate::checkFramebufferStatus(QOpenGLContext *ctx) const
-{
-    if (!ctx)
-        return false;   // Context no longer exists.
-    GLenum status = ctx->functions()->glCheckFramebufferStatus(GL_FRAMEBUFFER);
-    switch(status) {
-    case GL_NO_ERROR:
-    case GL_FRAMEBUFFER_COMPLETE:
-        return true;
-    case GL_FRAMEBUFFER_UNSUPPORTED:
-        qDebug("QOpenGLFramebufferObject: Unsupported framebuffer format.");
-        break;
-    case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
-        qDebug("QOpenGLFramebufferObject: Framebuffer incomplete attachment.");
-        break;
-    case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
-        qDebug("QOpenGLFramebufferObject: Framebuffer incomplete, missing attachment.");
-        break;
-#ifdef GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT
-    case GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT:
-        qDebug("QOpenGLFramebufferObject: Framebuffer incomplete, duplicate attachment.");
-        break;
-#endif
-#ifdef GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS
-    case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS:
-        qDebug("QOpenGLFramebufferObject: Framebuffer incomplete, attached images must have same dimensions.");
-        break;
-#endif
-#ifdef GL_FRAMEBUFFER_INCOMPLETE_FORMATS
-    case GL_FRAMEBUFFER_INCOMPLETE_FORMATS:
-        qDebug("QOpenGLFramebufferObject: Framebuffer incomplete, attached images must have same format.");
-        break;
-#endif
-#ifdef GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER
-    case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER:
-        qDebug("QOpenGLFramebufferObject: Framebuffer incomplete, missing draw buffer.");
-        break;
-#endif
-#ifdef GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER
-    case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER:
-        qDebug("QOpenGLFramebufferObject: Framebuffer incomplete, missing read buffer.");
-        break;
-#endif
-#ifdef GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE
-    case GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE:
-        qDebug("QOpenGLFramebufferObject: Framebuffer incomplete, attachments must have same number of samples per pixel.");
-        break;
-#endif
-    default:
-        qDebug() <<"QOpenGLFramebufferObject: An undefined error has occurred: "<< status;
-        break;
-    }
-    return false;
-}
-
-namespace
-{
-    void freeFramebufferFunc(QOpenGLFunctions *funcs, GLuint id)
-    {
-        funcs->glDeleteFramebuffers(1, &id);
-    }
-
-    void freeRenderbufferFunc(QOpenGLFunctions *funcs, GLuint id)
-    {
-        funcs->glDeleteRenderbuffers(1, &id);
-    }
-
-    void freeTextureFunc(QOpenGLFunctions *funcs, GLuint id)
-    {
-        funcs->glDeleteTextures(1, &id);
-    }
-}
-
-void QOpenGLFramebufferObjectPrivate::init(QOpenGLFramebufferObject *, const QSize &size,
-                                           QOpenGLFramebufferObject::Attachment attachment,
-                                           GLenum texture_target, GLenum internal_format,
-                                           GLint samples, bool mipmap)
-{
-    QOpenGLContext *ctx = QOpenGLContext::currentContext();
-
-    funcs.initializeOpenGLFunctions();
-
-    if (!funcs.hasOpenGLFeature(QOpenGLFunctions::Framebuffers))
-        return;
-
-    // Fall back to using a normal non-msaa FBO if we don't have support for MSAA
-    if (!funcs.hasOpenGLExtension(QOpenGLExtensions::FramebufferMultisample)
-            || !funcs.hasOpenGLExtension(QOpenGLExtensions::FramebufferBlit)) {
-        samples = 0;
-    } else if (!ctx->isOpenGLES() || ctx->format().majorVersion() >= 3) {
-        GLint maxSamples;
-        funcs.glGetIntegerv(GL_MAX_SAMPLES, &maxSamples);
-        samples = qBound(0, int(samples), int(maxSamples));
-    }
-
-    colorAttachments.append(ColorAttachment(size, internal_format));
-
-    dsSize = size;
-
-    samples = qMax(0, samples);
-    requestedSamples = samples;
-
-    target = texture_target;
-
-    QT_RESET_GLERROR(); // reset error state
-    GLuint fbo = 0;
-
-    funcs.glGenFramebuffers(1, &fbo);
-    funcs.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
-
-    QOpenGLContextPrivate::get(ctx)->qgl_current_fbo_invalid = true;
-
-    QT_CHECK_GLERROR();
-
-    format.setTextureTarget(target);
-    format.setInternalTextureFormat(internal_format);
-    format.setMipmap(mipmap);
-
-    if (samples == 0)
-        initTexture(0);
-    else
-        initColorBuffer(0, &samples);
-
-    format.setSamples(int(samples));
-
-    initDepthStencilAttachments(ctx, attachment);
-
-    if (valid)
-        fbo_guard = new QOpenGLSharedResourceGuard(ctx, fbo, freeFramebufferFunc);
-    else
-        funcs.glDeleteFramebuffers(1, &fbo);
-
-    QT_CHECK_GLERROR();
-}
-
-void QOpenGLFramebufferObjectPrivate::initTexture(int idx)
-{
-    QOpenGLContext *ctx = QOpenGLContext::currentContext();
-    GLuint texture = 0;
-
-    funcs.glGenTextures(1, &texture);
-    funcs.glBindTexture(target, texture);
-
-    funcs.glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-    funcs.glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-    funcs.glTexParameteri(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-    funcs.glTexParameteri(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-
-    ColorAttachment &color(colorAttachments[idx]);
-
-    GLuint pixelType = GL_UNSIGNED_BYTE;
-    if (color.internalFormat == GL_RGB10_A2 || color.internalFormat == GL_RGB10)
-        pixelType = GL_UNSIGNED_INT_2_10_10_10_REV;
-    else if (color.internalFormat == GL_RGB16  || color.internalFormat == GL_RGBA16)
-        pixelType = GL_UNSIGNED_SHORT;
-
-    funcs.glTexImage2D(target, 0, color.internalFormat, color.size.width(), color.size.height(), 0,
-                       GL_RGBA, pixelType, nullptr);
-    if (format.mipmap()) {
-        int width = color.size.width();
-        int height = color.size.height();
-        int level = 0;
-        while (width > 1 || height > 1) {
-            width = qMax(1, width >> 1);
-            height = qMax(1, height >> 1);
-            ++level;
-            funcs.glTexImage2D(target, level, color.internalFormat, width, height, 0,
-                               GL_RGBA, pixelType, nullptr);
-        }
-    }
-    funcs.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + idx,
-                                 target, texture, 0);
-
-    QT_CHECK_GLERROR();
-    funcs.glBindTexture(target, 0);
-    valid = checkFramebufferStatus(ctx);
-    if (valid) {
-        color.guard = new QOpenGLSharedResourceGuard(ctx, texture, freeTextureFunc);
-    } else {
-        funcs.glDeleteTextures(1, &texture);
-    }
-}
-
-void QOpenGLFramebufferObjectPrivate::initColorBuffer(int idx, GLint *samples)
-{
-    QOpenGLContext *ctx = QOpenGLContext::currentContext();
-    GLuint color_buffer = 0;
-
-    ColorAttachment &color(colorAttachments[idx]);
-
-    GLenum storageFormat = color.internalFormat;
-    // ES requires a sized format. The older desktop extension does not. Correct the format on ES.
-    if (ctx->isOpenGLES()) {
-        if (color.internalFormat == GL_RGBA) {
-            if (funcs.hasOpenGLExtension(QOpenGLExtensions::Sized8Formats))
-                storageFormat = GL_RGBA8;
-            else
-                storageFormat = GL_RGBA4;
-        } else if (color.internalFormat == GL_RGB10) {
-            // GL_RGB10 is not allowed in ES for glRenderbufferStorage.
-            storageFormat = GL_RGB10_A2;
-        }
-    }
-
-    funcs.glGenRenderbuffers(1, &color_buffer);
-    funcs.glBindRenderbuffer(GL_RENDERBUFFER, color_buffer);
-    funcs.glRenderbufferStorageMultisample(GL_RENDERBUFFER, *samples, storageFormat, color.size.width(), color.size.height());
-    funcs.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + idx,
-                                    GL_RENDERBUFFER, color_buffer);
-
-    QT_CHECK_GLERROR();
-    valid = checkFramebufferStatus(ctx);
-    if (valid) {
-        // Query the actual number of samples. This can be greater than the requested
-        // value since the typically supported values are 0, 4, 8, ..., and the
-        // requests are mapped to the next supported value.
-        funcs.glGetRenderbufferParameteriv(GL_RENDERBUFFER, GL_RENDERBUFFER_SAMPLES, samples);
-        color.guard = new QOpenGLSharedResourceGuard(ctx, color_buffer, freeRenderbufferFunc);
-    } else {
-        funcs.glDeleteRenderbuffers(1, &color_buffer);
-    }
-}
-
-void QOpenGLFramebufferObjectPrivate::initDepthStencilAttachments(QOpenGLContext *ctx,
-                                                                  QOpenGLFramebufferObject::Attachment attachment)
-{
-    // Use the same sample count for all attachments. format.samples() already contains
-    // the actual number of samples for the color attachment and is not suitable. Use
-    // requestedSamples instead.
-    const int samples = requestedSamples;
-
-    // free existing attachments
-    if (depth_buffer_guard) {
-#ifdef Q_OS_WASM
-        funcs.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, 0);
-#else
-        funcs.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, 0);
-#endif
-        depth_buffer_guard->free();
-    }
-    if (stencil_buffer_guard) {
-        funcs.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, 0);
-        if (stencil_buffer_guard != depth_buffer_guard)
-            stencil_buffer_guard->free();
-    }
-
-    depth_buffer_guard = nullptr;
-    stencil_buffer_guard = nullptr;
-
-    GLuint depth_buffer = 0;
-    GLuint stencil_buffer = 0;
-
-    // In practice, a combined depth-stencil buffer is supported by all desktop platforms, while a
-    // separate stencil buffer is not. On embedded devices however, a combined depth-stencil buffer
-    // might not be supported while separate buffers are, according to QTBUG-12861.
-#ifdef Q_OS_WASM
-    // WebGL doesn't allow separately attach buffers to
-    // STENCIL_ATTACHMENT and DEPTH_ATTACHMENT
-    // QTBUG-69913
-    if (attachment == QOpenGLFramebufferObject::CombinedDepthStencil) {
-        funcs.glGenRenderbuffers(1, &depth_buffer);
-        funcs.glBindRenderbuffer(GL_RENDERBUFFER, depth_buffer);
-        Q_ASSERT(funcs.glIsRenderbuffer(depth_buffer));
-
-        if (samples != 0 ) {
-            funcs.glRenderbufferStorageMultisample(GL_RENDERBUFFER, samples,
-                                                   GL_DEPTH24_STENCIL8, dsSize.width(), dsSize.height());
-        } else {
-            funcs.glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_STENCIL,
-                                        dsSize.width(), dsSize.height());
-        }
-
-        funcs.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT,
-                                        GL_RENDERBUFFER, depth_buffer);
-
-        valid = checkFramebufferStatus(ctx);
-        if (!valid) {
-            funcs.glDeleteRenderbuffers(1, &depth_buffer);
-            depth_buffer = 0;
-        }
-    }
-#else
-    if (attachment == QOpenGLFramebufferObject::CombinedDepthStencil
-        && funcs.hasOpenGLExtension(QOpenGLExtensions::PackedDepthStencil))
-    {
-        // depth and stencil buffer needs another extension
-        funcs.glGenRenderbuffers(1, &depth_buffer);
-        funcs.glBindRenderbuffer(GL_RENDERBUFFER, depth_buffer);
-        Q_ASSERT(funcs.glIsRenderbuffer(depth_buffer));
-        if (samples != 0 && funcs.hasOpenGLExtension(QOpenGLExtensions::FramebufferMultisample))
-            funcs.glRenderbufferStorageMultisample(GL_RENDERBUFFER, samples,
-                GL_DEPTH24_STENCIL8, dsSize.width(), dsSize.height());
-        else
-            funcs.glRenderbufferStorage(GL_RENDERBUFFER,
-                GL_DEPTH24_STENCIL8, dsSize.width(), dsSize.height());
-
-        stencil_buffer = depth_buffer;
-        funcs.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
-                                     GL_RENDERBUFFER, depth_buffer);
-        funcs.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT,
-                                     GL_RENDERBUFFER, stencil_buffer);
-
-        valid = checkFramebufferStatus(ctx);
-        if (!valid) {
-            funcs.glDeleteRenderbuffers(1, &depth_buffer);
-            stencil_buffer = depth_buffer = 0;
-        }
-    }
-
-    if (depth_buffer == 0 && (attachment == QOpenGLFramebufferObject::CombinedDepthStencil
-        || (attachment == QOpenGLFramebufferObject::Depth)))
-    {
-        funcs.glGenRenderbuffers(1, &depth_buffer);
-        funcs.glBindRenderbuffer(GL_RENDERBUFFER, depth_buffer);
-        Q_ASSERT(funcs.glIsRenderbuffer(depth_buffer));
-        if (samples != 0 && funcs.hasOpenGLExtension(QOpenGLExtensions::FramebufferMultisample)) {
-            if (ctx->isOpenGLES()) {
-                if (funcs.hasOpenGLExtension(QOpenGLExtensions::Depth24))
-                    funcs.glRenderbufferStorageMultisample(GL_RENDERBUFFER, samples,
-                                                           GL_DEPTH_COMPONENT24, dsSize.width(), dsSize.height());
-                else
-                    funcs.glRenderbufferStorageMultisample(GL_RENDERBUFFER, samples,
-                                                           GL_DEPTH_COMPONENT16, dsSize.width(), dsSize.height());
-            } else {
-                funcs.glRenderbufferStorageMultisample(GL_RENDERBUFFER, samples,
-                                                       GL_DEPTH_COMPONENT, dsSize.width(), dsSize.height());
-            }
-        } else {
-            if (ctx->isOpenGLES()) {
-                if (funcs.hasOpenGLExtension(QOpenGLExtensions::Depth24)) {
-                    funcs.glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT24,
-                                                dsSize.width(), dsSize.height());
-                } else {
-                    funcs.glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16,
-                                                dsSize.width(), dsSize.height());
-                }
-            } else {
-                funcs.glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, dsSize.width(), dsSize.height());
-            }
-        }
-        funcs.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
-                                     GL_RENDERBUFFER, depth_buffer);
-        valid = checkFramebufferStatus(ctx);
-        if (!valid) {
-            funcs.glDeleteRenderbuffers(1, &depth_buffer);
-            depth_buffer = 0;
-        }
-    }
-
-    if (stencil_buffer == 0 && (attachment == QOpenGLFramebufferObject::CombinedDepthStencil)) {
-        funcs.glGenRenderbuffers(1, &stencil_buffer);
-        funcs.glBindRenderbuffer(GL_RENDERBUFFER, stencil_buffer);
-        Q_ASSERT(funcs.glIsRenderbuffer(stencil_buffer));
-
-#ifdef QT_OPENGL_ES
-        GLenum storage = GL_STENCIL_INDEX8;
-#else
-        GLenum storage = ctx->isOpenGLES() ? GL_STENCIL_INDEX8 : GL_STENCIL_INDEX;
-#endif
-
-        if (samples != 0 && funcs.hasOpenGLExtension(QOpenGLExtensions::FramebufferMultisample))
-            funcs.glRenderbufferStorageMultisample(GL_RENDERBUFFER, samples, storage, dsSize.width(), dsSize.height());
-        else
-            funcs.glRenderbufferStorage(GL_RENDERBUFFER, storage, dsSize.width(), dsSize.height());
-
-        funcs.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT,
-                                  GL_RENDERBUFFER, stencil_buffer);
-        valid = checkFramebufferStatus(ctx);
-        if (!valid) {
-            funcs.glDeleteRenderbuffers(1, &stencil_buffer);
-            stencil_buffer = 0;
-        }
-    }
-#endif //Q_OS_WASM
-
-    // The FBO might have become valid after removing the depth or stencil buffer.
-    valid = checkFramebufferStatus(ctx);
-
-#ifdef Q_OS_WASM
-    if (depth_buffer) {
-#else
-    if (depth_buffer && stencil_buffer) {
-#endif
-        fbo_attachment = QOpenGLFramebufferObject::CombinedDepthStencil;
-    } else if (depth_buffer) {
-        fbo_attachment = QOpenGLFramebufferObject::Depth;
-    } else {
-        fbo_attachment = QOpenGLFramebufferObject::NoAttachment;
-    }
-
-    if (valid) {
-        if (depth_buffer)
-            depth_buffer_guard = new QOpenGLSharedResourceGuard(ctx, depth_buffer, freeRenderbufferFunc);
-        if (stencil_buffer) {
-            if (stencil_buffer == depth_buffer)
-                stencil_buffer_guard = depth_buffer_guard;
-            else
-                stencil_buffer_guard = new QOpenGLSharedResourceGuard(ctx, stencil_buffer, freeRenderbufferFunc);
-        }
-    } else {
-        if (depth_buffer)
-            funcs.glDeleteRenderbuffers(1, &depth_buffer);
-        if (stencil_buffer && depth_buffer != stencil_buffer)
-            funcs.glDeleteRenderbuffers(1, &stencil_buffer);
-    }
-    QT_CHECK_GLERROR();
-
-    format.setAttachment(fbo_attachment);
-}
-
-/*!
-    \class QOpenGLFramebufferObject
-    \brief The QOpenGLFramebufferObject class encapsulates an OpenGL framebuffer object.
-    \since 5.0
-    \inmodule QtGui
-
-    \ingroup painting-3D
-
-    The QOpenGLFramebufferObject class encapsulates an OpenGL framebuffer
-    object, defined by the \c{GL_EXT_framebuffer_object} extension. It provides
-    a rendering surface that can be painted on with a QPainter with the help of
-    QOpenGLPaintDevice, or rendered to using native OpenGL calls. This surface
-    can be bound and used as a regular texture in your own OpenGL drawing code.
-    By default, the QOpenGLFramebufferObject class generates a 2D OpenGL
-    texture (using the \c{GL_TEXTURE_2D} target), which is used as the internal
-    rendering target.
-
-    \b{It is important to have a current OpenGL context when creating a
-    QOpenGLFramebufferObject, otherwise initialization will fail.}
-
-    Create the QOpenGLFrameBufferObject instance with the CombinedDepthStencil
-    attachment if you want QPainter to render correctly. Note that you need to
-    create a QOpenGLFramebufferObject with more than one sample per pixel for
-    primitives to be antialiased when drawing using a QPainter. To create a
-    multisample framebuffer object you should use one of the constructors that
-    take a QOpenGLFramebufferObjectFormat parameter, and set the
-    QOpenGLFramebufferObjectFormat::samples() property to a non-zero value.
-
-    For multisample framebuffer objects a color render buffer is created,
-    otherwise a texture with the specified texture target is created.
-    The color render buffer or texture will have the specified internal
-    format, and will be bound to the \c GL_COLOR_ATTACHMENT0
-    attachment in the framebuffer object.
-
-    Multiple render targets are also supported, in case the OpenGL
-    implementation supports this. Here there will be multiple textures (or, in
-    case of multisampling, renderbuffers) present and each of them will get
-    attached to \c GL_COLOR_ATTACHMENT0, \c 1, \c 2, ...
-
-    If you want to use a framebuffer object with multisampling enabled
-    as a texture, you first need to copy from it to a regular framebuffer
-    object using QOpenGLContext::blitFramebuffer().
-
-    It is possible to draw into a QOpenGLFramebufferObject using QPainter and
-    QOpenGLPaintDevice in a separate thread.
-*/
-
-
-/*!
-    \enum QOpenGLFramebufferObject::Attachment
-
-    This enum type is used to configure the depth and stencil buffers
-    attached to the framebuffer object when it is created.
-
-    \value NoAttachment         No attachment is added to the framebuffer object. Note that the
-                                OpenGL depth and stencil tests won't work when rendering to a
-                                framebuffer object without any depth or stencil buffers.
-                                This is the default value.
-
-    \value CombinedDepthStencil If the \c GL_EXT_packed_depth_stencil extension is present,
-                                a combined depth and stencil buffer is attached.
-                                If the extension is not present, only a depth buffer is attached.
-
-    \value Depth                A depth buffer is attached to the framebuffer object.
-
-    \sa attachment()
-*/
-
-static inline GLenum effectiveInternalFormat(GLenum internalFormat)
-{
-    if (!internalFormat)
-#ifdef QT_OPENGL_ES_2
-        internalFormat = GL_RGBA;
-#else
-        internalFormat = QOpenGLContext::currentContext()->isOpenGLES() ? GL_RGBA : GL_RGBA8;
-#endif
-    return internalFormat;
-}
-
-/*!
-
-    Constructs an OpenGL framebuffer object and binds a 2D OpenGL texture
-    to the buffer of the size \a size. The texture is bound to the
-    \c GL_COLOR_ATTACHMENT0 target in the framebuffer object.
-
-    The \a target parameter is used to specify the OpenGL texture
-    target. The default target is \c GL_TEXTURE_2D. Keep in mind that
-    \c GL_TEXTURE_2D textures must have a power of 2 width and height
-    (e.g. 256x512), unless you are using OpenGL 2.0 or higher.
-
-    By default, no depth and stencil buffers are attached. This behavior
-    can be toggled using one of the overloaded constructors.
-
-    The default internal texture format is \c GL_RGBA8 for desktop
-    OpenGL, and \c GL_RGBA for OpenGL/ES.
-
-    It is important that you have a current OpenGL context set when
-    creating the QOpenGLFramebufferObject, otherwise the initialization
-    will fail.
-
-    \sa size(), texture(), attachment()
-*/
-
-QOpenGLFramebufferObject::QOpenGLFramebufferObject(const QSize &size, GLenum target)
-    : d_ptr(new QOpenGLFramebufferObjectPrivate)
-{
-    Q_D(QOpenGLFramebufferObject);
-    d->init(this, size, NoAttachment, target, effectiveInternalFormat(0));
-}
-
-/*!
-
-    Constructs an OpenGL framebuffer object and binds a 2D OpenGL texture
-    to the buffer of the given \a width and \a height.
-
-    \sa size(), texture()
-*/
-QOpenGLFramebufferObject::QOpenGLFramebufferObject(int width, int height, GLenum target)
-    : QOpenGLFramebufferObject(QSize(width, height), target)
-{
-}
-
-/*!
-
-    Constructs an OpenGL framebuffer object of the given \a size based on the
-    supplied \a format.
-*/
-
-QOpenGLFramebufferObject::QOpenGLFramebufferObject(const QSize &size, const QOpenGLFramebufferObjectFormat &format)
-    : d_ptr(new QOpenGLFramebufferObjectPrivate)
-{
-    Q_D(QOpenGLFramebufferObject);
-    d->init(this, size, format.attachment(), format.textureTarget(), format.internalTextureFormat(),
-            format.samples(), format.mipmap());
-}
-
-/*!
-
-    Constructs an OpenGL framebuffer object of the given \a width and \a height
-    based on the supplied \a format.
-*/
-
-QOpenGLFramebufferObject::QOpenGLFramebufferObject(int width, int height, const QOpenGLFramebufferObjectFormat &format)
-    : QOpenGLFramebufferObject(QSize(width, height), format)
-{
-}
-
-/*!
-
-    Constructs an OpenGL framebuffer object and binds a texture to the
-    buffer of the given \a width and \a height.
-
-    The \a attachment parameter describes the depth/stencil buffer
-    configuration, \a target the texture target and \a internalFormat
-    the internal texture format. The default texture target is \c
-    GL_TEXTURE_2D, while the default internal format is \c GL_RGBA8
-    for desktop OpenGL and \c GL_RGBA for OpenGL/ES.
-
-    \sa size(), texture(), attachment()
-*/
-QOpenGLFramebufferObject::QOpenGLFramebufferObject(int width, int height, Attachment attachment,
-                                           GLenum target, GLenum internalFormat)
-    : d_ptr(new QOpenGLFramebufferObjectPrivate)
-{
-    Q_D(QOpenGLFramebufferObject);
-    d->init(this, QSize(width, height), attachment, target, effectiveInternalFormat(internalFormat));
-}
-
-/*!
-
-    Constructs an OpenGL framebuffer object and binds a texture to the
-    buffer of the given \a size.
-
-    The \a attachment parameter describes the depth/stencil buffer
-    configuration, \a target the texture target and \a internalFormat
-    the internal texture format. The default texture target is \c
-    GL_TEXTURE_2D, while the default internal format is \c GL_RGBA8
-    for desktop OpenGL and \c GL_RGBA for OpenGL/ES.
-
-    \sa size(), texture(), attachment()
-*/
-QOpenGLFramebufferObject::QOpenGLFramebufferObject(const QSize &size, Attachment attachment,
-                                           GLenum target, GLenum internalFormat)
-    : d_ptr(new QOpenGLFramebufferObjectPrivate)
-{
-    Q_D(QOpenGLFramebufferObject);
-    d->init(this, size, attachment, target, effectiveInternalFormat(internalFormat));
-}
-
-/*!
-
-    Destroys the framebuffer object and frees any allocated resources.
-*/
-QOpenGLFramebufferObject::~QOpenGLFramebufferObject()
-{
-    Q_D(QOpenGLFramebufferObject);
-    if (isBound())
-        release();
-
-    for (const auto &color : qAsConst(d->colorAttachments)) {
-        if (color.guard)
-            color.guard->free();
-    }
-    d->colorAttachments.clear();
-
-    if (d->depth_buffer_guard)
-        d->depth_buffer_guard->free();
-    if (d->stencil_buffer_guard && d->stencil_buffer_guard != d->depth_buffer_guard)
-        d->stencil_buffer_guard->free();
-    if (d->fbo_guard)
-        d->fbo_guard->free();
-
-    QOpenGLContextPrivate *contextPrv = QOpenGLContextPrivate::get(QOpenGLContext::currentContext());
-    if (contextPrv && contextPrv->qgl_current_fbo == this) {
-        contextPrv->qgl_current_fbo_invalid = true;
-        contextPrv->qgl_current_fbo = nullptr;
-    }
-}
-
-/*!
-    Creates and attaches an additional texture or renderbuffer of \a size width
-    and height.
-
-    There is always an attachment at GL_COLOR_ATTACHMENT0. Call this function
-    to set up additional attachments at GL_COLOR_ATTACHMENT1,
-    GL_COLOR_ATTACHMENT2, ...
-
-    When \a internalFormat is not \c 0, it specifies the internal format of the
-    texture or renderbuffer. Otherwise a default of GL_RGBA or GL_RGBA8 is
-    used.
-
-    \note This is only functional when multiple render targets are supported by
-    the OpenGL implementation. When that is not the case, the function will not
-    add any additional color attachments. Call
-    QOpenGLFunctions::hasOpenGLFeature() with
-    QOpenGLFunctions::MultipleRenderTargets at runtime to check if MRT is
-    supported.
-
-    \note The internal format of the color attachments may differ but there may
-    be limitations on the supported combinations, depending on the drivers.
-
-    \note The size of the color attachments may differ but rendering is limited
-    to the area that fits all the attachments, according to the OpenGL
-    specification. Some drivers may not be fully conformant in this respect,
-    however.
-
-    \since 5.6
- */
-void QOpenGLFramebufferObject::addColorAttachment(const QSize &size, GLenum internalFormat)
-{
-    Q_D(QOpenGLFramebufferObject);
-
-    if (!QOpenGLContext::currentContext()->functions()->hasOpenGLFeature(QOpenGLFunctions::MultipleRenderTargets)) {
-        qWarning("Multiple render targets not supported, ignoring extra color attachment request");
-        return;
-    }
-
-    QOpenGLFramebufferObjectPrivate::ColorAttachment color(size, effectiveInternalFormat(internalFormat));
-    d->colorAttachments.append(color);
-    const int idx = d->colorAttachments.count() - 1;
-
-    if (d->requestedSamples == 0) {
-        d->initTexture(idx);
-    } else {
-        GLint samples = d->requestedSamples;
-        d->initColorBuffer(idx, &samples);
-    }
-}
-
-/*! \overload
-
-    Creates and attaches an additional texture or renderbuffer of size \a width and \a height.
-
-    When \a internalFormat is not \c 0, it specifies the internal format of the texture or
-    renderbuffer. Otherwise a default of GL_RGBA or GL_RGBA8 is used.
-
-    \since 5.6
- */
-void QOpenGLFramebufferObject::addColorAttachment(int width, int height, GLenum internalFormat)
-{
-    addColorAttachment(QSize(width, height), internalFormat);
-}
-
-/*!
-    \fn bool QOpenGLFramebufferObject::isValid() const
-
-    Returns \c true if the framebuffer object is valid.
-
-    The framebuffer can become invalid if the initialization process
-    fails, the user attaches an invalid buffer to the framebuffer
-    object, or a non-power of two width/height is specified as the
-    texture size if the texture target is \c{GL_TEXTURE_2D}.
-    The non-power of two limitation does not apply if the OpenGL version
-    is 2.0 or higher, or if the GL_ARB_texture_non_power_of_two extension
-    is present.
-
-    The framebuffer can also become invalid if the QOpenGLContext that
-    the framebuffer was created within is destroyed and there are
-    no other shared contexts that can take over ownership of the
-    framebuffer.
-*/
-bool QOpenGLFramebufferObject::isValid() const
-{
-    Q_D(const QOpenGLFramebufferObject);
-    return d->valid && d->fbo_guard && d->fbo_guard->id();
-}
-
-/*!
-    \fn bool QOpenGLFramebufferObject::bind()
-
-    Switches rendering from the default, windowing system provided
-    framebuffer to this framebuffer object.
-    Returns \c true upon success, false otherwise.
-
-    \note If takeTexture() was called, a new texture is created and associated
-    with the framebuffer object. This is potentially expensive and changes the
-    context state (the currently bound texture).
-
-    \sa release()
-*/
-bool QOpenGLFramebufferObject::bind()
-{
-    if (!isValid())
-        return false;
-    Q_D(QOpenGLFramebufferObject);
-    QOpenGLContext *current = QOpenGLContext::currentContext();
-    if (!current)
-        return false;
-#ifdef QT_DEBUG
-    if (current->shareGroup() != d->fbo_guard->group())
-        qWarning("QOpenGLFramebufferObject::bind() called from incompatible context");
-#endif
-
-    d->funcs.glBindFramebuffer(GL_FRAMEBUFFER, d->fbo());
-
-    QOpenGLContextPrivate::get(current)->qgl_current_fbo_invalid = true;
-    QOpenGLContextPrivate::get(current)->qgl_current_fbo = this;
-
-    if (d->format.samples() == 0) {
-        // Create new textures to replace the ones stolen via takeTexture().
-        for (int i = 0; i < d->colorAttachments.count(); ++i) {
-            if (!d->colorAttachments.at(i).guard)
-                d->initTexture(i);
-        }
-    }
-
-    return d->valid;
-}
-
-/*!
-    \fn bool QOpenGLFramebufferObject::release()
-
-    Switches rendering back to the default, windowing system provided
-    framebuffer.
-    Returns \c true upon success, false otherwise.
-
-    \sa bind()
-*/
-bool QOpenGLFramebufferObject::release()
-{
-    if (!isValid())
-        return false;
-
-    QOpenGLContext *current = QOpenGLContext::currentContext();
-    if (!current)
-        return false;
-
-    Q_D(QOpenGLFramebufferObject);
-#ifdef QT_DEBUG
-    if (current->shareGroup() != d->fbo_guard->group())
-        qWarning("QOpenGLFramebufferObject::release() called from incompatible context");
-#endif
-
-    if (current) {
-        d->funcs.glBindFramebuffer(GL_FRAMEBUFFER, current->defaultFramebufferObject());
-
-        QOpenGLContextPrivate *contextPrv = QOpenGLContextPrivate::get(current);
-        contextPrv->qgl_current_fbo_invalid = true;
-        contextPrv->qgl_current_fbo = nullptr;
-    }
-
-    return true;
-}
-
-/*!
-    \fn GLuint QOpenGLFramebufferObject::texture() const
-
-    Returns the texture id for the texture attached as the default
-    rendering target in this framebuffer object. This texture id can
-    be bound as a normal texture in your own OpenGL code.
-
-    If a multisample framebuffer object is used then the value returned
-    from this function will be invalid.
-
-    When multiple textures are attached, the return value is the ID of
-    the first one.
-
-    \sa takeTexture(), textures()
-*/
-GLuint QOpenGLFramebufferObject::texture() const
-{
-    Q_D(const QOpenGLFramebufferObject);
-    return d->colorAttachments[0].guard ? d->colorAttachments[0].guard->id() : 0;
-}
-
-/*!
-    Returns the texture id for all attached textures.
-
-    If a multisample framebuffer object is used, then an empty vector is returned.
-
-    \since 5.6
-
-    \sa takeTexture(), texture()
-*/
-QVector<GLuint> QOpenGLFramebufferObject::textures() const
-{
-    Q_D(const QOpenGLFramebufferObject);
-    QVector<GLuint> ids;
-    if (d->format.samples() != 0)
-        return ids;
-    ids.reserve(d->colorAttachments.count());
-    for (const auto &color : d->colorAttachments)
-        ids.append(color.guard ? color.guard->id() : 0);
-    return ids;
-}
-
-/*!
-   \fn GLuint QOpenGLFramebufferObject::takeTexture()
-
-   Returns the texture id for the texture attached to this framebuffer
-   object. The ownership of the texture is transferred to the caller.
-
-   If the framebuffer object is currently bound, an implicit release()
-   will be done. During the next call to bind() a new texture will be
-   created.
-
-   If a multisample framebuffer object is used, then there is no
-   texture and the return value from this function will be invalid.
-   Similarly, incomplete framebuffer objects will also return 0.
-
-   \since 5.3
-
-   \sa texture(), bind(), release()
- */
-GLuint QOpenGLFramebufferObject::takeTexture()
-{
-    return takeTexture(0);
-}
-
-/*! \overload
-
-   Returns the texture id for the texture attached to the color attachment of
-   index \a colorAttachmentIndex of this framebuffer object. The ownership of
-   the texture is transferred to the caller.
-
-   When \a colorAttachmentIndex is \c 0, the behavior is identical to the
-   parameter-less variant of this function.
-
-   If the framebuffer object is currently bound, an implicit release()
-   will be done. During the next call to bind() a new texture will be
-   created.
-
-   If a multisample framebuffer object is used, then there is no
-   texture and the return value from this function will be invalid.
-   Similarly, incomplete framebuffer objects will also return 0.
-
-   \since 5.6
- */
-GLuint QOpenGLFramebufferObject::takeTexture(int colorAttachmentIndex)
-{
-    Q_D(QOpenGLFramebufferObject);
-    GLuint id = 0;
-    if (isValid() && d->format.samples() == 0 && d->colorAttachments.count() > colorAttachmentIndex) {
-        QOpenGLContext *current = QOpenGLContext::currentContext();
-        if (current && current->shareGroup() == d->fbo_guard->group() && isBound())
-            release();
-        auto &guard = d->colorAttachments[colorAttachmentIndex].guard;
-        id = guard ? guard->id() : 0;
-        // Do not call free() on texture_guard, just null it out.
-        // This way the texture will not be deleted when the guard is destroyed.
-        guard = nullptr;
-    }
-    return id;
-}
-
-/*!
-    \return the size of the color and depth/stencil attachments attached to
-    this framebuffer object.
-*/
-QSize QOpenGLFramebufferObject::size() const
-{
-    Q_D(const QOpenGLFramebufferObject);
-    return d->dsSize;
-}
-
-/*!
-    \return the sizes of all color attachments attached to this framebuffer
-    object.
-
-    \since 5.6
-*/
-QVector<QSize> QOpenGLFramebufferObject::sizes() const
-{
-    Q_D(const QOpenGLFramebufferObject);
-    QVector<QSize> sz;
-    sz.reserve(d->colorAttachments.size());
-    for (const auto &color : d->colorAttachments)
-        sz.append(color.size);
-    return sz;
-}
-
-/*!
-    \fn int QOpenGLFramebufferObject::width() const
-
-    Returns the width of the framebuffer object attachments.
-*/
-
-/*!
-    \fn int QOpenGLFramebufferObject::height() const
-
-    Returns the height of the framebuffer object attachments.
-*/
-
-/*!
-    Returns the format of this framebuffer object.
-*/
-QOpenGLFramebufferObjectFormat QOpenGLFramebufferObject::format() const
-{
-    Q_D(const QOpenGLFramebufferObject);
-    return d->format;
-}
-
-static inline QImage qt_gl_read_framebuffer_rgba8(const QSize &size, bool include_alpha, QOpenGLContext *context)
-{
-    QOpenGLFunctions *funcs = context->functions();
-    const int w = size.width();
-    const int h = size.height();
-    bool isOpenGL12orBetter = !context->isOpenGLES() && (context->format().majorVersion() >= 2 || context->format().minorVersion() >= 2);
-    if (isOpenGL12orBetter) {
-        QImage img(size, include_alpha ? QImage::Format_ARGB32_Premultiplied : QImage::Format_RGB32);
-        funcs->glReadPixels(0, 0, w, h, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, img.bits());
-        return img;
-    }
-
-    // For OpenGL ES stick with the byte ordered format / RGBA readback format
-    // since that is the only spec mandated way. (also, skip the
-    // GL_IMPLEMENTATION_COLOR_READ_FORMAT mess since there is nothing saying a
-    // BGRA capable impl would return BGRA from there)
-
-    QImage rgbaImage(size, include_alpha ? QImage::Format_RGBA8888_Premultiplied : QImage::Format_RGBX8888);
-    funcs->glReadPixels(0, 0, w, h, GL_RGBA, GL_UNSIGNED_BYTE, rgbaImage.bits());
-    return rgbaImage;
-}
-
-static inline QImage qt_gl_read_framebuffer_rgb10a2(const QSize &size, bool include_alpha, QOpenGLContext *context)
-{
-    // We assume OpenGL 1.2+ or ES 3.0+ here.
-    QImage img(size, include_alpha ? QImage::Format_A2BGR30_Premultiplied : QImage::Format_BGR30);
-    context->functions()->glReadPixels(0, 0, size.width(), size.height(), GL_RGBA, GL_UNSIGNED_INT_2_10_10_10_REV, img.bits());
-    return img;
-}
-
-static inline QImage qt_gl_read_framebuffer_rgba16(const QSize &size, bool include_alpha, QOpenGLContext *context)
-{
-    // We assume OpenGL 1.2+ or ES 3.0+ here.
-    QImage img(size, include_alpha ? QImage::Format_RGBA64_Premultiplied : QImage::Format_RGBX64);
-    context->functions()->glReadPixels(0, 0, size.width(), size.height(), GL_RGBA, GL_UNSIGNED_SHORT, img.bits());
-    return img;
-}
-
-static QImage qt_gl_read_framebuffer(const QSize &size, GLenum internal_format, bool include_alpha, bool flip)
-{
-    QOpenGLContext *ctx = QOpenGLContext::currentContext();
-    QOpenGLFunctions *funcs = ctx->functions();
-    while (true) {
-        GLenum error = funcs->glGetError();
-        if (error == GL_NO_ERROR || error == GL_CONTEXT_LOST)
-            break;
-    }
-    switch (internal_format) {
-    case GL_RGB:
-    case GL_RGB8:
-        return qt_gl_read_framebuffer_rgba8(size, false, ctx).mirrored(false, flip);
-    case GL_RGB10:
-        return qt_gl_read_framebuffer_rgb10a2(size, false, ctx).mirrored(false, flip);
-    case GL_RGB10_A2:
-        return qt_gl_read_framebuffer_rgb10a2(size, include_alpha, ctx).mirrored(false, flip);
-    case GL_RGB16:
-        return qt_gl_read_framebuffer_rgba16(size, false, ctx).mirrored(false, flip);
-    case GL_RGBA16:
-        return qt_gl_read_framebuffer_rgba16(size, include_alpha, ctx).mirrored(false, flip);
-    case GL_RGBA:
-    case GL_RGBA8:
-    default:
-        return qt_gl_read_framebuffer_rgba8(size, include_alpha, ctx).mirrored(false, flip);
-    }
-
-    Q_UNREACHABLE();
-    return QImage();
-}
-
-Q_GUI_EXPORT QImage qt_gl_read_framebuffer(const QSize &size, bool alpha_format, bool include_alpha)
-{
-    return qt_gl_read_framebuffer(size, alpha_format ? GL_RGBA : GL_RGB, include_alpha, true);
-}
-
-/*!
-    \fn QImage QOpenGLFramebufferObject::toImage(bool flipped) const
-
-    Returns the contents of this framebuffer object as a QImage.
-
-    If \a flipped is true the image is flipped from OpenGL coordinates to raster coordinates.
-    If used together with QOpenGLPaintDevice, \a flipped should be the opposite of the value
-    of QOpenGLPaintDevice::paintFlipped().
-
-    The returned image has a format of premultiplied ARGB32 or RGB32. The latter
-    is used only when internalTextureFormat() is set to \c GL_RGB. Since Qt 5.2
-    the function will fall back to premultiplied RGBA8888 or RGBx8888 when
-    reading to (A)RGB32 is not supported, and this includes OpenGL ES. Since Qt
-    5.4 an A2BGR30 image is returned if the internal format is RGB10_A2, and since
-    Qt 5.12 a RGBA64 image is return if the internal format is RGBA16.
-
-    If the rendering in the framebuffer was not done with premultiplied alpha in mind,
-    create a wrapper QImage with a non-premultiplied format. This is necessary before
-    performing operations like QImage::save() because otherwise the image data would get
-    unpremultiplied, even though it was not premultiplied in the first place. To create
-    such a wrapper without performing a copy of the pixel data, do the following:
-
-    \code
-    QImage fboImage(fbo.toImage());
-    QImage image(fboImage.constBits(), fboImage.width(), fboImage.height(), QImage::Format_ARGB32);
-    \endcode
-
-    For multisampled framebuffer objects the samples are resolved using the
-    \c{GL_EXT_framebuffer_blit} extension. If the extension is not available, the contents
-    of the returned image is undefined.
-
-    For singlesampled framebuffers the contents is retrieved via \c glReadPixels. This is
-    a potentially expensive and inefficient operation. Therefore it is recommended that
-    this function is used as seldom as possible.
-
-    \sa QOpenGLPaintDevice::paintFlipped()
-*/
-
-QImage QOpenGLFramebufferObject::toImage(bool flipped) const
-{
-    return toImage(flipped, 0);
-}
-
-/*!
-    \fn QImage QOpenGLFramebufferObject::toImage() const
-    \overload
-
-    Returns the contents of this framebuffer object as a QImage. This method flips
-    the image from OpenGL coordinates to raster coordinates.
-*/
-// ### Qt 6: Remove this method and make it a default argument instead.
-QImage QOpenGLFramebufferObject::toImage() const
-{
-    return toImage(true, 0);
-}
-
-/*! \overload
-
-    Returns the contents of the color attachment of index \a
-    colorAttachmentIndex of this framebuffer object as a QImage. This method
-    flips the image from OpenGL coordinates to raster coordinates when \a
-    flipped is set to \c true.
-
-    \note This overload is only fully functional when multiple render targets are
-    supported by the OpenGL implementation. When that is not the case, only one
-    color attachment will be set up.
-
-    \since 5.6
-*/
-QImage QOpenGLFramebufferObject::toImage(bool flipped, int colorAttachmentIndex) const
-{
-    Q_D(const QOpenGLFramebufferObject);
-    if (!d->valid)
-        return QImage();
-
-    QOpenGLContext *ctx = QOpenGLContext::currentContext();
-    if (!ctx) {
-        qWarning("QOpenGLFramebufferObject::toImage() called without a current context");
-        return QImage();
-    }
-
-    if (d->colorAttachments.count() <= colorAttachmentIndex) {
-        qWarning("QOpenGLFramebufferObject::toImage() called for missing color attachment");
-        return QImage();
-    }
-
-    GLuint prevFbo = 0;
-    ctx->functions()->glGetIntegerv(GL_FRAMEBUFFER_BINDING, (GLint *) &prevFbo);
-
-    if (prevFbo != d->fbo())
-        const_cast<QOpenGLFramebufferObject *>(this)->bind();
-
-    QImage image;
-    QOpenGLExtraFunctions *extraFuncs = ctx->extraFunctions();
-    // qt_gl_read_framebuffer doesn't work on a multisample FBO
-    if (format().samples() != 0) {
-        QRect rect(QPoint(0, 0), size());
-        QOpenGLFramebufferObjectFormat fmt;
-        if (extraFuncs->hasOpenGLFeature(QOpenGLFunctions::MultipleRenderTargets)) {
-            fmt.setInternalTextureFormat(d->colorAttachments[colorAttachmentIndex].internalFormat);
-            QOpenGLFramebufferObject temp(d->colorAttachments[colorAttachmentIndex].size, fmt);
-            blitFramebuffer(&temp, rect, const_cast<QOpenGLFramebufferObject *>(this), rect,
-                            GL_COLOR_BUFFER_BIT, GL_NEAREST,
-                            colorAttachmentIndex, 0);
-            image = temp.toImage(flipped);
-        } else {
-            fmt.setInternalTextureFormat(d->colorAttachments[0].internalFormat);
-            QOpenGLFramebufferObject temp(size(), fmt);
-            blitFramebuffer(&temp, rect, const_cast<QOpenGLFramebufferObject *>(this), rect);
-            image = temp.toImage(flipped);
-        }
-    } else {
-        if (extraFuncs->hasOpenGLFeature(QOpenGLFunctions::MultipleRenderTargets)) {
-            extraFuncs->glReadBuffer(GL_COLOR_ATTACHMENT0 + colorAttachmentIndex);
-            image = qt_gl_read_framebuffer(d->colorAttachments[colorAttachmentIndex].size,
-                                           d->colorAttachments[colorAttachmentIndex].internalFormat,
-                                           true, flipped);
-            extraFuncs->glReadBuffer(GL_COLOR_ATTACHMENT0);
-        } else {
-            image = qt_gl_read_framebuffer(d->colorAttachments[0].size,
-                                           d->colorAttachments[0].internalFormat,
-                                           true, flipped);
-        }
-    }
-
-    if (prevFbo != d->fbo())
-        ctx->functions()->glBindFramebuffer(GL_FRAMEBUFFER, prevFbo);
-
-    return image;
-}
-
-/*!
-    \fn bool QOpenGLFramebufferObject::bindDefault()
-
-    Switches rendering back to the default, windowing system provided
-    framebuffer.
-    Returns \c true upon success, false otherwise.
-
-    \sa bind(), release()
-*/
-bool QOpenGLFramebufferObject::bindDefault()
-{
-    QOpenGLContext *ctx = const_cast<QOpenGLContext *>(QOpenGLContext::currentContext());
-
-    if (ctx) {
-        ctx->functions()->glBindFramebuffer(GL_FRAMEBUFFER, ctx->defaultFramebufferObject());
-        QOpenGLContextPrivate::get(ctx)->qgl_current_fbo_invalid = true;
-        QOpenGLContextPrivate::get(ctx)->qgl_current_fbo = nullptr;
-    }
-#ifdef QT_DEBUG
-    else
-        qWarning("QOpenGLFramebufferObject::bindDefault() called without current context.");
-#endif
-
-    return ctx != nullptr;
-}
-
-/*!
-    \fn bool QOpenGLFramebufferObject::hasOpenGLFramebufferObjects()
-
-    Returns \c true if the OpenGL \c{GL_EXT_framebuffer_object} extension
-    is present on this system; otherwise returns \c false.
-*/
-bool QOpenGLFramebufferObject::hasOpenGLFramebufferObjects()
-{
-    return QOpenGLContext::currentContext()->functions()->hasOpenGLFeature(QOpenGLFunctions::Framebuffers);
-}
-
-/*!
-    \fn GLuint QOpenGLFramebufferObject::handle() const
-
-    Returns the OpenGL framebuffer object handle for this framebuffer
-    object (returned by the \c{glGenFrameBuffersEXT()} function). This
-    handle can be used to attach new images or buffers to the
-    framebuffer. The user is responsible for cleaning up and
-    destroying these objects.
-*/
-GLuint QOpenGLFramebufferObject::handle() const
-{
-    Q_D(const QOpenGLFramebufferObject);
-    return d->fbo();
-}
-
-/*!
-    Returns the status of the depth and stencil buffers attached to
-    this framebuffer object.
-*/
-
-QOpenGLFramebufferObject::Attachment QOpenGLFramebufferObject::attachment() const
-{
-    Q_D(const QOpenGLFramebufferObject);
-    if (d->valid)
-        return d->fbo_attachment;
-    return NoAttachment;
-}
-
-/*!
-    Sets the attachments of the framebuffer object to \a attachment.
-
-    This can be used to free or reattach the depth and stencil buffer
-    attachments as needed.
-
-    \note This function alters the current framebuffer binding.
- */
-void QOpenGLFramebufferObject::setAttachment(QOpenGLFramebufferObject::Attachment attachment)
-{
-    Q_D(QOpenGLFramebufferObject);
-    if (attachment == d->fbo_attachment || !isValid())
-        return;
-    QOpenGLContext *current = QOpenGLContext::currentContext();
-    if (!current)
-        return;
-#ifdef QT_DEBUG
-    if (current->shareGroup() != d->fbo_guard->group())
-        qWarning("QOpenGLFramebufferObject::setAttachment() called from incompatible context");
-#endif
-    d->funcs.glBindFramebuffer(GL_FRAMEBUFFER, d->fbo());
-    QOpenGLContextPrivate::get(current)->qgl_current_fbo_invalid = true;
-    d->initDepthStencilAttachments(current, attachment);
-}
-
-/*!
-    Returns \c true if the framebuffer object is currently bound to the current context,
-    otherwise false is returned.
-*/
-bool QOpenGLFramebufferObject::isBound() const
-{
-    Q_D(const QOpenGLFramebufferObject);
-    QOpenGLContext *ctx = QOpenGLContext::currentContext();
-    if (!ctx)
-        return false;
-    GLint fbo = 0;
-    ctx->functions()->glGetIntegerv(GL_FRAMEBUFFER_BINDING, &fbo);
-    return GLuint(fbo) == d->fbo();
-}
-
-/*!
-    \fn bool QOpenGLFramebufferObject::hasOpenGLFramebufferBlit()
-
-    Returns \c true if the OpenGL \c{GL_EXT_framebuffer_blit} extension
-    is present on this system; otherwise returns \c false.
-
-    \sa blitFramebuffer()
-*/
-bool QOpenGLFramebufferObject::hasOpenGLFramebufferBlit()
-{
-    return QOpenGLExtensions(QOpenGLContext::currentContext()).hasOpenGLExtension(QOpenGLExtensions::FramebufferBlit);
-}
-
-
-/*!
-    \overload
-
-    Convenience overload to blit between two framebuffer objects.
-*/
-void QOpenGLFramebufferObject::blitFramebuffer(QOpenGLFramebufferObject *target,
-                                               QOpenGLFramebufferObject *source,
-                                               GLbitfield buffers, GLenum filter)
-{
-    if (!target && !source)
-        return;
-
-    QSize targetSize;
-    QSize sourceSize;
-
-    if (target)
-        targetSize = target->size();
-    if (source)
-        sourceSize = source->size();
-
-    if (targetSize.isEmpty())
-        targetSize = sourceSize;
-    else if (sourceSize.isEmpty())
-        sourceSize = targetSize;
-
-    blitFramebuffer(target, QRect(QPoint(0, 0), targetSize),
-                    source, QRect(QPoint(0, 0), sourceSize),
-                    buffers, filter);
-}
-
-/*! \overload
- *
-    Convenience overload to blit between two framebuffer objects.
-*/
-void QOpenGLFramebufferObject::blitFramebuffer(QOpenGLFramebufferObject *target, const QRect &targetRect,
-                                               QOpenGLFramebufferObject *source, const QRect &sourceRect,
-                                               GLbitfield buffers,
-                                               GLenum filter)
-{
-    blitFramebuffer(target, targetRect, source, sourceRect, buffers, filter, 0, 0);
-}
-
-/*!
-    \enum QOpenGLFramebufferObject::FramebufferRestorePolicy
-    \since 5.7
-
-    This enum type is used to configure the behavior related to restoring
-    framebuffer bindings when calling blitFramebuffer().
-
-    \value DontRestoreFramebufferBinding        Do not restore the previous framebuffer binding.
-                                                The caller is responsible for tracking and setting
-                                                the framebuffer binding as needed.
-
-    \value RestoreFramebufferBindingToDefault   After the blit operation, bind the default
-                                                framebuffer.
-
-    \value RestoreFrameBufferBinding            Restore the previously bound framebuffer. This is
-                                                potentially expensive because of the need to
-                                                query the currently bound framebuffer.
-
-    \sa blitFramebuffer()
-*/
-
-/*!
-    \since 5.7
-
-    Blits from the \a sourceRect rectangle in the \a source framebuffer
-    object to the \a targetRect rectangle in the \a target framebuffer object.
-
-    If \a source or \a target is 0, the default framebuffer will be used
-    instead of a framebuffer object as source or target respectively.
-
-    This function will have no effect unless hasOpenGLFramebufferBlit() returns
-    true.
-
-    The \a buffers parameter should be a mask consisting of any combination of
-    \c GL_COLOR_BUFFER_BIT, \c GL_DEPTH_BUFFER_BIT, and
-    \c GL_STENCIL_BUFFER_BIT.  Any buffer type that is not present both
-    in the source and target buffers is ignored.
-
-    The \a sourceRect and \a targetRect rectangles may have different sizes;
-    in this case \a buffers should not contain \c GL_DEPTH_BUFFER_BIT or
-    \c GL_STENCIL_BUFFER_BIT. The \a filter parameter should be set to
-    \c GL_LINEAR or \c GL_NEAREST, and specifies whether linear or nearest
-    interpolation should be used when scaling is performed.
-
-    If \a source equals \a target a copy is performed within the same buffer.
-    Results are undefined if the source and target rectangles overlap and
-    have different sizes. The sizes must also be the same if any of the
-    framebuffer objects are multisample framebuffers.
-
-    \note The scissor test will restrict the blit area if enabled.
-
-    When multiple render targets are in use, \a readColorAttachmentIndex and \a
-    drawColorAttachmentIndex specify the index of the color attachments in the
-    source and destination framebuffers.
-
-    The \a restorePolicy determines if the framebuffer that was bound prior to
-    calling this function should be restored, or if the default framebuffer
-    should be bound before returning, of if the caller is responsible for
-    tracking and setting the bound framebuffer. Restoring the previous
-    framebuffer can be relatively expensive due to the call to \c{glGetIntegerv}
-    which on some OpenGL drivers may imply a pipeline stall.
-
-    \sa hasOpenGLFramebufferBlit()
-*/
-void QOpenGLFramebufferObject::blitFramebuffer(QOpenGLFramebufferObject *target, const QRect &targetRect,
-                                               QOpenGLFramebufferObject *source, const QRect &sourceRect,
-                                               GLbitfield buffers,
-                                               GLenum filter,
-                                               int readColorAttachmentIndex,
-                                               int drawColorAttachmentIndex,
-                                               QOpenGLFramebufferObject::FramebufferRestorePolicy restorePolicy)
-{
-    QOpenGLContext *ctx = QOpenGLContext::currentContext();
-    if (!ctx)
-        return;
-
-    QOpenGLExtensions extensions(ctx);
-    if (!extensions.hasOpenGLExtension(QOpenGLExtensions::FramebufferBlit))
-        return;
-
-    GLuint prevFbo = 0;
-    if (restorePolicy == RestoreFrameBufferBinding)
-        ctx->functions()->glGetIntegerv(GL_FRAMEBUFFER_BINDING, (GLint *) &prevFbo);
-
-    const int sx0 = sourceRect.left();
-    const int sx1 = sourceRect.left() + sourceRect.width();
-    const int sy0 = sourceRect.top();
-    const int sy1 = sourceRect.top() + sourceRect.height();
-
-    const int tx0 = targetRect.left();
-    const int tx1 = targetRect.left() + targetRect.width();
-    const int ty0 = targetRect.top();
-    const int ty1 = targetRect.top() + targetRect.height();
-
-    const GLuint defaultFboId = ctx->defaultFramebufferObject();
-
-    extensions.glBindFramebuffer(GL_READ_FRAMEBUFFER, source ? source->handle() : defaultFboId);
-    extensions.glBindFramebuffer(GL_DRAW_FRAMEBUFFER, target ? target->handle() : defaultFboId);
-
-    const bool supportsMRT = extensions.hasOpenGLFeature(QOpenGLFunctions::MultipleRenderTargets);
-    if (supportsMRT) {
-        extensions.glReadBuffer(GL_COLOR_ATTACHMENT0 + readColorAttachmentIndex);
-        if (target) {
-            GLenum drawBuf = GL_COLOR_ATTACHMENT0 + drawColorAttachmentIndex;
-            extensions.glDrawBuffers(1, &drawBuf);
-        }
-    }
-
-    extensions.glBlitFramebuffer(sx0, sy0, sx1, sy1,
-                                 tx0, ty0, tx1, ty1,
-                                 buffers, filter);
-
-    if (supportsMRT)
-        extensions.glReadBuffer(GL_COLOR_ATTACHMENT0);
-
-    switch (restorePolicy) {
-    case RestoreFrameBufferBinding:
-        ctx->functions()->glBindFramebuffer(GL_FRAMEBUFFER, prevFbo); // sets both READ and DRAW
-        break;
-
-    case RestoreFramebufferBindingToDefault:
-        ctx->functions()->glBindFramebuffer(GL_FRAMEBUFFER, ctx->defaultFramebufferObject()); // sets both READ and DRAW
-        break;
-
-    case DontRestoreFramebufferBinding:
-        break;
-    }
-}
-
-/*!
-   \overload
-
-    Convenience overload to blit between two framebuffer objects and
-    to restore the previous framebuffer binding. Equivalent to calling
-    blitFramebuffer(target, targetRect, source, sourceRect, buffers, filter,
-    readColorAttachmentIndex, drawColorAttachmentIndex,
-    RestoreFrameBufferBinding).
-*/
-void QOpenGLFramebufferObject::blitFramebuffer(QOpenGLFramebufferObject *target, const QRect &targetRect,
-                                               QOpenGLFramebufferObject *source, const QRect &sourceRect,
-                                               GLbitfield buffers,
-                                               GLenum filter,
-                                               int readColorAttachmentIndex,
-                                               int drawColorAttachmentIndex)
-{
-    blitFramebuffer(target, targetRect, source, sourceRect,
-                    buffers, filter,
-                    readColorAttachmentIndex,
-                    drawColorAttachmentIndex,
-                    RestoreFrameBufferBinding);
-}
-
-QT_END_NAMESPACE
diff --git a/src/gui/opengl/qopenglframebufferobject.h b/src/gui/opengl/qopenglframebufferobject.h
deleted file mode 100644
index 161054d1bf..0000000000
--- a/src/gui/opengl/qopenglframebufferobject.h
+++ /dev/null
@@ -1,200 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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 QOPENGLFRAMEBUFFEROBJECT_H
-#define QOPENGLFRAMEBUFFEROBJECT_H
-
-#include <QtGui/qtguiglobal.h>
-
-#ifndef QT_NO_OPENGL
-
-#include <QtGui/qopengl.h>
-#include <QtGui/qpaintdevice.h>
-
-#include <QtCore/qscopedpointer.h>
-
-#if defined(Q_CLANG_QDOC)
-#undef GLuint
-typedef unsigned int GLuint;
-#undef GLenum
-typedef unsigned int GLenum;
-#undef GL_TEXTURE_2D
-#define GL_TEXTURE_2D 0x0DE1
-#undef GLbitfield
-typedef unsigned int GLbitfield;
-#endif
-
-QT_BEGIN_NAMESPACE
-
-class QOpenGLFramebufferObjectPrivate;
-class QOpenGLFramebufferObjectFormat;
-
-class Q_GUI_EXPORT QOpenGLFramebufferObject
-{
-    Q_DECLARE_PRIVATE(QOpenGLFramebufferObject)
-public:
-    enum Attachment {
-        NoAttachment,
-        CombinedDepthStencil,
-        Depth
-    };
-
-    explicit QOpenGLFramebufferObject(const QSize &size, GLenum target = GL_TEXTURE_2D);
-    QOpenGLFramebufferObject(int width, int height, GLenum target = GL_TEXTURE_2D);
-
-    QOpenGLFramebufferObject(const QSize &size, Attachment attachment,
-                         GLenum target = GL_TEXTURE_2D, GLenum internalFormat = 0);
-    QOpenGLFramebufferObject(int width, int height, Attachment attachment,
-                         GLenum target = GL_TEXTURE_2D, GLenum internalFormat = 0);
-
-    QOpenGLFramebufferObject(const QSize &size, const QOpenGLFramebufferObjectFormat &format);
-    QOpenGLFramebufferObject(int width, int height, const QOpenGLFramebufferObjectFormat &format);
-
-    virtual ~QOpenGLFramebufferObject();
-
-    void addColorAttachment(const QSize &size, GLenum internalFormat = 0);
-    void addColorAttachment(int width, int height, GLenum internalFormat = 0);
-
-    QOpenGLFramebufferObjectFormat format() const;
-
-    bool isValid() const;
-    bool isBound() const;
-    bool bind();
-    bool release();
-
-    int width() const { return size().width(); }
-    int height() const { return size().height(); }
-
-    GLuint texture() const;
-    QVector<GLuint> textures() const;
-
-    GLuint takeTexture();
-    GLuint takeTexture(int colorAttachmentIndex);
-
-    QSize size() const;
-    QVector<QSize> sizes() const;
-
-    QImage toImage() const;
-    QImage toImage(bool flipped) const;
-    QImage toImage(bool flipped, int colorAttachmentIndex) const;
-
-    Attachment attachment() const;
-    void setAttachment(Attachment attachment);
-
-    GLuint handle() const;
-
-    static bool bindDefault();
-
-    static bool hasOpenGLFramebufferObjects();
-
-    static bool hasOpenGLFramebufferBlit();
-
-    enum FramebufferRestorePolicy {
-        DontRestoreFramebufferBinding,
-        RestoreFramebufferBindingToDefault,
-        RestoreFrameBufferBinding
-    };
-
-    static void blitFramebuffer(QOpenGLFramebufferObject *target, const QRect &targetRect,
-                                QOpenGLFramebufferObject *source, const QRect &sourceRect,
-                                GLbitfield buffers,
-                                GLenum filter,
-                                int readColorAttachmentIndex,
-                                int drawColorAttachmentIndex,
-                                FramebufferRestorePolicy restorePolicy);
-    static void blitFramebuffer(QOpenGLFramebufferObject *target, const QRect &targetRect,
-                                QOpenGLFramebufferObject *source, const QRect &sourceRect,
-                                GLbitfield buffers,
-                                GLenum filter,
-                                int readColorAttachmentIndex,
-                                int drawColorAttachmentIndex);
-    static void blitFramebuffer(QOpenGLFramebufferObject *target, const QRect &targetRect,
-                                QOpenGLFramebufferObject *source, const QRect &sourceRect,
-                                GLbitfield buffers = GL_COLOR_BUFFER_BIT,
-                                GLenum filter = GL_NEAREST);
-    static void blitFramebuffer(QOpenGLFramebufferObject *target,
-                                QOpenGLFramebufferObject *source,
-                                GLbitfield buffers = GL_COLOR_BUFFER_BIT,
-                                GLenum filter = GL_NEAREST);
-
-private:
-    Q_DISABLE_COPY(QOpenGLFramebufferObject)
-    QScopedPointer<QOpenGLFramebufferObjectPrivate> d_ptr;
-    friend class QOpenGLPaintDevice;
-    friend class QOpenGLFBOGLPaintDevice;
-};
-
-class QOpenGLFramebufferObjectFormatPrivate;
-class Q_GUI_EXPORT QOpenGLFramebufferObjectFormat
-{
-public:
-    QOpenGLFramebufferObjectFormat();
-    QOpenGLFramebufferObjectFormat(const QOpenGLFramebufferObjectFormat &other);
-    QOpenGLFramebufferObjectFormat &operator=(const QOpenGLFramebufferObjectFormat &other);
-    ~QOpenGLFramebufferObjectFormat();
-
-    void setSamples(int samples);
-    int samples() const;
-
-    void setMipmap(bool enabled);
-    bool mipmap() const;
-
-    void setAttachment(QOpenGLFramebufferObject::Attachment attachment);
-    QOpenGLFramebufferObject::Attachment attachment() const;
-
-    void setTextureTarget(GLenum target);
-    GLenum textureTarget() const;
-
-    void setInternalTextureFormat(GLenum internalTextureFormat);
-    GLenum internalTextureFormat() const;
-
-    bool operator==(const QOpenGLFramebufferObjectFormat& other) const;
-    bool operator!=(const QOpenGLFramebufferObjectFormat& other) const;
-
-private:
-    QOpenGLFramebufferObjectFormatPrivate *d;
-
-    void detach();
-};
-
-QT_END_NAMESPACE
-
-#endif // QT_NO_OPENGL
-
-#endif // QOPENGLFRAMEBUFFEROBJECT_H
diff --git a/src/gui/opengl/qopenglframebufferobject_p.h b/src/gui/opengl/qopenglframebufferobject_p.h
deleted file mode 100644
index 644bb6c59b..0000000000
--- a/src/gui/opengl/qopenglframebufferobject_p.h
+++ /dev/null
@@ -1,153 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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 QOPENGLFRAMEBUFFEROBJECT_P_H
-#define QOPENGLFRAMEBUFFEROBJECT_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 <QtGui/private/qtguiglobal_p.h>
-#include <qopenglframebufferobject.h>
-#include <private/qopenglcontext_p.h>
-#include <private/qopenglextensions_p.h>
-
-QT_BEGIN_NAMESPACE
-
-class QOpenGLFramebufferObjectFormatPrivate
-{
-public:
-    QOpenGLFramebufferObjectFormatPrivate()
-        : ref(1),
-          samples(0),
-          attachment(QOpenGLFramebufferObject::NoAttachment),
-          target(GL_TEXTURE_2D),
-          mipmap(false)
-    {
-#ifndef QT_OPENGL_ES_2
-        // There is nothing that says QOpenGLFramebufferObjectFormat needs a current
-        // context, so we need a fallback just to be safe, even though in pratice there
-        // will usually be a context current.
-        QOpenGLContext *ctx = QOpenGLContext::currentContext();
-        const bool isES = ctx ? ctx->isOpenGLES() : QOpenGLContext::openGLModuleType() != QOpenGLContext::LibGL;
-        internal_format = isES ? GL_RGBA : GL_RGBA8;
-#else
-        internal_format = GL_RGBA;
-#endif
-    }
-    QOpenGLFramebufferObjectFormatPrivate
-            (const QOpenGLFramebufferObjectFormatPrivate *other)
-        : ref(1),
-          samples(other->samples),
-          attachment(other->attachment),
-          target(other->target),
-          internal_format(other->internal_format),
-          mipmap(other->mipmap)
-    {
-    }
-    bool equals(const QOpenGLFramebufferObjectFormatPrivate *other)
-    {
-        return samples == other->samples &&
-               attachment == other->attachment &&
-               target == other->target &&
-               internal_format == other->internal_format &&
-               mipmap == other->mipmap;
-    }
-
-    QAtomicInt ref;
-    int samples;
-    QOpenGLFramebufferObject::Attachment attachment;
-    GLenum target;
-    GLenum internal_format;
-    uint mipmap : 1;
-};
-
-class QOpenGLFramebufferObjectPrivate
-{
-public:
-    QOpenGLFramebufferObjectPrivate() : fbo_guard(nullptr), depth_buffer_guard(nullptr)
-                                  , stencil_buffer_guard(nullptr)
-                                  , valid(false) {}
-    ~QOpenGLFramebufferObjectPrivate() {}
-
-    void init(QOpenGLFramebufferObject *q, const QSize &size,
-              QOpenGLFramebufferObject::Attachment attachment,
-              GLenum texture_target, GLenum internal_format,
-              GLint samples = 0, bool mipmap = false);
-    void initTexture(int idx);
-    void initColorBuffer(int idx, GLint *samples);
-    void initDepthStencilAttachments(QOpenGLContext *ctx, QOpenGLFramebufferObject::Attachment attachment);
-
-    bool checkFramebufferStatus(QOpenGLContext *ctx) const;
-    QOpenGLSharedResourceGuard *fbo_guard;
-    QOpenGLSharedResourceGuard *depth_buffer_guard;
-    QOpenGLSharedResourceGuard *stencil_buffer_guard;
-    GLenum target;
-    QSize dsSize;
-    QOpenGLFramebufferObjectFormat format;
-    int requestedSamples;
-    uint valid : 1;
-    QOpenGLFramebufferObject::Attachment fbo_attachment;
-    QOpenGLExtensions funcs;
-
-    struct ColorAttachment {
-        ColorAttachment() : internalFormat(0), guard(nullptr) { }
-        ColorAttachment(const QSize &size, GLenum internalFormat)
-            : size(size), internalFormat(internalFormat), guard(nullptr) { }
-        QSize size;
-        GLenum internalFormat;
-        QOpenGLSharedResourceGuard *guard;
-    };
-    QVector<ColorAttachment> colorAttachments;
-
-    inline GLuint fbo() const { return fbo_guard ? fbo_guard->id() : 0; }
-};
-
-
-QT_END_NAMESPACE
-
-#endif // QOPENGLFRAMEBUFFEROBJECT_P_H
diff --git a/src/gui/opengl/qopenglfunctions.cpp b/src/gui/opengl/qopenglfunctions.cpp
index 11ca802ee6..c9352fbc31 100644
--- a/src/gui/opengl/qopenglfunctions.cpp
+++ b/src/gui/opengl/qopenglfunctions.cpp
@@ -1,41 +1,5 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-****************************************************************************/
+// Copyright (C) 2021 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
 #include "qopenglfunctions.h"
 #include "qopenglextrafunctions.h"
@@ -57,6 +21,8 @@
 
 QT_BEGIN_NAMESPACE
 
+using namespace Qt::StringLiterals;
+
 #define QT_OPENGL_COUNT_FUNCTIONS(ret, name, args) +1
 #define QT_OPENGL_FUNCTION_NAMES(ret, name, args) \
     "gl"#name"\0"
@@ -364,6 +330,8 @@ static int qt_gl_resolve_extensions()
         extensions |= QOpenGLExtensions::ETC1TextureCompression;
     if (extensionMatcher.match("GL_IMG_texture_compression_pvrtc"))
         extensions |= QOpenGLExtensions::PVRTCTextureCompression;
+    if (extensionMatcher.match("GL_KHR_texture_compression_astc_ldr"))
+        extensions |= QOpenGLExtensions::ASTCTextureCompression;
     if (extensionMatcher.match("GL_ARB_texture_mirrored_repeat"))
         extensions |= QOpenGLExtensions::MirroredRepeat;
     if (extensionMatcher.match("GL_EXT_stencil_two_side"))
@@ -376,6 +344,14 @@ static int qt_gl_resolve_extensions()
         extensions |= QOpenGLExtensions::PixelBufferObject;
     if (extensionMatcher.match("GL_ARB_texture_swizzle") || extensionMatcher.match("GL_EXT_texture_swizzle"))
         extensions |= QOpenGLExtensions::TextureSwizzle;
+    if (extensionMatcher.match("GL_OES_standard_derivatives"))
+        extensions |= QOpenGLExtensions::StandardDerivatives;
+    if (extensionMatcher.match("GL_ARB_half_float_vertex"))
+        extensions |= QOpenGLExtensions::HalfFloatVertex;
+    if (extensionMatcher.match("GL_OVR_multiview"))
+        extensions |= QOpenGLExtensions::MultiView;
+    if (extensionMatcher.match("GL_OVR_multiview2"))
+        extensions |= QOpenGLExtensions::MultiViewExtended;
 
     if (ctx->isOpenGLES()) {
         if (format.majorVersion() >= 2)
@@ -388,7 +364,11 @@ static int qt_gl_resolve_extensions()
                 | QOpenGLExtensions::MapBufferRange
                 | QOpenGLExtensions::FramebufferBlit
                 | QOpenGLExtensions::FramebufferMultisample
-                | QOpenGLExtensions::Sized8Formats;
+                | QOpenGLExtensions::Sized8Formats
+                | QOpenGLExtensions::DiscardFramebuffer
+                | QOpenGLExtensions::StandardDerivatives
+                | QOpenGLExtensions::ETC2TextureCompression
+                | QOpenGLExtensions::HalfFloatVertex;
 #ifndef Q_OS_WASM
             // WebGL 2.0 specification explicitly does not support texture swizzles
             // https://www.khronos.org/registry/webgl/specs/latest/2.0/#5.19
@@ -410,6 +390,8 @@ static int qt_gl_resolve_extensions()
                 extensions |= QOpenGLExtensions::FramebufferMultisample;
             if (extensionMatcher.match("GL_OES_rgb8_rgba8"))
                 extensions |= QOpenGLExtensions::Sized8Formats;
+            if (extensionMatcher.match("GL_OES_compressed_ETC2_RGB8_texture"))
+                extensions |= QOpenGLExtensions::ETC2TextureCompression;
         }
 
         if (extensionMatcher.match("GL_OES_mapbuffer"))
@@ -419,13 +401,13 @@ static int qt_gl_resolve_extensions()
         // We don't match GL_APPLE_texture_format_BGRA8888 here because it has different semantics.
         if (extensionMatcher.match("GL_IMG_texture_format_BGRA8888") || extensionMatcher.match("GL_EXT_texture_format_BGRA8888"))
             extensions |= QOpenGLExtensions::BGRATextureFormat;
-#if defined(Q_OS_ANDROID) && !defined(Q_OS_ANDROID_EMBEDDED)
+#ifdef Q_OS_ANDROID
         QString *deviceName =
                 static_cast<QString *>(QGuiApplication::platformNativeInterface()->nativeResourceForIntegration("AndroidDeviceName"));
         static bool wrongfullyReportsBgra8888Support = deviceName != 0
-                                                        && (deviceName->compare(QLatin1String("samsung SM-T211"), Qt::CaseInsensitive) == 0
-                                                            || deviceName->compare(QLatin1String("samsung SM-T210"), Qt::CaseInsensitive) == 0
-                                                            || deviceName->compare(QLatin1String("samsung SM-T215"), Qt::CaseInsensitive) == 0);
+                                                        && (deviceName->compare("samsung SM-T211"_L1, Qt::CaseInsensitive) == 0
+                                                            || deviceName->compare("samsung SM-T210"_L1, Qt::CaseInsensitive) == 0
+                                                            || deviceName->compare("samsung SM-T215"_L1, Qt::CaseInsensitive) == 0);
         if (wrongfullyReportsBgra8888Support)
             extensions &= ~QOpenGLExtensions::BGRATextureFormat;
 #endif
@@ -445,6 +427,9 @@ static int qt_gl_resolve_extensions()
         if (format.version() >= qMakePair(1, 4) || extensionMatcher.match("GL_SGIS_generate_mipmap"))
             extensions |= QOpenGLExtensions::GenerateMipmap;
 
+        if (format.majorVersion() >= 2)
+            extensions |= QOpenGLExtensions::StandardDerivatives;
+
         if (format.majorVersion() >= 3 || extensionMatcher.match("GL_ARB_framebuffer_object")) {
             extensions |= QOpenGLExtensions::FramebufferMultisample
                 | QOpenGLExtensions::FramebufferBlit
@@ -466,6 +451,9 @@ static int qt_gl_resolve_extensions()
         if (format.version() >= qMakePair(3, 3))
             extensions |= QOpenGLExtensions::TextureSwizzle;
 
+        if (format.version() >= qMakePair(4, 3) || extensionMatcher.match("GL_ARB_invalidate_subdata"))
+            extensions |= QOpenGLExtensions::DiscardFramebuffer;
+
         if (extensionMatcher.match("GL_ARB_map_buffer_range"))
             extensions |= QOpenGLExtensions::MapBufferRange;
 
@@ -475,6 +463,9 @@ static int qt_gl_resolve_extensions()
             if (srgbCapableFramebuffers)
                 extensions |= QOpenGLExtensions::SRGBFrameBuffer;
         }
+
+        if (extensionMatcher.match("GL_ARB_ES3_compatibility"))
+            extensions |= QOpenGLExtensions::ETC2TextureCompression;
     }
 
     return extensions;
@@ -557,13 +548,6 @@ bool QOpenGLExtensions::hasOpenGLExtension(QOpenGLExtensions::OpenGLExtension ex
 }
 
 /*!
-    \fn void QOpenGLFunctions::initializeGLFunctions()
-    \obsolete
-
-    Use initializeOpenGLFunctions() instead.
-*/
-
-/*!
     Initializes OpenGL function resolution for the current context.
 
     After calling this function, the QOpenGLFunctions object can only be
@@ -581,7 +565,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glBindTexture(\a target, \a texture).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glBindTexture.xhtml}{glBindTexture()}.
 
     \since 5.3
@@ -592,7 +576,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glBlendFunc(\a sfactor, \a dfactor).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glBlendFunc.xhtml}{glBlendFunc()}.
 
     \since 5.3
@@ -603,7 +587,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glClear(\a mask).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glClear.xhtml}{glClear()}.
 
     \since 5.3
@@ -614,7 +598,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glClearColor(\a red, \a green, \a blue, \a alpha).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glClearColor.xhtml}{glClearColor()}.
 
     \since 5.3
@@ -625,7 +609,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glClearStencil(\a s).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glClearStencil.xhtml}{glClearStencil()}.
 
     \since 5.3
@@ -636,7 +620,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glColorMask(\a red, \a green, \a blue, \a alpha).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glColorMask.xhtml}{glColorMask()}.
 
     \since 5.3
@@ -647,7 +631,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glCopyTexImage2D(\a target, \a level, \a internalformat, \a x, \a y, \a width, \a height, \a border).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glCopyTexImage2D.xhtml}{glCopyTexImage2D()}.
 
     \since 5.3
@@ -658,7 +642,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glCopyTexSubImage2D(\a target, \a level, \a xoffset, \a yoffset, \a x, \a y, \a width, \a height).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glCopyTexSubImage2D.xhtml}{glCopyTexSubImage2D()}.
 
     \since 5.3
@@ -669,7 +653,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glCullFace(\a mode).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glCullFace.xhtml}{glCullFace()}.
 
     \since 5.3
@@ -680,7 +664,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glDeleteTextures(\a n, \a textures).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glDeleteTextures.xhtml}{glDeleteTextures()}.
 
     \since 5.3
@@ -691,7 +675,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glDepthFunc(\a func).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glDepthFunc.xhtml}{glDepthFunc()}.
 
     \since 5.3
@@ -702,7 +686,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glDepthMask(\a flag).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glDepthMask.xhtml}{glDepthMask()}.
 
     \since 5.3
@@ -713,8 +697,8 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glDisable(\a cap).
 
-    For more information, see the OpenGL ES 2.0 documentation for
-    \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glDisable.xhtml}{glDisable()}.
+    For more information, see the OpenGL ES 3.X documentation for
+    \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glEnable.xhtml}{glDisable()}.
 
     \since 5.3
 */
@@ -724,7 +708,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glDrawArrays(\a mode, \a first, \a count).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glDrawArrays.xhtml}{glDrawArrays()}.
 
     \since 5.3
@@ -735,7 +719,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glDrawElements(\a mode, \a count, \a type, \a indices).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glDrawElements.xhtml}{glDrawElements()}.
 
     \since 5.3
@@ -746,7 +730,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glEnable(\a cap).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glEnable.xhtml}{glEnable()}.
 
     \since 5.3
@@ -757,7 +741,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glFinish().
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glFinish.xhtml}{glFinish()}.
 
     \since 5.3
@@ -768,7 +752,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glFlush().
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glFlush.xhtml}{glFlush()}.
 
     \since 5.3
@@ -779,7 +763,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glFrontFace(\a mode).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glFrontFace.xhtml}{glFrontFace()}.
 
     \since 5.3
@@ -790,7 +774,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glGenTextures(\a n, \a textures).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glGenTextures.xhtml}{glGenTextures()}.
 
     \since 5.3
@@ -801,7 +785,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glGetBooleanv(\a pname, \a params).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glGet.xhtml}{glGetBooleanv()}.
 
     \since 5.3
@@ -812,7 +796,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glGetError().
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glGetError.xhtml}{glGetError()}.
 
     \since 5.3
@@ -823,7 +807,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glGetFloatv(\a pname, \a params).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glGet.xhtml}{glGetFloatv()}.
 
     \since 5.3
@@ -834,7 +818,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glGetIntegerv(\a pname, \a params).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glGet.xhtml}{glGetIntegerv()}.
 
     \since 5.3
@@ -845,7 +829,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glGetString(\a name).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glGetString.xhtml}{glGetString()}.
 
     \since 5.3
@@ -856,7 +840,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glGetTexParameterfv(\a target, \a pname, \a params).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glGetTexParameter.xhtml}{glGetTexParameterfv()}.
 
     \since 5.3
@@ -867,7 +851,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glGetTexParameteriv(\a target, \a pname, \a params).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glGetTexParameter.xhtml}{glGetTexParameteriv()}.
 
     \since 5.3
@@ -878,7 +862,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glHint(\a target, \a mode).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glHint.xhtml}{glHint()}.
 
     \since 5.3
@@ -889,7 +873,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glIsEnabled(\a cap).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glIsEnabled.xhtml}{glIsEnabled()}.
 
     \since 5.3
@@ -900,7 +884,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glIsTexture(\a texture).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glIsTexture.xhtml}{glIsTexture()}.
 
     \since 5.3
@@ -911,7 +895,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glLineWidth(\a width).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glLineWidth.xhtml}{glLineWidth()}.
 
     \since 5.3
@@ -922,7 +906,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glPixelStorei(\a pname, \a param).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glPixelStorei.xhtml}{glPixelStorei()}.
 
     \since 5.3
@@ -933,7 +917,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glPolygonOffset(\a factor, \a units).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glPolygonOffset.xhtml}{glPolygonOffset()}.
 
     \since 5.3
@@ -944,7 +928,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glReadPixels(\a x, \a y, \a width, \a height, \a format, \a type, \a pixels).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glReadPixels.xhtml}{glReadPixels()}.
 
     \since 5.3
@@ -955,7 +939,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glScissor(\a x, \a y, \a width, \a height).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glScissor.xhtml}{glScissor()}.
 
     \since 5.3
@@ -966,7 +950,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glStencilFunc(\a func, \a ref, \a mask).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glStencilFunc.xhtml}{glStencilFunc()}.
 
     \since 5.3
@@ -977,7 +961,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glStencilMask(\a mask).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glStencilMask.xhtml}{glStencilMask()}.
 
     \since 5.3
@@ -988,7 +972,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glStencilOp(\a fail, \a zfail, \a zpass).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glStencilOp.xhtml}{glStencilOp()}.
 
     \since 5.3
@@ -999,7 +983,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glTexImage2D(\a target, \a level, \a internalformat, \a width, \a height, \a border, \a format, \a type, \a pixels).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glTexImage2D.xhtml}{glTexImage2D()}.
 
     \since 5.3
@@ -1010,7 +994,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glTexParameterf(\a target, \a pname, \a param).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glTexParameter.xhtml}{glTexParameterf()}.
 
     \since 5.3
@@ -1021,7 +1005,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glTexParameterfv(\a target, \a pname, \a params).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glTexParameter.xhtml}{glTexParameterfv()}.
 
     \since 5.3
@@ -1032,7 +1016,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glTexParameteri(\a target, \a pname, \a param).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glTexParameter.xhtml}{glTexParameteri()}.
 
     \since 5.3
@@ -1043,7 +1027,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glTexParameteriv(\a target, \a pname, \a params).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glTexParameter.xhtml}{glTexParameteriv()}.
 
     \since 5.3
@@ -1054,7 +1038,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glTexSubImage2D(\a target, \a level, \a xoffset, \a yoffset, \a width, \a height, \a format, \a type, \a pixels).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glTexSubImage2D.xhtml}{glTexSubImage2D()}.
 
     \since 5.3
@@ -1065,7 +1049,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glViewport(\a x, \a y, \a width, \a height).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glViewport.xhtml}{glViewport()}.
 
     \since 5.3
@@ -1076,7 +1060,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glActiveTexture(\a texture).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glActiveTexture.xhtml}{glActiveTexture()}.
 */
 
@@ -1085,7 +1069,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glAttachShader(\a program, \a shader).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glAttachShader.xhtml}{glAttachShader()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -1096,7 +1080,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glBindAttribLocation(\a program, \a index, \a name).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glBindAttribLocation.xhtml}{glBindAttribLocation()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -1107,7 +1091,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glBindBuffer(\a target, \a buffer).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glBindBuffer.xhtml}{glBindBuffer()}.
 */
 
@@ -1119,7 +1103,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
     Note that Qt will translate a \a framebuffer argument of 0 to the currently
     bound QOpenGLContext's defaultFramebufferObject().
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glBindFramebuffer.xhtml}{glBindFramebuffer()}.
 */
 
@@ -1128,7 +1112,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glBindRenderbuffer(\a target, \a renderbuffer).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glBindRenderbuffer.xhtml}{glBindRenderbuffer()}.
 */
 
@@ -1137,7 +1121,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glBlendColor(\a red, \a green, \a blue, \a alpha).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glBlendColor.xhtml}{glBlendColor()}.
 */
 
@@ -1146,7 +1130,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glBlendEquation(\a mode).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glBlendEquation.xhtml}{glBlendEquation()}.
 */
 
@@ -1155,7 +1139,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glBlendEquationSeparate(\a modeRGB, \a modeAlpha).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glBlendEquationSeparate.xhtml}{glBlendEquationSeparate()}.
 */
 
@@ -1164,7 +1148,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glBlendFuncSeparate(\a srcRGB, \a dstRGB, \a srcAlpha, \a dstAlpha).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glBlendFuncSeparate.xhtml}{glBlendFuncSeparate()}.
 */
 
@@ -1173,7 +1157,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glBufferData(\a target, \a size, \a data, \a usage).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glBufferData.xhtml}{glBufferData()}.
 */
 
@@ -1182,7 +1166,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glBufferSubData(\a target, \a offset, \a size, \a data).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glBufferSubData.xhtml}{glBufferSubData()}.
 */
 
@@ -1191,7 +1175,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glCheckFramebufferStatus(\a target).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glCheckFramebufferStatus.xhtml}{glCheckFramebufferStatus()}.
 */
 
@@ -1202,7 +1186,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
     desktop OpenGL systems and glClearDepthf(\a depth) on
     embedded OpenGL ES systems.
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glClearDepthf.xhtml}{glClearDepthf()}.
 */
 
@@ -1211,7 +1195,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glCompileShader(\a shader).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glCompileShader.xhtml}{glCompileShader()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -1222,7 +1206,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glCompressedTexImage2D(\a target, \a level, \a internalformat, \a width, \a height, \a border, \a imageSize, \a data).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glCompressedTexImage2D.xhtml}{glCompressedTexImage2D()}.
 */
 
@@ -1231,7 +1215,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glCompressedTexSubImage2D(\a target, \a level, \a xoffset, \a yoffset, \a width, \a height, \a format, \a imageSize, \a data).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glCompressedTexSubImage2D.xhtml}{glCompressedTexSubImage2D()}.
 */
 
@@ -1240,7 +1224,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glCreateProgram().
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glCreateProgram.xhtml}{glCreateProgram()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -1251,7 +1235,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glCreateShader(\a type).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glCreateShader.xhtml}{glCreateShader()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -1262,7 +1246,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glDeleteBuffers(\a n, \a buffers).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glDeleteBuffers.xhtml}{glDeleteBuffers()}.
 */
 
@@ -1271,7 +1255,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glDeleteFramebuffers(\a n, \a framebuffers).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glDeleteFramebuffers.xhtml}{glDeleteFramebuffers()}.
 */
 
@@ -1280,7 +1264,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glDeleteProgram(\a program).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glDeleteProgram.xhtml}{glDeleteProgram()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -1291,7 +1275,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glDeleteRenderbuffers(\a n, \a renderbuffers).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glDeleteRenderbuffers.xhtml}{glDeleteRenderbuffers()}.
 */
 
@@ -1300,7 +1284,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glDeleteShader(\a shader).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glDeleteShader.xhtml}{glDeleteShader()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -1313,7 +1297,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
     desktop OpenGL systems and glDepthRangef(\a zNear, \a zFar) on
     embedded OpenGL ES systems.
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glDepthRangef.xhtml}{glDepthRangef()}.
 */
 
@@ -1322,7 +1306,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glDetachShader(\a program, \a shader).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glDetachShader.xhtml}{glDetachShader()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -1333,8 +1317,8 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glDisableVertexAttribArray(\a index).
 
-    For more information, see the OpenGL ES 2.0 documentation for
-    \l{https://www.khronos.org/registry/OpenGL-Refpages/es2.0/html/glDisableVertexAttribArray.xhtml}{glDisableVertexAttribArray()}.
+    For more information, see the OpenGL ES 3.X documentation for
+    \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glEnableVertexAttribArray.xhtml}{glDisableVertexAttribArray()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
 */
@@ -1344,7 +1328,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glEnableVertexAttribArray(\a index).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glEnableVertexAttribArray.xhtml}{glEnableVertexAttribArray()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -1355,7 +1339,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glFramebufferRenderbuffer(\a target, \a attachment, \a renderbuffertarget, \a renderbuffer).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glFramebufferRenderbuffer.xhtml}{glFramebufferRenderbuffer()}.
 */
 
@@ -1364,7 +1348,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glFramebufferTexture2D(\a target, \a attachment, \a textarget, \a texture, \a level).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glFramebufferTexture2D.xhtml}{glFramebufferTexture2D()}.
 */
 
@@ -1373,7 +1357,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glGenBuffers(\a n, \a buffers).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glGenBuffers.xhtml}{glGenBuffers()}.
 */
 
@@ -1382,7 +1366,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glGenerateMipmap(\a target).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glGenerateMipmap.xhtml}{glGenerateMipmap()}.
 */
 
@@ -1391,7 +1375,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glGenFramebuffers(\a n, \a framebuffers).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glGenFramebuffers.xhtml}{glGenFramebuffers()}.
 */
 
@@ -1400,7 +1384,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glGenRenderbuffers(\a n, \a renderbuffers).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glGenRenderbuffers.xhtml}{glGenRenderbuffers()}.
 */
 
@@ -1409,7 +1393,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glGetActiveAttrib(\a program, \a index, \a bufsize, \a length, \a size, \a type, \a name).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glGetActiveAttrib.xhtml}{glGetActiveAttrib()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -1420,7 +1404,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glGetActiveUniform(\a program, \a index, \a bufsize, \a length, \a size, \a type, \a name).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glGetActiveUniform.xhtml}{glGetActiveUniform()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -1431,7 +1415,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glGetAttachedShaders(\a program, \a maxcount, \a count, \a shaders).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glGetAttachedShaders.xhtml}{glGetAttachedShaders()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -1442,7 +1426,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glGetAttribLocation(\a program, \a name).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glGetAttribLocation.xhtml}{glGetAttribLocation()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -1453,8 +1437,8 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glGetBufferParameteriv(\a target, \a pname, \a params).
 
-    For more information, see the OpenGL ES 2.0 documentation for
-    \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glGetBufferParameteriv.xhtml}{glGetBufferParameteriv()}.
+    For more information, see the OpenGL ES 3.X documentation for
+    \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glGetBufferParameter.xhtml}{glGetBufferParameteriv()}.
 */
 
 /*!
@@ -1462,7 +1446,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glGetFramebufferAttachmentParameteriv(\a target, \a attachment, \a pname, \a params).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glGetFramebufferAttachmentParameteriv.xhtml}{glGetFramebufferAttachmentParameteriv()}.
 */
 
@@ -1471,7 +1455,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glGetProgramiv(\a program, \a pname, \a params).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glGetProgramiv.xhtml}{glGetProgramiv()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -1482,7 +1466,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glGetProgramInfoLog(\a program, \a bufsize, \a length, \a infolog).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glGetProgramInfoLog.xhtml}{glGetProgramInfoLog()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -1493,7 +1477,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glGetRenderbufferParameteriv(\a target, \a pname, \a params).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glGetRenderbufferParameteriv.xhtml}{glGetRenderbufferParameteriv()}.
 */
 
@@ -1502,7 +1486,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glGetShaderiv(\a shader, \a pname, \a params).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glGetShaderiv.xhtml}{glGetShaderiv()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -1513,7 +1497,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glGetShaderInfoLog(\a shader, \a bufsize, \a length, \a infolog).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glGetShaderInfoLog.xhtml}{glGetShaderInfoLog()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -1524,7 +1508,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glGetShaderPrecisionFormat(\a shadertype, \a precisiontype, \a range, \a precision).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glGetShaderPrecisionFormat.xhtml}{glGetShaderPrecisionFormat()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -1535,7 +1519,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glGetShaderSource(\a shader, \a bufsize, \a length, \a source).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glGetShaderSource.xhtml}{glGetShaderSource()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -1546,7 +1530,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glGetUniformfv(\a program, \a location, \a params).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glGetUniform.xhtml}{glGetUniformfv()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -1557,7 +1541,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glGetUniformiv(\a program, \a location, \a params).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glGetUniform.xhtml}{glGetUniformiv()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -1568,7 +1552,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glGetUniformLocation(\a program, \a name).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glGetUniformLocation.xhtml}{glGetUniformLocation()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -1579,8 +1563,8 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glGetVertexAttribfv(\a index, \a pname, \a params).
 
-    For more information, see the OpenGL ES 2.0 documentation for
-    \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glGetVertexAttribfv.xhtml}{glGetVertexAttribfv()}.
+    For more information, see the OpenGL ES 3.X documentation for
+    \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glGetVertexAttrib.xhtml}{glGetVertexAttribfv()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
 */
@@ -1590,8 +1574,8 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glGetVertexAttribiv(\a index, \a pname, \a params).
 
-    For more information, see the OpenGL ES 2.0 documentation for
-    \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glGetVertexAttribiv.xhtml}{glGetVertexAttribiv()}.
+    For more information, see the OpenGL ES 3.X documentation for
+    \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glGetVertexAttrib.xhtml}{glGetVertexAttribiv()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
 */
@@ -1601,7 +1585,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glGetVertexAttribPointerv(\a index, \a pname, \a pointer).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glGetVertexAttribPointerv.xhtml}{glGetVertexAttribPointerv()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -1612,7 +1596,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glIsBuffer(\a buffer).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glIsBuffer.xhtml}{glIsBuffer()}.
 */
 
@@ -1621,7 +1605,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glIsFramebuffer(\a framebuffer).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glIsFramebuffer.xhtml}{glIsFramebuffer()}.
 */
 
@@ -1630,7 +1614,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glIsProgram(\a program).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glIsProgram.xhtml}{glIsProgram()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -1641,7 +1625,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glIsRenderbuffer(\a renderbuffer).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glIsRenderbuffer.xhtml}{glIsRenderbuffer()}.
 */
 
@@ -1650,7 +1634,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glIsShader(\a shader).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glIsShader.xhtml}{glIsShader()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -1661,7 +1645,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glLinkProgram(\a program).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glLinkProgram.xhtml}{glLinkProgram()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -1672,7 +1656,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glReleaseShaderCompiler().
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glReleaseShaderCompiler.xhtml}{glReleaseShaderCompiler()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -1683,7 +1667,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glRenderbufferStorage(\a target, \a internalformat, \a width, \a height).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glRenderbufferStorage.xhtml}{glRenderbufferStorage()}.
 */
 
@@ -1692,7 +1676,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glSampleCoverage(\a value, \a invert).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glSampleCoverage.xhtml}{glSampleCoverage()}.
 */
 
@@ -1701,7 +1685,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glShaderBinary(\a n, \a shaders, \a binaryformat, \a binary, \a length).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glShaderBinary.xhtml}{glShaderBinary()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -1712,7 +1696,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glShaderSource(\a shader, \a count, \a string, \a length).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glShaderSource.xhtml}{glShaderSource()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -1723,7 +1707,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glStencilFuncSeparate(\a face, \a func, \a ref, \a mask).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glStencilFuncSeparate.xhtml}{glStencilFuncSeparate()}.
 */
 
@@ -1732,7 +1716,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glStencilMaskSeparate(\a face, \a mask).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glStencilMaskSeparate.xhtml}{glStencilMaskSeparate()}.
 */
 
@@ -1741,7 +1725,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glStencilOpSeparate(\a face, \a fail, \a zfail, \a zpass).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glStencilOpSeparate.xhtml}{glStencilOpSeparate()}.
 */
 
@@ -1750,7 +1734,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glUniform1f(\a location, \a x).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glUniform.xhtml}{glUniform1f()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -1761,7 +1745,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glUniform1fv(\a location, \a count, \a v).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glUniform.xhtml}{glUniform1fv()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -1772,7 +1756,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glUniform1i(\a location, \a x).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glUniform.xhtml}{glUniform1i()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -1783,7 +1767,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glUniform1iv(\a location, \a count, \a v).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glUniform.xhtml}{glUniform1iv()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -1794,7 +1778,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glUniform2f(\a location, \a x, \a y).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glUniform.xhtml}{glUniform2f()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -1805,7 +1789,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glUniform2fv(\a location, \a count, \a v).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glUniform.xhtml}{glUniform2fv()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -1816,7 +1800,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glUniform2i(\a location, \a x, \a y).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glUniform.xhtml}{glUniform2i()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -1827,7 +1811,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glUniform2iv(\a location, \a count, \a v).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glUniform.xhtml}{glUniform2iv()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -1838,7 +1822,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glUniform3f(\a location, \a x, \a y, \a z).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glUniform.xhtml}{glUniform3f()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -1849,7 +1833,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glUniform3fv(\a location, \a count, \a v).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glUniform.xhtml}{glUniform3fv()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -1860,7 +1844,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glUniform3i(\a location, \a x, \a y, \a z).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glUniform.xhtml}{glUniform3i()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -1871,7 +1855,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glUniform3iv(\a location, \a count, \a v).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glUniform.xhtml}{glUniform3iv()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -1882,7 +1866,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glUniform4f(\a location, \a x, \a y, \a z, \a w).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glUniform.xhtml}{glUniform4f()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -1893,7 +1877,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glUniform4fv(\a location, \a count, \a v).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glUniform.xhtml}{glUniform4fv()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -1904,7 +1888,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glUniform4i(\a location, \a x, \a y, \a z, \a w).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glUniform.xhtml}{glUniform4i()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -1915,7 +1899,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glUniform4iv(\a location, \a count, \a v).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glUniform.xhtml}{glUniform4iv()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -1926,7 +1910,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glUniformMatrix2fv(\a location, \a count, \a transpose, \a value).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glUniform.xhtml}{glUniformMatrix2fv()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -1937,7 +1921,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glUniformMatrix3fv(\a location, \a count, \a transpose, \a value).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glUniform.xhtml}{glUniformMatrix3fv()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -1948,7 +1932,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glUniformMatrix4fv(\a location, \a count, \a transpose, \a value).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glUniform.xhtml}{glUniformMatrix4fv()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -1959,7 +1943,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glUseProgram(\a program).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glUseProgram.xhtml}{glUseProgram()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -1970,7 +1954,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glValidateProgram(\a program).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glValidateProgram.xhtml}{glValidateProgram()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -1981,7 +1965,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glVertexAttrib1f(\a indx, \a x).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glVertexAttrib.xhtml}{glVertexAttrib1f()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -1992,7 +1976,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glVertexAttrib1fv(\a indx, \a values).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glVertexAttrib.xhtml}{glVertexAttrib1fv()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -2003,7 +1987,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glVertexAttrib2f(\a indx, \a x, \a y).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glVertexAttrib.xhtml}{glVertexAttrib2f()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -2014,7 +1998,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glVertexAttrib2fv(\a indx, \a values).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glVertexAttrib.xhtml}{glVertexAttrib2fv()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -2025,7 +2009,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glVertexAttrib3f(\a indx, \a x, \a y, \a z).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glVertexAttrib.xhtml}{glVertexAttrib3f()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -2036,7 +2020,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glVertexAttrib3fv(\a indx, \a values).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glVertexAttrib.xhtml}{glVertexAttrib3fv()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -2047,7 +2031,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glVertexAttrib4f(\a indx, \a x, \a y, \a z, \a w).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glVertexAttrib.xhtml}{glVertexAttrib4f()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -2058,7 +2042,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glVertexAttrib4fv(\a indx, \a values).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glVertexAttrib.xhtml}{glVertexAttrib4fv()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -2069,7 +2053,7 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
     Convenience function that calls glVertexAttribPointer(\a indx, \a size, \a type, \a normalized, \a stride, \a ptr).
 
-    For more information, see the OpenGL ES 2.0 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glVertexAttribPointer.xhtml}{glVertexAttribPointer()}.
 
     This convenience function will do nothing on OpenGL ES 1.x systems.
@@ -2129,7 +2113,7 @@ Func resolve(QOpenGLContext *context, const char *name, Func)
 #define RESOLVE(name) \
     resolve(context, "gl"#name, name)
 
-#ifndef QT_OPENGL_ES_2
+#if !QT_CONFIG(opengles2)
 
 // some fallback functions
 static void QOPENGLF_APIENTRY qopenglfSpecialClearDepthf(GLclampf depth)
@@ -2167,14 +2151,14 @@ static void QOPENGLF_APIENTRY qopenglfSpecialReleaseShaderCompiler()
 {
 }
 
-#endif // !QT_OPENGL_ES_2
+#endif // !QT_CONFIG(opengles2)
 
 
 QOpenGLFunctionsPrivate::QOpenGLFunctionsPrivate(QOpenGLContext *c)
 {
     init(c);
 
-#ifndef QT_OPENGL_ES_2
+#if !QT_CONFIG(opengles2)
     // setup fallbacks in case some methods couldn't get resolved
     bool es = QOpenGLContext::currentContext()->isOpenGLES();
     if (!f.ClearDepthf || !es)
@@ -2564,7 +2548,7 @@ QT_OPENGL_IMPLEMENT(QOpenGLFunctionsPrivate, QT_OPENGL_FUNCTIONS)
     function either in core or as an extension.
 
     For more information, see the OpenGL ES 3.x documentation for
-    \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glEndQuery.xhtml}{glEndQuery()}.
+    \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glBeginQuery.xhtml}{glEndQuery()}.
 */
 
 /*!
@@ -2577,7 +2561,7 @@ QT_OPENGL_IMPLEMENT(QOpenGLFunctionsPrivate, QT_OPENGL_FUNCTIONS)
     function either in core or as an extension.
 
     For more information, see the OpenGL ES 3.x documentation for
-    \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glEndTransformFeedback.xhtml}{glEndTransformFeedback()}.
+    \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glBeginTransformFeedback.xhtml}{glEndTransformFeedback()}.
 */
 
 /*!
@@ -3474,7 +3458,7 @@ QT_OPENGL_IMPLEMENT(QOpenGLFunctionsPrivate, QT_OPENGL_FUNCTIONS)
     function either in core or as an extension.
 
     For more information, see the OpenGL ES 3.x documentation for
-    \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glUnmapBuffer.xhtml}{glUnmapBuffer()}.
+    \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glMapBufferRange.xhtml}{glUnmapBuffer()}.
 */
 
 /*!
@@ -3630,7 +3614,7 @@ QT_OPENGL_IMPLEMENT(QOpenGLFunctionsPrivate, QT_OPENGL_FUNCTIONS)
     function either in core or as an extension.
 
     For more information, see the OpenGL ES 3.x documentation for
-    \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glCreateShaderProgramv.xhtml}{glCreateShaderProgramv()}.
+    \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glCreateShaderProgram.xhtml}{glCreateShaderProgramv()}.
 */
 
 /*!
@@ -4436,7 +4420,7 @@ QT_OPENGL_IMPLEMENT(QOpenGLFunctionsPrivate, QT_OPENGL_FUNCTIONS)
     function either in core or as an extension.
 
     For more information, see the OpenGL ES 3.x documentation for
-    \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glVertexAttribIFormat.xhtml}{glVertexAttribIFormat()}.
+    \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glVertexAttribFormat.xhtml}{glVertexAttribIFormat()}.
 */
 
 /*!
@@ -4461,7 +4445,7 @@ QT_OPENGL_IMPLEMENT(QOpenGLFunctionsPrivate, QT_OPENGL_FUNCTIONS)
     with plain OpenGL, the function is only usable when the given profile and version contains the
     function either in core or as an extension.
 
-    For more information, see the OpenGL ES 3.2 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glBlendBarrier.xhtml}{glBlendBarrier()}.
 */
 
@@ -4474,7 +4458,7 @@ QT_OPENGL_IMPLEMENT(QOpenGLFunctionsPrivate, QT_OPENGL_FUNCTIONS)
     with plain OpenGL, the function is only usable when the given profile and version contains the
     function either in core or as an extension.
 
-    For more information, see the OpenGL ES 3.2 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glBlendEquationSeparate.xhtml}{glBlendEquationSeparatei()}.
 */
 
@@ -4487,8 +4471,8 @@ QT_OPENGL_IMPLEMENT(QOpenGLFunctionsPrivate, QT_OPENGL_FUNCTIONS)
     with plain OpenGL, the function is only usable when the given profile and version contains the
     function either in core or as an extension.
 
-    For more information, see the OpenGL ES 3.2 documentation for
-    \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glBlendEquationi.xhtml}{glBlendEquationi()}.
+    For more information, see the OpenGL ES 3.X documentation for
+    \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glBlendEquation.xhtml}{glBlendEquationi()}.
 */
 
 /*!
@@ -4500,7 +4484,7 @@ QT_OPENGL_IMPLEMENT(QOpenGLFunctionsPrivate, QT_OPENGL_FUNCTIONS)
     with plain OpenGL, the function is only usable when the given profile and version contains the
     function either in core or as an extension.
 
-    For more information, see the OpenGL ES 3.2 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glBlendFuncSeparate.xhtml}{glBlendFuncSeparatei()}.
 */
 
@@ -4513,8 +4497,8 @@ QT_OPENGL_IMPLEMENT(QOpenGLFunctionsPrivate, QT_OPENGL_FUNCTIONS)
     with plain OpenGL, the function is only usable when the given profile and version contains the
     function either in core or as an extension.
 
-    For more information, see the OpenGL ES 3.2 documentation for
-    \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glBlendFunci.xhtml}{glBlendFunci()}.
+    For more information, see the OpenGL ES 3.X documentation for
+    \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glBlendFunc.xhtml}{glBlendFunci()}.
 */
 
 /*!
@@ -4526,7 +4510,7 @@ QT_OPENGL_IMPLEMENT(QOpenGLFunctionsPrivate, QT_OPENGL_FUNCTIONS)
     with plain OpenGL, the function is only usable when the given profile and version contains the
     function either in core or as an extension.
 
-    For more information, see the OpenGL ES 3.2 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glColorMask.xhtml}{glColorMaski()}.
 */
 
@@ -4539,7 +4523,7 @@ QT_OPENGL_IMPLEMENT(QOpenGLFunctionsPrivate, QT_OPENGL_FUNCTIONS)
     with plain OpenGL, the function is only usable when the given profile and version contains the
     function either in core or as an extension.
 
-    For more information, see the OpenGL ES 3.2 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glCopyImageSubData.xhtml}{glCopyImageSubData()}.
 */
 
@@ -4552,7 +4536,7 @@ QT_OPENGL_IMPLEMENT(QOpenGLFunctionsPrivate, QT_OPENGL_FUNCTIONS)
     with plain OpenGL, the function is only usable when the given profile and version contains the
     function either in core or as an extension.
 
-    For more information, see the OpenGL ES 3.2 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glDebugMessageCallback.xhtml}{glDebugMessageCallback()}.
 */
 
@@ -4565,7 +4549,7 @@ QT_OPENGL_IMPLEMENT(QOpenGLFunctionsPrivate, QT_OPENGL_FUNCTIONS)
     with plain OpenGL, the function is only usable when the given profile and version contains the
     function either in core or as an extension.
 
-    For more information, see the OpenGL ES 3.2 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glDebugMessageControl.xhtml}{glDebugMessageContro()}.
 */
 
@@ -4578,7 +4562,7 @@ QT_OPENGL_IMPLEMENT(QOpenGLFunctionsPrivate, QT_OPENGL_FUNCTIONS)
     with plain OpenGL, the function is only usable when the given profile and version contains the
     function either in core or as an extension.
 
-    For more information, see the OpenGL ES 3.2 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glDebugMessageInsert.xhtml}{glDebugMessageInsert()}.
 */
 
@@ -4591,7 +4575,7 @@ QT_OPENGL_IMPLEMENT(QOpenGLFunctionsPrivate, QT_OPENGL_FUNCTIONS)
     with plain OpenGL, the function is only usable when the given profile and version contains the
     function either in core or as an extension.
 
-    For more information, see the OpenGL ES 3.2 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/glEnable.xhtml}{glDisablei()}.
 */
 
@@ -4604,7 +4588,7 @@ QT_OPENGL_IMPLEMENT(QOpenGLFunctionsPrivate, QT_OPENGL_FUNCTIONS)
     with plain OpenGL, the function is only usable when the given profile and version contains the
     function either in core or as an extension.
 
-    For more information, see the OpenGL ES 3.2 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glDrawElementsBaseVertex.xhtml}{glDrawElementsBaseVerte()}.
 */
 
@@ -4617,7 +4601,7 @@ QT_OPENGL_IMPLEMENT(QOpenGLFunctionsPrivate, QT_OPENGL_FUNCTIONS)
     with plain OpenGL, the function is only usable when the given profile and version contains the
     function either in core or as an extension.
 
-    For more information, see the OpenGL ES 3.2 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glDrawElementsInstancedBaseVertex.xhtml}{glDrawElementsInstancedBaseVerte()}.
 */
 
@@ -4630,7 +4614,7 @@ QT_OPENGL_IMPLEMENT(QOpenGLFunctionsPrivate, QT_OPENGL_FUNCTIONS)
     with plain OpenGL, the function is only usable when the given profile and version contains the
     function either in core or as an extension.
 
-    For more information, see the OpenGL ES 3.2 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glDrawRangeElementsBaseVertex.xhtml}{glDrawRangeElementsBaseVerte()}.
 */
 
@@ -4643,8 +4627,8 @@ QT_OPENGL_IMPLEMENT(QOpenGLFunctionsPrivate, QT_OPENGL_FUNCTIONS)
     with plain OpenGL, the function is only usable when the given profile and version contains the
     function either in core or as an extension.
 
-    For more information, see the OpenGL ES 3.2 documentation for
-    \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glEnablei.xhtml}{glEnablei()}.
+    For more information, see the OpenGL ES 3.X documentation for
+    \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glEnable.xhtml}{glEnablei()}.
 */
 
 /*!
@@ -4656,7 +4640,7 @@ QT_OPENGL_IMPLEMENT(QOpenGLFunctionsPrivate, QT_OPENGL_FUNCTIONS)
     with plain OpenGL, the function is only usable when the given profile and version contains the
     function either in core or as an extension.
 
-    For more information, see the OpenGL ES 3.2 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glFramebufferTexture.xhtml}{glFramebufferTexture()}.
 */
 
@@ -4669,7 +4653,7 @@ QT_OPENGL_IMPLEMENT(QOpenGLFunctionsPrivate, QT_OPENGL_FUNCTIONS)
     with plain OpenGL, the function is only usable when the given profile and version contains the
     function either in core or as an extension.
 
-    For more information, see the OpenGL ES 3.2 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glGetDebugMessageLog.xhtml}{glGetDebugMessageLog()}.
 */
 
@@ -4682,7 +4666,7 @@ QT_OPENGL_IMPLEMENT(QOpenGLFunctionsPrivate, QT_OPENGL_FUNCTIONS)
     with plain OpenGL, the function is only usable when the given profile and version contains the
     function either in core or as an extension.
 
-    For more information, see the OpenGL ES 3.2 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glGetGraphicsResetStatus.xhtml}{glGetGraphicsResetStatus()}.
 */
 
@@ -4695,7 +4679,7 @@ QT_OPENGL_IMPLEMENT(QOpenGLFunctionsPrivate, QT_OPENGL_FUNCTIONS)
     with plain OpenGL, the function is only usable when the given profile and version contains the
     function either in core or as an extension.
 
-    For more information, see the OpenGL ES 3.2 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glGetObjectLabel.xhtml}{glGetObjectLabe()}.
 */
 
@@ -4708,7 +4692,7 @@ QT_OPENGL_IMPLEMENT(QOpenGLFunctionsPrivate, QT_OPENGL_FUNCTIONS)
     with plain OpenGL, the function is only usable when the given profile and version contains the
     function either in core or as an extension.
 
-    For more information, see the OpenGL ES 3.2 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glGetObjectPtrLabel.xhtml}{glGetObjectPtrLabe()}.
 */
 
@@ -4721,7 +4705,7 @@ QT_OPENGL_IMPLEMENT(QOpenGLFunctionsPrivate, QT_OPENGL_FUNCTIONS)
     with plain OpenGL, the function is only usable when the given profile and version contains the
     function either in core or as an extension.
 
-    For more information, see the OpenGL ES 3.2 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glGetPointerv.xhtml}{glGetPointerv()}.
 */
 
@@ -4734,7 +4718,7 @@ QT_OPENGL_IMPLEMENT(QOpenGLFunctionsPrivate, QT_OPENGL_FUNCTIONS)
     with plain OpenGL, the function is only usable when the given profile and version contains the
     function either in core or as an extension.
 
-    For more information, see the OpenGL ES 3.2 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glGetSamplerParameter.xhtml}{glGetSamplerParameterIiv()}.
 */
 
@@ -4747,7 +4731,7 @@ QT_OPENGL_IMPLEMENT(QOpenGLFunctionsPrivate, QT_OPENGL_FUNCTIONS)
     with plain OpenGL, the function is only usable when the given profile and version contains the
     function either in core or as an extension.
 
-    For more information, see the OpenGL ES 3.2 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glGetSamplerParameter.xhtml}{glGetSamplerParameterIuiv()}.
 */
 
@@ -4760,7 +4744,7 @@ QT_OPENGL_IMPLEMENT(QOpenGLFunctionsPrivate, QT_OPENGL_FUNCTIONS)
     with plain OpenGL, the function is only usable when the given profile and version contains the
     function either in core or as an extension.
 
-    For more information, see the OpenGL ES 3.2 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glGetTexParameter.xhtml}{glGetTexParameterIiv()}.
 */
 
@@ -4773,7 +4757,7 @@ QT_OPENGL_IMPLEMENT(QOpenGLFunctionsPrivate, QT_OPENGL_FUNCTIONS)
     with plain OpenGL, the function is only usable when the given profile and version contains the
     function either in core or as an extension.
 
-    For more information, see the OpenGL ES 3.2 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glGetTexParameter.xhtml}{glGetTexParameterIuiv()}.
 */
 
@@ -4786,7 +4770,7 @@ QT_OPENGL_IMPLEMENT(QOpenGLFunctionsPrivate, QT_OPENGL_FUNCTIONS)
     with plain OpenGL, the function is only usable when the given profile and version contains the
     function either in core or as an extension.
 
-    For more information, see the OpenGL ES 3.2 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glGetUniform.xhtml}{glGetnUniformfv()}.
 */
 
@@ -4799,7 +4783,7 @@ QT_OPENGL_IMPLEMENT(QOpenGLFunctionsPrivate, QT_OPENGL_FUNCTIONS)
     with plain OpenGL, the function is only usable when the given profile and version contains the
     function either in core or as an extension.
 
-    For more information, see the OpenGL ES 3.2 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glGetUniform.xhtml}{glGetnUniformiv()}.
 */
 
@@ -4812,7 +4796,7 @@ QT_OPENGL_IMPLEMENT(QOpenGLFunctionsPrivate, QT_OPENGL_FUNCTIONS)
     with plain OpenGL, the function is only usable when the given profile and version contains the
     function either in core or as an extension.
 
-    For more information, see the OpenGL ES 3.2 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glGetUniform.xhtml}{glGetnUniformuiv()}.
 */
 
@@ -4825,7 +4809,7 @@ QT_OPENGL_IMPLEMENT(QOpenGLFunctionsPrivate, QT_OPENGL_FUNCTIONS)
     with plain OpenGL, the function is only usable when the given profile and version contains the
     function either in core or as an extension.
 
-    For more information, see the OpenGL ES 3.2 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glIsEnabled.xhtml}{glIsEnabledi()}.
 */
 
@@ -4838,7 +4822,7 @@ QT_OPENGL_IMPLEMENT(QOpenGLFunctionsPrivate, QT_OPENGL_FUNCTIONS)
     with plain OpenGL, the function is only usable when the given profile and version contains the
     function either in core or as an extension.
 
-    For more information, see the OpenGL ES 3.2 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glMinSampleShading.xhtml}{glMinSampleShading()}.
 */
 
@@ -4851,7 +4835,7 @@ QT_OPENGL_IMPLEMENT(QOpenGLFunctionsPrivate, QT_OPENGL_FUNCTIONS)
     with plain OpenGL, the function is only usable when the given profile and version contains the
     function either in core or as an extension.
 
-    For more information, see the OpenGL ES 3.2 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glObjectLabel.xhtml}{glObjectLabe()}.
 */
 
@@ -4864,7 +4848,7 @@ QT_OPENGL_IMPLEMENT(QOpenGLFunctionsPrivate, QT_OPENGL_FUNCTIONS)
     with plain OpenGL, the function is only usable when the given profile and version contains the
     function either in core or as an extension.
 
-    For more information, see the OpenGL ES 3.2 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glObjectPtrLabel.xhtml}{glObjectPtrLabe()}.
 */
 
@@ -4877,7 +4861,7 @@ QT_OPENGL_IMPLEMENT(QOpenGLFunctionsPrivate, QT_OPENGL_FUNCTIONS)
     with plain OpenGL, the function is only usable when the given profile and version contains the
     function either in core or as an extension.
 
-    For more information, see the OpenGL ES 3.2 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glPatchParameteri.xhtml}{glPatchParameteri()}.
 */
 
@@ -4890,7 +4874,7 @@ QT_OPENGL_IMPLEMENT(QOpenGLFunctionsPrivate, QT_OPENGL_FUNCTIONS)
     with plain OpenGL, the function is only usable when the given profile and version contains the
     function either in core or as an extension.
 
-    For more information, see the OpenGL ES 3.2 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glPopDebugGroup.xhtml}{glPopDebugGroup()}.
 */
 
@@ -4903,7 +4887,7 @@ QT_OPENGL_IMPLEMENT(QOpenGLFunctionsPrivate, QT_OPENGL_FUNCTIONS)
     with plain OpenGL, the function is only usable when the given profile and version contains the
     function either in core or as an extension.
 
-    For more information, see the OpenGL ES 3.2 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glPrimitiveBoundingBox.xhtml}{glPrimitiveBoundingBo()}.
 */
 
@@ -4916,7 +4900,7 @@ QT_OPENGL_IMPLEMENT(QOpenGLFunctionsPrivate, QT_OPENGL_FUNCTIONS)
     with plain OpenGL, the function is only usable when the given profile and version contains the
     function either in core or as an extension.
 
-    For more information, see the OpenGL ES 3.2 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glPushDebugGroup.xhtml}{glPushDebugGroup()}.
 */
 
@@ -4929,7 +4913,7 @@ QT_OPENGL_IMPLEMENT(QOpenGLFunctionsPrivate, QT_OPENGL_FUNCTIONS)
     with plain OpenGL, the function is only usable when the given profile and version contains the
     function either in core or as an extension.
 
-    For more information, see the OpenGL ES 3.2 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/glReadPixels.xhtml}{glReadnPixels()}.
 */
 
@@ -4942,7 +4926,7 @@ QT_OPENGL_IMPLEMENT(QOpenGLFunctionsPrivate, QT_OPENGL_FUNCTIONS)
     with plain OpenGL, the function is only usable when the given profile and version contains the
     function either in core or as an extension.
 
-    For more information, see the OpenGL ES 3.2 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glSamplerParameter.xhtml}{glSamplerParameterIiv()}.
 */
 
@@ -4955,7 +4939,7 @@ QT_OPENGL_IMPLEMENT(QOpenGLFunctionsPrivate, QT_OPENGL_FUNCTIONS)
     with plain OpenGL, the function is only usable when the given profile and version contains the
     function either in core or as an extension.
 
-    For more information, see the OpenGL ES 3.2 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glSamplerParameter.xhtml}{glSamplerParameterIuiv()}.
 */
 
@@ -4968,7 +4952,7 @@ QT_OPENGL_IMPLEMENT(QOpenGLFunctionsPrivate, QT_OPENGL_FUNCTIONS)
     with plain OpenGL, the function is only usable when the given profile and version contains the
     function either in core or as an extension.
 
-    For more information, see the OpenGL ES 3.2 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glTexBuffer.xhtml}{glTexBuffer()}.
 */
 
@@ -4981,7 +4965,7 @@ QT_OPENGL_IMPLEMENT(QOpenGLFunctionsPrivate, QT_OPENGL_FUNCTIONS)
     with plain OpenGL, the function is only usable when the given profile and version contains the
     function either in core or as an extension.
 
-    For more information, see the OpenGL ES 3.2 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glTexBufferRange.xhtml}{glTexBufferRange()}.
 */
 
@@ -4994,7 +4978,7 @@ QT_OPENGL_IMPLEMENT(QOpenGLFunctionsPrivate, QT_OPENGL_FUNCTIONS)
     with plain OpenGL, the function is only usable when the given profile and version contains the
     function either in core or as an extension.
 
-    For more information, see the OpenGL ES 3.2 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glTexParameter.xhtml}{glTexParameterIiv()}.
 */
 
@@ -5007,7 +4991,7 @@ QT_OPENGL_IMPLEMENT(QOpenGLFunctionsPrivate, QT_OPENGL_FUNCTIONS)
     with plain OpenGL, the function is only usable when the given profile and version contains the
     function either in core or as an extension.
 
-    For more information, see the OpenGL ES 3.2 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glTexParameter.xhtml}{glTexParameterIuiv()}.
 */
 
@@ -5020,7 +5004,7 @@ QT_OPENGL_IMPLEMENT(QOpenGLFunctionsPrivate, QT_OPENGL_FUNCTIONS)
     with plain OpenGL, the function is only usable when the given profile and version contains the
     function either in core or as an extension.
 
-    For more information, see the OpenGL ES 3.2 documentation for
+    For more information, see the OpenGL ES 3.X documentation for
     \l{https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glTexStorage3DMultisample.xhtml}{glTexStorage3DMultisample()}.
 */
 
@@ -5071,7 +5055,23 @@ QOpenGLExtensionsPrivate::QOpenGLExtensionsPrivate(QOpenGLContext *ctx)
     MapBuffer = RESOLVE(MapBuffer);
     GetBufferSubData = RESOLVE(GetBufferSubData);
     DiscardFramebuffer = RESOLVE(DiscardFramebuffer);
- }
+}
+
+void QOpenGLExtensions::discardFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments)
+{
+    Q_D(QOpenGLExtensions);
+    Q_ASSERT(QOpenGLExtensions::isInitialized(d));
+    Q_ASSERT(d->f.InvalidateFramebuffer || d->DiscardFramebuffer);
+
+    // On GLES >= 3 we prefer glInvalidateFramebuffer, even if the
+    // discard extension is present
+    if (d->f.InvalidateFramebuffer)
+        d->f.InvalidateFramebuffer(target, numAttachments, attachments);
+    else
+        d->DiscardFramebuffer(target, numAttachments, attachments);
+
+    Q_OPENGL_FUNCTIONS_DEBUG
+}
 
 void QOpenGLExtensions::flushShared()
 {
diff --git a/src/gui/opengl/qopenglfunctions.h b/src/gui/opengl/qopenglfunctions.h
index 4554291bbd..05435903fb 100644
--- a/src/gui/opengl/qopenglfunctions.h
+++ b/src/gui/opengl/qopenglfunctions.h
@@ -1,41 +1,5 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-****************************************************************************/
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
 #ifndef QOPENGLFUNCTIONS_H
 #define QOPENGLFUNCTIONS_H
@@ -56,7 +20,7 @@
 
 //#define Q_ENABLE_OPENGL_FUNCTIONS_DEBUG
 
-#ifdef QT_OPENGL_ES
+#if QT_CONFIG(opengles2)
 typedef double GLdouble;
 #endif
 
@@ -68,7 +32,7 @@ typedef double GLdouble;
         unsigned clamped = qMin(unsigned(error - GL_INVALID_ENUM), 4U); \
         const char *errors[] = { "GL_INVALID_ENUM", "GL_INVALID_VALUE", "GL_INVALID_OPERATION", "Unknown" }; \
         printf("GL error at %s:%d: %s\n", __FILE__, __LINE__, errors[clamped]); \
-        int *value = 0; \
+        int *value = nullptr; \
         *value = 0; \
     }
 #else
@@ -227,7 +191,7 @@ struct QOpenGLFunctionsPrivate;
 
 #undef glTexLevelParameteriv
 
-#if defined(Q_CLANG_QDOC)
+#if defined(Q_QDOC)
 #undef GLbitfield
 typedef unsigned int GLbitfield;
 #undef GLchar
@@ -269,10 +233,6 @@ public:
 
     void initializeOpenGLFunctions();
 
-#if QT_DEPRECATED_SINCE(5, 0)
-    QT_DEPRECATED void initializeGLFunctions() { initializeOpenGLFunctions(); }
-#endif
-
     // GLES2 + OpenGL1 common subset
     void glBindTexture(GLenum target, GLuint texture);
     void glBlendFunc(GLenum sfactor, GLenum dfactor);
@@ -599,7 +559,7 @@ struct QOpenGLFunctionsPrivate
 
 inline void QOpenGLFunctions::glBindTexture(GLenum target, GLuint texture)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glBindTexture(target, texture);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -610,7 +570,7 @@ inline void QOpenGLFunctions::glBindTexture(GLenum target, GLuint texture)
 
 inline void QOpenGLFunctions::glBlendFunc(GLenum sfactor, GLenum dfactor)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glBlendFunc(sfactor, dfactor);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -621,7 +581,7 @@ inline void QOpenGLFunctions::glBlendFunc(GLenum sfactor, GLenum dfactor)
 
 inline void QOpenGLFunctions::glClear(GLbitfield mask)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glClear(mask);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -632,7 +592,7 @@ inline void QOpenGLFunctions::glClear(GLbitfield mask)
 
 inline void QOpenGLFunctions::glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glClearColor(red, green, blue, alpha);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -643,7 +603,7 @@ inline void QOpenGLFunctions::glClearColor(GLclampf red, GLclampf green, GLclamp
 
 inline void QOpenGLFunctions::glClearStencil(GLint s)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glClearStencil(s);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -654,7 +614,7 @@ inline void QOpenGLFunctions::glClearStencil(GLint s)
 
 inline void QOpenGLFunctions::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glColorMask(red, green, blue, alpha);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -665,7 +625,7 @@ inline void QOpenGLFunctions::glColorMask(GLboolean red, GLboolean green, GLbool
 
 inline void QOpenGLFunctions::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glCopyTexImage2D(target, level, internalformat, x, y, width,height, border);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -676,7 +636,7 @@ inline void QOpenGLFunctions::glCopyTexImage2D(GLenum target, GLint level, GLenu
 
 inline void QOpenGLFunctions::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -687,7 +647,7 @@ inline void QOpenGLFunctions::glCopyTexSubImage2D(GLenum target, GLint level, GL
 
 inline void QOpenGLFunctions::glCullFace(GLenum mode)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glCullFace(mode);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -698,7 +658,7 @@ inline void QOpenGLFunctions::glCullFace(GLenum mode)
 
 inline void QOpenGLFunctions::glDeleteTextures(GLsizei n, const GLuint* textures)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glDeleteTextures(n, textures);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -709,7 +669,7 @@ inline void QOpenGLFunctions::glDeleteTextures(GLsizei n, const GLuint* textures
 
 inline void QOpenGLFunctions::glDepthFunc(GLenum func)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glDepthFunc(func);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -720,7 +680,7 @@ inline void QOpenGLFunctions::glDepthFunc(GLenum func)
 
 inline void QOpenGLFunctions::glDepthMask(GLboolean flag)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glDepthMask(flag);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -731,7 +691,7 @@ inline void QOpenGLFunctions::glDepthMask(GLboolean flag)
 
 inline void QOpenGLFunctions::glDisable(GLenum cap)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glDisable(cap);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -742,7 +702,7 @@ inline void QOpenGLFunctions::glDisable(GLenum cap)
 
 inline void QOpenGLFunctions::glDrawArrays(GLenum mode, GLint first, GLsizei count)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glDrawArrays(mode, first, count);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -753,7 +713,7 @@ inline void QOpenGLFunctions::glDrawArrays(GLenum mode, GLint first, GLsizei cou
 
 inline void QOpenGLFunctions::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glDrawElements(mode, count, type, indices);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -764,7 +724,7 @@ inline void QOpenGLFunctions::glDrawElements(GLenum mode, GLsizei count, GLenum
 
 inline void QOpenGLFunctions::glEnable(GLenum cap)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glEnable(cap);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -775,7 +735,7 @@ inline void QOpenGLFunctions::glEnable(GLenum cap)
 
 inline void QOpenGLFunctions::glFinish()
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glFinish();
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -786,7 +746,7 @@ inline void QOpenGLFunctions::glFinish()
 
 inline void QOpenGLFunctions::glFlush()
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glFlush();
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -797,7 +757,7 @@ inline void QOpenGLFunctions::glFlush()
 
 inline void QOpenGLFunctions::glFrontFace(GLenum mode)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glFrontFace(mode);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -808,7 +768,7 @@ inline void QOpenGLFunctions::glFrontFace(GLenum mode)
 
 inline void QOpenGLFunctions::glGenTextures(GLsizei n, GLuint* textures)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glGenTextures(n, textures);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -819,7 +779,7 @@ inline void QOpenGLFunctions::glGenTextures(GLsizei n, GLuint* textures)
 
 inline void QOpenGLFunctions::glGetBooleanv(GLenum pname, GLboolean* params)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glGetBooleanv(pname, params);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -830,7 +790,7 @@ inline void QOpenGLFunctions::glGetBooleanv(GLenum pname, GLboolean* params)
 
 inline GLenum QOpenGLFunctions::glGetError()
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     GLenum result = ::glGetError();
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -841,7 +801,7 @@ inline GLenum QOpenGLFunctions::glGetError()
 
 inline void QOpenGLFunctions::glGetFloatv(GLenum pname, GLfloat* params)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glGetFloatv(pname, params);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -852,7 +812,7 @@ inline void QOpenGLFunctions::glGetFloatv(GLenum pname, GLfloat* params)
 
 inline void QOpenGLFunctions::glGetIntegerv(GLenum pname, GLint* params)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glGetIntegerv(pname, params);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -863,7 +823,7 @@ inline void QOpenGLFunctions::glGetIntegerv(GLenum pname, GLint* params)
 
 inline const GLubyte *QOpenGLFunctions::glGetString(GLenum name)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     const GLubyte *result = ::glGetString(name);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -875,7 +835,7 @@ inline const GLubyte *QOpenGLFunctions::glGetString(GLenum name)
 
 inline void QOpenGLFunctions::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glGetTexParameterfv(target, pname, params);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -886,7 +846,7 @@ inline void QOpenGLFunctions::glGetTexParameterfv(GLenum target, GLenum pname, G
 
 inline void QOpenGLFunctions::glGetTexParameteriv(GLenum target, GLenum pname, GLint* params)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glGetTexParameteriv(target, pname, params);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -897,7 +857,7 @@ inline void QOpenGLFunctions::glGetTexParameteriv(GLenum target, GLenum pname, G
 
 inline void QOpenGLFunctions::glHint(GLenum target, GLenum mode)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glHint(target, mode);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -908,7 +868,7 @@ inline void QOpenGLFunctions::glHint(GLenum target, GLenum mode)
 
 inline GLboolean QOpenGLFunctions::glIsEnabled(GLenum cap)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     GLboolean result = ::glIsEnabled(cap);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -920,7 +880,7 @@ inline GLboolean QOpenGLFunctions::glIsEnabled(GLenum cap)
 
 inline GLboolean QOpenGLFunctions::glIsTexture(GLuint texture)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     GLboolean result = ::glIsTexture(texture);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -932,7 +892,7 @@ inline GLboolean QOpenGLFunctions::glIsTexture(GLuint texture)
 
 inline void QOpenGLFunctions::glLineWidth(GLfloat width)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glLineWidth(width);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -943,7 +903,7 @@ inline void QOpenGLFunctions::glLineWidth(GLfloat width)
 
 inline void QOpenGLFunctions::glPixelStorei(GLenum pname, GLint param)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glPixelStorei(pname, param);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -954,7 +914,7 @@ inline void QOpenGLFunctions::glPixelStorei(GLenum pname, GLint param)
 
 inline void QOpenGLFunctions::glPolygonOffset(GLfloat factor, GLfloat units)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glPolygonOffset(factor, units);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -965,7 +925,7 @@ inline void QOpenGLFunctions::glPolygonOffset(GLfloat factor, GLfloat units)
 
 inline void QOpenGLFunctions::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glReadPixels(x, y, width, height, format, type, pixels);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -976,7 +936,7 @@ inline void QOpenGLFunctions::glReadPixels(GLint x, GLint y, GLsizei width, GLsi
 
 inline void QOpenGLFunctions::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glScissor(x, y, width, height);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -987,7 +947,7 @@ inline void QOpenGLFunctions::glScissor(GLint x, GLint y, GLsizei width, GLsizei
 
 inline void QOpenGLFunctions::glStencilFunc(GLenum func, GLint ref, GLuint mask)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glStencilFunc(func, ref, mask);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -998,7 +958,7 @@ inline void QOpenGLFunctions::glStencilFunc(GLenum func, GLint ref, GLuint mask)
 
 inline void QOpenGLFunctions::glStencilMask(GLuint mask)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glStencilMask(mask);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1009,7 +969,7 @@ inline void QOpenGLFunctions::glStencilMask(GLuint mask)
 
 inline void QOpenGLFunctions::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glStencilOp(fail, zfail, zpass);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1020,7 +980,7 @@ inline void QOpenGLFunctions::glStencilOp(GLenum fail, GLenum zfail, GLenum zpas
 
 inline void QOpenGLFunctions::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pixels)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glTexImage2D(target, level, internalformat, width,height, border, format, type, pixels);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1031,7 +991,7 @@ inline void QOpenGLFunctions::glTexImage2D(GLenum target, GLint level, GLint int
 
 inline void QOpenGLFunctions::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glTexParameterf(target, pname, param);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1042,7 +1002,7 @@ inline void QOpenGLFunctions::glTexParameterf(GLenum target, GLenum pname, GLflo
 
 inline void QOpenGLFunctions::glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glTexParameterfv(target, pname, params);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1053,7 +1013,7 @@ inline void QOpenGLFunctions::glTexParameterfv(GLenum target, GLenum pname, cons
 
 inline void QOpenGLFunctions::glTexParameteri(GLenum target, GLenum pname, GLint param)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glTexParameteri(target, pname, param);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1064,7 +1024,7 @@ inline void QOpenGLFunctions::glTexParameteri(GLenum target, GLenum pname, GLint
 
 inline void QOpenGLFunctions::glTexParameteriv(GLenum target, GLenum pname, const GLint* params)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glTexParameteriv(target, pname, params);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1075,7 +1035,7 @@ inline void QOpenGLFunctions::glTexParameteriv(GLenum target, GLenum pname, cons
 
 inline void QOpenGLFunctions::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1086,7 +1046,7 @@ inline void QOpenGLFunctions::glTexSubImage2D(GLenum target, GLint level, GLint
 
 inline void QOpenGLFunctions::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glViewport(x, y, width, height);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1099,7 +1059,7 @@ inline void QOpenGLFunctions::glViewport(GLint x, GLint y, GLsizei width, GLsize
 
 inline void QOpenGLFunctions::glActiveTexture(GLenum texture)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glActiveTexture(texture);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1110,7 +1070,7 @@ inline void QOpenGLFunctions::glActiveTexture(GLenum texture)
 
 inline void QOpenGLFunctions::glAttachShader(GLuint program, GLuint shader)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glAttachShader(program, shader);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1121,7 +1081,7 @@ inline void QOpenGLFunctions::glAttachShader(GLuint program, GLuint shader)
 
 inline void QOpenGLFunctions::glBindAttribLocation(GLuint program, GLuint index, const char* name)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glBindAttribLocation(program, index, name);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1132,7 +1092,7 @@ inline void QOpenGLFunctions::glBindAttribLocation(GLuint program, GLuint index,
 
 inline void QOpenGLFunctions::glBindBuffer(GLenum target, GLuint buffer)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glBindBuffer(target, buffer);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1145,7 +1105,7 @@ inline void QOpenGLFunctions::glBindFramebuffer(GLenum target, GLuint framebuffe
 {
     if (framebuffer == 0)
         framebuffer = QOpenGLContext::currentContext()->defaultFramebufferObject();
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glBindFramebuffer(target, framebuffer);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1156,7 +1116,7 @@ inline void QOpenGLFunctions::glBindFramebuffer(GLenum target, GLuint framebuffe
 
 inline void QOpenGLFunctions::glBindRenderbuffer(GLenum target, GLuint renderbuffer)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glBindRenderbuffer(target, renderbuffer);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1167,7 +1127,7 @@ inline void QOpenGLFunctions::glBindRenderbuffer(GLenum target, GLuint renderbuf
 
 inline void QOpenGLFunctions::glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glBlendColor(red, green, blue, alpha);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1178,7 +1138,7 @@ inline void QOpenGLFunctions::glBlendColor(GLclampf red, GLclampf green, GLclamp
 
 inline void QOpenGLFunctions::glBlendEquation(GLenum mode)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glBlendEquation(mode);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1189,7 +1149,7 @@ inline void QOpenGLFunctions::glBlendEquation(GLenum mode)
 
 inline void QOpenGLFunctions::glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glBlendEquationSeparate(modeRGB, modeAlpha);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1200,7 +1160,7 @@ inline void QOpenGLFunctions::glBlendEquationSeparate(GLenum modeRGB, GLenum mod
 
 inline void QOpenGLFunctions::glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1211,7 +1171,7 @@ inline void QOpenGLFunctions::glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB,
 
 inline void QOpenGLFunctions::glBufferData(GLenum target, qopengl_GLsizeiptr size, const void* data, GLenum usage)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glBufferData(target, size, data, usage);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1222,7 +1182,7 @@ inline void QOpenGLFunctions::glBufferData(GLenum target, qopengl_GLsizeiptr siz
 
 inline void QOpenGLFunctions::glBufferSubData(GLenum target, qopengl_GLintptr offset, qopengl_GLsizeiptr size, const void* data)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glBufferSubData(target, offset, size, data);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1233,7 +1193,7 @@ inline void QOpenGLFunctions::glBufferSubData(GLenum target, qopengl_GLintptr of
 
 inline GLenum QOpenGLFunctions::glCheckFramebufferStatus(GLenum target)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     GLenum result = ::glCheckFramebufferStatus(target);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1245,7 +1205,7 @@ inline GLenum QOpenGLFunctions::glCheckFramebufferStatus(GLenum target)
 
 inline void QOpenGLFunctions::glClearDepthf(GLclampf depth)
 {
-#if defined(QT_OPENGL_ES) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glClearDepthf(depth);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1256,7 +1216,7 @@ inline void QOpenGLFunctions::glClearDepthf(GLclampf depth)
 
 inline void QOpenGLFunctions::glCompileShader(GLuint shader)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glCompileShader(shader);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1267,7 +1227,7 @@ inline void QOpenGLFunctions::glCompileShader(GLuint shader)
 
 inline void QOpenGLFunctions::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1278,7 +1238,7 @@ inline void QOpenGLFunctions::glCompressedTexImage2D(GLenum target, GLint level,
 
 inline void QOpenGLFunctions::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1289,7 +1249,7 @@ inline void QOpenGLFunctions::glCompressedTexSubImage2D(GLenum target, GLint lev
 
 inline GLuint QOpenGLFunctions::glCreateProgram()
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     GLuint result = ::glCreateProgram();
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1301,7 +1261,7 @@ inline GLuint QOpenGLFunctions::glCreateProgram()
 
 inline GLuint QOpenGLFunctions::glCreateShader(GLenum type)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     GLuint result = ::glCreateShader(type);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1313,7 +1273,7 @@ inline GLuint QOpenGLFunctions::glCreateShader(GLenum type)
 
 inline void QOpenGLFunctions::glDeleteBuffers(GLsizei n, const GLuint* buffers)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glDeleteBuffers(n, buffers);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1324,7 +1284,7 @@ inline void QOpenGLFunctions::glDeleteBuffers(GLsizei n, const GLuint* buffers)
 
 inline void QOpenGLFunctions::glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glDeleteFramebuffers(n, framebuffers);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1335,7 +1295,7 @@ inline void QOpenGLFunctions::glDeleteFramebuffers(GLsizei n, const GLuint* fram
 
 inline void QOpenGLFunctions::glDeleteProgram(GLuint program)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glDeleteProgram(program);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1346,7 +1306,7 @@ inline void QOpenGLFunctions::glDeleteProgram(GLuint program)
 
 inline void QOpenGLFunctions::glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glDeleteRenderbuffers(n, renderbuffers);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1357,7 +1317,7 @@ inline void QOpenGLFunctions::glDeleteRenderbuffers(GLsizei n, const GLuint* ren
 
 inline void QOpenGLFunctions::glDeleteShader(GLuint shader)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glDeleteShader(shader);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1368,7 +1328,7 @@ inline void QOpenGLFunctions::glDeleteShader(GLuint shader)
 
 inline void QOpenGLFunctions::glDepthRangef(GLclampf zNear, GLclampf zFar)
 {
-#if defined(QT_OPENGL_ES) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glDepthRangef(zNear, zFar);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1379,7 +1339,7 @@ inline void QOpenGLFunctions::glDepthRangef(GLclampf zNear, GLclampf zFar)
 
 inline void QOpenGLFunctions::glDetachShader(GLuint program, GLuint shader)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glDetachShader(program, shader);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1390,7 +1350,7 @@ inline void QOpenGLFunctions::glDetachShader(GLuint program, GLuint shader)
 
 inline void QOpenGLFunctions::glDisableVertexAttribArray(GLuint index)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glDisableVertexAttribArray(index);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1401,7 +1361,7 @@ inline void QOpenGLFunctions::glDisableVertexAttribArray(GLuint index)
 
 inline void QOpenGLFunctions::glEnableVertexAttribArray(GLuint index)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glEnableVertexAttribArray(index);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1412,7 +1372,7 @@ inline void QOpenGLFunctions::glEnableVertexAttribArray(GLuint index)
 
 inline void QOpenGLFunctions::glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1423,7 +1383,7 @@ inline void QOpenGLFunctions::glFramebufferRenderbuffer(GLenum target, GLenum at
 
 inline void QOpenGLFunctions::glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glFramebufferTexture2D(target, attachment, textarget, texture, level);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1434,7 +1394,7 @@ inline void QOpenGLFunctions::glFramebufferTexture2D(GLenum target, GLenum attac
 
 inline void QOpenGLFunctions::glGenBuffers(GLsizei n, GLuint* buffers)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glGenBuffers(n, buffers);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1445,7 +1405,7 @@ inline void QOpenGLFunctions::glGenBuffers(GLsizei n, GLuint* buffers)
 
 inline void QOpenGLFunctions::glGenerateMipmap(GLenum target)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glGenerateMipmap(target);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1456,7 +1416,7 @@ inline void QOpenGLFunctions::glGenerateMipmap(GLenum target)
 
 inline void QOpenGLFunctions::glGenFramebuffers(GLsizei n, GLuint* framebuffers)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glGenFramebuffers(n, framebuffers);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1467,7 +1427,7 @@ inline void QOpenGLFunctions::glGenFramebuffers(GLsizei n, GLuint* framebuffers)
 
 inline void QOpenGLFunctions::glGenRenderbuffers(GLsizei n, GLuint* renderbuffers)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glGenRenderbuffers(n, renderbuffers);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1478,7 +1438,7 @@ inline void QOpenGLFunctions::glGenRenderbuffers(GLsizei n, GLuint* renderbuffer
 
 inline void QOpenGLFunctions::glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glGetActiveAttrib(program, index, bufsize, length, size, type, name);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1489,7 +1449,7 @@ inline void QOpenGLFunctions::glGetActiveAttrib(GLuint program, GLuint index, GL
 
 inline void QOpenGLFunctions::glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glGetActiveUniform(program, index, bufsize, length, size, type, name);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1500,7 +1460,7 @@ inline void QOpenGLFunctions::glGetActiveUniform(GLuint program, GLuint index, G
 
 inline void QOpenGLFunctions::glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glGetAttachedShaders(program, maxcount, count, shaders);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1511,7 +1471,7 @@ inline void QOpenGLFunctions::glGetAttachedShaders(GLuint program, GLsizei maxco
 
 inline GLint QOpenGLFunctions::glGetAttribLocation(GLuint program, const char* name)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     GLint result = ::glGetAttribLocation(program, name);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1523,7 +1483,7 @@ inline GLint QOpenGLFunctions::glGetAttribLocation(GLuint program, const char* n
 
 inline void QOpenGLFunctions::glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glGetBufferParameteriv(target, pname, params);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1534,7 +1494,7 @@ inline void QOpenGLFunctions::glGetBufferParameteriv(GLenum target, GLenum pname
 
 inline void QOpenGLFunctions::glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1545,7 +1505,7 @@ inline void QOpenGLFunctions::glGetFramebufferAttachmentParameteriv(GLenum targe
 
 inline void QOpenGLFunctions::glGetProgramiv(GLuint program, GLenum pname, GLint* params)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glGetProgramiv(program, pname, params);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1556,7 +1516,7 @@ inline void QOpenGLFunctions::glGetProgramiv(GLuint program, GLenum pname, GLint
 
 inline void QOpenGLFunctions::glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glGetProgramInfoLog(program, bufsize, length, infolog);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1567,7 +1527,7 @@ inline void QOpenGLFunctions::glGetProgramInfoLog(GLuint program, GLsizei bufsiz
 
 inline void QOpenGLFunctions::glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glGetRenderbufferParameteriv(target, pname, params);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1578,7 +1538,7 @@ inline void QOpenGLFunctions::glGetRenderbufferParameteriv(GLenum target, GLenum
 
 inline void QOpenGLFunctions::glGetShaderiv(GLuint shader, GLenum pname, GLint* params)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glGetShaderiv(shader, pname, params);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1589,7 +1549,7 @@ inline void QOpenGLFunctions::glGetShaderiv(GLuint shader, GLenum pname, GLint*
 
 inline void QOpenGLFunctions::glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glGetShaderInfoLog(shader, bufsize, length, infolog);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1600,7 +1560,7 @@ inline void QOpenGLFunctions::glGetShaderInfoLog(GLuint shader, GLsizei bufsize,
 
 inline void QOpenGLFunctions::glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1611,7 +1571,7 @@ inline void QOpenGLFunctions::glGetShaderPrecisionFormat(GLenum shadertype, GLen
 
 inline void QOpenGLFunctions::glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, char* source)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glGetShaderSource(shader, bufsize, length, source);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1622,7 +1582,7 @@ inline void QOpenGLFunctions::glGetShaderSource(GLuint shader, GLsizei bufsize,
 
 inline void QOpenGLFunctions::glGetUniformfv(GLuint program, GLint location, GLfloat* params)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glGetUniformfv(program, location, params);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1633,7 +1593,7 @@ inline void QOpenGLFunctions::glGetUniformfv(GLuint program, GLint location, GLf
 
 inline void QOpenGLFunctions::glGetUniformiv(GLuint program, GLint location, GLint* params)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glGetUniformiv(program, location, params);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1644,7 +1604,7 @@ inline void QOpenGLFunctions::glGetUniformiv(GLuint program, GLint location, GLi
 
 inline GLint QOpenGLFunctions::glGetUniformLocation(GLuint program, const char* name)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     GLint result = ::glGetUniformLocation(program, name);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1656,7 +1616,7 @@ inline GLint QOpenGLFunctions::glGetUniformLocation(GLuint program, const char*
 
 inline void QOpenGLFunctions::glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glGetVertexAttribfv(index, pname, params);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1667,7 +1627,7 @@ inline void QOpenGLFunctions::glGetVertexAttribfv(GLuint index, GLenum pname, GL
 
 inline void QOpenGLFunctions::glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glGetVertexAttribiv(index, pname, params);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1678,7 +1638,7 @@ inline void QOpenGLFunctions::glGetVertexAttribiv(GLuint index, GLenum pname, GL
 
 inline void QOpenGLFunctions::glGetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glGetVertexAttribPointerv(index, pname, pointer);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1689,7 +1649,7 @@ inline void QOpenGLFunctions::glGetVertexAttribPointerv(GLuint index, GLenum pna
 
 inline GLboolean QOpenGLFunctions::glIsBuffer(GLuint buffer)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     GLboolean result = ::glIsBuffer(buffer);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1701,7 +1661,7 @@ inline GLboolean QOpenGLFunctions::glIsBuffer(GLuint buffer)
 
 inline GLboolean QOpenGLFunctions::glIsFramebuffer(GLuint framebuffer)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     GLboolean result = ::glIsFramebuffer(framebuffer);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1713,7 +1673,7 @@ inline GLboolean QOpenGLFunctions::glIsFramebuffer(GLuint framebuffer)
 
 inline GLboolean QOpenGLFunctions::glIsProgram(GLuint program)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     GLboolean result = ::glIsProgram(program);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1725,7 +1685,7 @@ inline GLboolean QOpenGLFunctions::glIsProgram(GLuint program)
 
 inline GLboolean QOpenGLFunctions::glIsRenderbuffer(GLuint renderbuffer)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     GLboolean result = ::glIsRenderbuffer(renderbuffer);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1737,7 +1697,7 @@ inline GLboolean QOpenGLFunctions::glIsRenderbuffer(GLuint renderbuffer)
 
 inline GLboolean QOpenGLFunctions::glIsShader(GLuint shader)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     GLboolean result = ::glIsShader(shader);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1749,7 +1709,7 @@ inline GLboolean QOpenGLFunctions::glIsShader(GLuint shader)
 
 inline void QOpenGLFunctions::glLinkProgram(GLuint program)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glLinkProgram(program);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1760,7 +1720,7 @@ inline void QOpenGLFunctions::glLinkProgram(GLuint program)
 
 inline void QOpenGLFunctions::glReleaseShaderCompiler()
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glReleaseShaderCompiler();
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1771,7 +1731,7 @@ inline void QOpenGLFunctions::glReleaseShaderCompiler()
 
 inline void QOpenGLFunctions::glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glRenderbufferStorage(target, internalformat, width, height);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1782,7 +1742,7 @@ inline void QOpenGLFunctions::glRenderbufferStorage(GLenum target, GLenum intern
 
 inline void QOpenGLFunctions::glSampleCoverage(GLclampf value, GLboolean invert)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glSampleCoverage(value, invert);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1793,7 +1753,7 @@ inline void QOpenGLFunctions::glSampleCoverage(GLclampf value, GLboolean invert)
 
 inline void QOpenGLFunctions::glShaderBinary(GLint n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLint length)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glShaderBinary(n, shaders, binaryformat, binary, length);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1804,7 +1764,7 @@ inline void QOpenGLFunctions::glShaderBinary(GLint n, const GLuint* shaders, GLe
 
 inline void QOpenGLFunctions::glShaderSource(GLuint shader, GLsizei count, const char** string, const GLint* length)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glShaderSource(shader, count, string, length);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1815,7 +1775,7 @@ inline void QOpenGLFunctions::glShaderSource(GLuint shader, GLsizei count, const
 
 inline void QOpenGLFunctions::glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glStencilFuncSeparate(face, func, ref, mask);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1826,7 +1786,7 @@ inline void QOpenGLFunctions::glStencilFuncSeparate(GLenum face, GLenum func, GL
 
 inline void QOpenGLFunctions::glStencilMaskSeparate(GLenum face, GLuint mask)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glStencilMaskSeparate(face, mask);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1837,7 +1797,7 @@ inline void QOpenGLFunctions::glStencilMaskSeparate(GLenum face, GLuint mask)
 
 inline void QOpenGLFunctions::glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glStencilOpSeparate(face, fail, zfail, zpass);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1848,7 +1808,7 @@ inline void QOpenGLFunctions::glStencilOpSeparate(GLenum face, GLenum fail, GLen
 
 inline void QOpenGLFunctions::glUniform1f(GLint location, GLfloat x)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glUniform1f(location, x);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1859,7 +1819,7 @@ inline void QOpenGLFunctions::glUniform1f(GLint location, GLfloat x)
 
 inline void QOpenGLFunctions::glUniform1fv(GLint location, GLsizei count, const GLfloat* v)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glUniform1fv(location, count, v);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1870,7 +1830,7 @@ inline void QOpenGLFunctions::glUniform1fv(GLint location, GLsizei count, const
 
 inline void QOpenGLFunctions::glUniform1i(GLint location, GLint x)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glUniform1i(location, x);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1881,7 +1841,7 @@ inline void QOpenGLFunctions::glUniform1i(GLint location, GLint x)
 
 inline void QOpenGLFunctions::glUniform1iv(GLint location, GLsizei count, const GLint* v)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glUniform1iv(location, count, v);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1892,7 +1852,7 @@ inline void QOpenGLFunctions::glUniform1iv(GLint location, GLsizei count, const
 
 inline void QOpenGLFunctions::glUniform2f(GLint location, GLfloat x, GLfloat y)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glUniform2f(location, x, y);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1903,7 +1863,7 @@ inline void QOpenGLFunctions::glUniform2f(GLint location, GLfloat x, GLfloat y)
 
 inline void QOpenGLFunctions::glUniform2fv(GLint location, GLsizei count, const GLfloat* v)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glUniform2fv(location, count, v);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1914,7 +1874,7 @@ inline void QOpenGLFunctions::glUniform2fv(GLint location, GLsizei count, const
 
 inline void QOpenGLFunctions::glUniform2i(GLint location, GLint x, GLint y)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glUniform2i(location, x, y);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1925,7 +1885,7 @@ inline void QOpenGLFunctions::glUniform2i(GLint location, GLint x, GLint y)
 
 inline void QOpenGLFunctions::glUniform2iv(GLint location, GLsizei count, const GLint* v)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glUniform2iv(location, count, v);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1936,7 +1896,7 @@ inline void QOpenGLFunctions::glUniform2iv(GLint location, GLsizei count, const
 
 inline void QOpenGLFunctions::glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glUniform3f(location, x, y, z);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1947,7 +1907,7 @@ inline void QOpenGLFunctions::glUniform3f(GLint location, GLfloat x, GLfloat y,
 
 inline void QOpenGLFunctions::glUniform3fv(GLint location, GLsizei count, const GLfloat* v)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glUniform3fv(location, count, v);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1958,7 +1918,7 @@ inline void QOpenGLFunctions::glUniform3fv(GLint location, GLsizei count, const
 
 inline void QOpenGLFunctions::glUniform3i(GLint location, GLint x, GLint y, GLint z)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glUniform3i(location, x, y, z);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1969,7 +1929,7 @@ inline void QOpenGLFunctions::glUniform3i(GLint location, GLint x, GLint y, GLin
 
 inline void QOpenGLFunctions::glUniform3iv(GLint location, GLsizei count, const GLint* v)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glUniform3iv(location, count, v);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1980,7 +1940,7 @@ inline void QOpenGLFunctions::glUniform3iv(GLint location, GLsizei count, const
 
 inline void QOpenGLFunctions::glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glUniform4f(location, x, y, z, w);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1991,7 +1951,7 @@ inline void QOpenGLFunctions::glUniform4f(GLint location, GLfloat x, GLfloat y,
 
 inline void QOpenGLFunctions::glUniform4fv(GLint location, GLsizei count, const GLfloat* v)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glUniform4fv(location, count, v);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -2002,7 +1962,7 @@ inline void QOpenGLFunctions::glUniform4fv(GLint location, GLsizei count, const
 
 inline void QOpenGLFunctions::glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glUniform4i(location, x, y, z, w);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -2013,7 +1973,7 @@ inline void QOpenGLFunctions::glUniform4i(GLint location, GLint x, GLint y, GLin
 
 inline void QOpenGLFunctions::glUniform4iv(GLint location, GLsizei count, const GLint* v)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glUniform4iv(location, count, v);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -2024,7 +1984,7 @@ inline void QOpenGLFunctions::glUniform4iv(GLint location, GLsizei count, const
 
 inline void QOpenGLFunctions::glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glUniformMatrix2fv(location, count, transpose, value);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -2035,7 +1995,7 @@ inline void QOpenGLFunctions::glUniformMatrix2fv(GLint location, GLsizei count,
 
 inline void QOpenGLFunctions::glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glUniformMatrix3fv(location, count, transpose, value);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -2046,7 +2006,7 @@ inline void QOpenGLFunctions::glUniformMatrix3fv(GLint location, GLsizei count,
 
 inline void QOpenGLFunctions::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glUniformMatrix4fv(location, count, transpose, value);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -2057,7 +2017,7 @@ inline void QOpenGLFunctions::glUniformMatrix4fv(GLint location, GLsizei count,
 
 inline void QOpenGLFunctions::glUseProgram(GLuint program)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glUseProgram(program);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -2068,7 +2028,7 @@ inline void QOpenGLFunctions::glUseProgram(GLuint program)
 
 inline void QOpenGLFunctions::glValidateProgram(GLuint program)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glValidateProgram(program);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -2079,7 +2039,7 @@ inline void QOpenGLFunctions::glValidateProgram(GLuint program)
 
 inline void QOpenGLFunctions::glVertexAttrib1f(GLuint indx, GLfloat x)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glVertexAttrib1f(indx, x);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -2090,7 +2050,7 @@ inline void QOpenGLFunctions::glVertexAttrib1f(GLuint indx, GLfloat x)
 
 inline void QOpenGLFunctions::glVertexAttrib1fv(GLuint indx, const GLfloat* values)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glVertexAttrib1fv(indx, values);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -2101,7 +2061,7 @@ inline void QOpenGLFunctions::glVertexAttrib1fv(GLuint indx, const GLfloat* valu
 
 inline void QOpenGLFunctions::glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glVertexAttrib2f(indx, x, y);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -2112,7 +2072,7 @@ inline void QOpenGLFunctions::glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y
 
 inline void QOpenGLFunctions::glVertexAttrib2fv(GLuint indx, const GLfloat* values)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glVertexAttrib2fv(indx, values);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -2123,7 +2083,7 @@ inline void QOpenGLFunctions::glVertexAttrib2fv(GLuint indx, const GLfloat* valu
 
 inline void QOpenGLFunctions::glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glVertexAttrib3f(indx, x, y, z);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -2134,7 +2094,7 @@ inline void QOpenGLFunctions::glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y
 
 inline void QOpenGLFunctions::glVertexAttrib3fv(GLuint indx, const GLfloat* values)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glVertexAttrib3fv(indx, values);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -2145,7 +2105,7 @@ inline void QOpenGLFunctions::glVertexAttrib3fv(GLuint indx, const GLfloat* valu
 
 inline void QOpenGLFunctions::glVertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glVertexAttrib4f(indx, x, y, z, w);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -2156,7 +2116,7 @@ inline void QOpenGLFunctions::glVertexAttrib4f(GLuint indx, GLfloat x, GLfloat y
 
 inline void QOpenGLFunctions::glVertexAttrib4fv(GLuint indx, const GLfloat* values)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glVertexAttrib4fv(indx, values);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -2167,7 +2127,7 @@ inline void QOpenGLFunctions::glVertexAttrib4fv(GLuint indx, const GLfloat* valu
 
 inline void QOpenGLFunctions::glVertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr)
 {
-#if defined(QT_OPENGL_ES_2) && defined(Q_OS_ANDROID)
+#if QT_CONFIG(opengles2) && defined(Q_OS_ANDROID)
     ::glVertexAttribPointer(indx, size, type, normalized, stride, ptr);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
diff --git a/src/gui/opengl/qopenglfunctions_1_0.cpp b/src/gui/opengl/qopenglfunctions_1_0.cpp
deleted file mode 100644
index f9d93ce210..0000000000
--- a/src/gui/opengl/qopenglfunctions_1_0.cpp
+++ /dev/null
@@ -1,136 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#include "qopenglfunctions_1_0.h"
-#include "qopenglcontext.h"
-
-QT_BEGIN_NAMESPACE
-
-/*!
-    \class QOpenGLFunctions_1_0
-    \inmodule QtGui
-    \since 5.1
-    \wrapper
-    \brief The QOpenGLFunctions_1_0 class provides all functions for OpenGL 1.0 specification.
-
-    This class is a wrapper for functions from OpenGL 1.0 specification.
-    See reference pages on \l {http://www.opengl.org/sdk/docs/}{opengl.org}
-    for function documentation.
-
-    \sa QAbstractOpenGLFunctions
-*/
-
-QOpenGLFunctions_1_0::QOpenGLFunctions_1_0()
- : QAbstractOpenGLFunctions()
- , d_1_0_Core(nullptr)
- , d_1_0_Deprecated(nullptr)
-{
-}
-
-QOpenGLFunctions_1_0::~QOpenGLFunctions_1_0()
-{
-    if (d_1_0_Core) {
-        d_1_0_Core->refs.deref();
-        Q_ASSERT(d_1_0_Core->refs.loadRelaxed());
-    }
-    if (d_1_0_Deprecated) {
-        d_1_0_Deprecated->refs.deref();
-        Q_ASSERT(d_1_0_Deprecated->refs.loadRelaxed());
-    }
-}
-
-bool QOpenGLFunctions_1_0::initializeOpenGLFunctions()
-{
-    if ( isInitialized() )
-        return true;
-
-    QOpenGLContext* context = QOpenGLContext::currentContext();
-
-    // If owned by a context object make sure it is current.
-    // Also check that current context is capable of resolving all needed functions
-    if (((owningContext() && owningContext() == context) || !owningContext())
-        && QOpenGLFunctions_1_0::isContextCompatible(context))
-    {
-        // Associate with private implementation, creating if necessary
-        // Function pointers in the backends are resolved at creation time
-        QOpenGLVersionFunctionsBackend* d = nullptr;
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
-        d_1_0_Deprecated = static_cast<QOpenGLFunctions_1_0_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        QAbstractOpenGLFunctions::initializeOpenGLFunctions();
-    }
-    return isInitialized();
-}
-
-bool QOpenGLFunctions_1_0::isContextCompatible(QOpenGLContext *context)
-{
-    Q_ASSERT(context);
-    QSurfaceFormat f = context->format();
-    const QPair<int, int> v = qMakePair(f.majorVersion(), f.minorVersion());
-    if (v < qMakePair(1, 0))
-        return false;
-
-    if (f.profile() == QSurfaceFormat::CoreProfile)
-        return false;
-
-    return true;
-}
-
-QOpenGLVersionProfile QOpenGLFunctions_1_0::versionProfile()
-{
-    QOpenGLVersionProfile v;
-    v.setVersion(1, 0);
-    return v;
-}
-
-QT_END_NAMESPACE
diff --git a/src/gui/opengl/qopenglfunctions_1_0.h b/src/gui/opengl/qopenglfunctions_1_0.h
deleted file mode 100644
index cddb7251ed..0000000000
--- a/src/gui/opengl/qopenglfunctions_1_0.h
+++ /dev/null
@@ -1,1929 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#ifndef QOPENGLVERSIONFUNCTIONS_1_0_H
-#define QOPENGLVERSIONFUNCTIONS_1_0_H
-
-#include <QtGui/qtguiglobal.h>
-
-#if !defined(QT_NO_OPENGL) && !defined(QT_OPENGL_ES_2)
-
-#include <QtGui/QOpenGLVersionFunctions>
-#include <QtGui/qopenglcontext.h>
-
-QT_BEGIN_NAMESPACE
-
-class Q_GUI_EXPORT QOpenGLFunctions_1_0 : public QAbstractOpenGLFunctions
-{
-public:
-    QOpenGLFunctions_1_0();
-    ~QOpenGLFunctions_1_0();
-
-    bool initializeOpenGLFunctions() override;
-
-    // OpenGL 1.0 core functions
-    void glViewport(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glDepthRange(GLdouble nearVal, GLdouble farVal);
-    GLboolean glIsEnabled(GLenum cap);
-    void glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params);
-    void glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params);
-    void glGetTexParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
-    const GLubyte * glGetString(GLenum name);
-    void glGetIntegerv(GLenum pname, GLint *params);
-    void glGetFloatv(GLenum pname, GLfloat *params);
-    GLenum glGetError();
-    void glGetDoublev(GLenum pname, GLdouble *params);
-    void glGetBooleanv(GLenum pname, GLboolean *params);
-    void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
-    void glReadBuffer(GLenum mode);
-    void glPixelStorei(GLenum pname, GLint param);
-    void glPixelStoref(GLenum pname, GLfloat param);
-    void glDepthFunc(GLenum func);
-    void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass);
-    void glStencilFunc(GLenum func, GLint ref, GLuint mask);
-    void glLogicOp(GLenum opcode);
-    void glBlendFunc(GLenum sfactor, GLenum dfactor);
-    void glFlush();
-    void glFinish();
-    void glEnable(GLenum cap);
-    void glDisable(GLenum cap);
-    void glDepthMask(GLboolean flag);
-    void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
-    void glStencilMask(GLuint mask);
-    void glClearDepth(GLdouble depth);
-    void glClearStencil(GLint s);
-    void glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glClear(GLbitfield mask);
-    void glDrawBuffer(GLenum mode);
-    void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glTexParameteri(GLenum target, GLenum pname, GLint param);
-    void glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glTexParameterf(GLenum target, GLenum pname, GLfloat param);
-    void glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glPolygonMode(GLenum face, GLenum mode);
-    void glPointSize(GLfloat size);
-    void glLineWidth(GLfloat width);
-    void glHint(GLenum target, GLenum mode);
-    void glFrontFace(GLenum mode);
-    void glCullFace(GLenum mode);
-
-    // OpenGL 1.0 deprecated functions
-    void glTranslatef(GLfloat x, GLfloat y, GLfloat z);
-    void glTranslated(GLdouble x, GLdouble y, GLdouble z);
-    void glScalef(GLfloat x, GLfloat y, GLfloat z);
-    void glScaled(GLdouble x, GLdouble y, GLdouble z);
-    void glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
-    void glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
-    void glPushMatrix();
-    void glPopMatrix();
-    void glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
-    void glMultMatrixd(const GLdouble *m);
-    void glMultMatrixf(const GLfloat *m);
-    void glMatrixMode(GLenum mode);
-    void glLoadMatrixd(const GLdouble *m);
-    void glLoadMatrixf(const GLfloat *m);
-    void glLoadIdentity();
-    void glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
-    GLboolean glIsList(GLuint list);
-    void glGetTexGeniv(GLenum coord, GLenum pname, GLint *params);
-    void glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params);
-    void glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params);
-    void glGetTexEnviv(GLenum target, GLenum pname, GLint *params);
-    void glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetPolygonStipple(GLubyte *mask);
-    void glGetPixelMapusv(GLenum map, GLushort *values);
-    void glGetPixelMapuiv(GLenum map, GLuint *values);
-    void glGetPixelMapfv(GLenum map, GLfloat *values);
-    void glGetMaterialiv(GLenum face, GLenum pname, GLint *params);
-    void glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params);
-    void glGetMapiv(GLenum target, GLenum query, GLint *v);
-    void glGetMapfv(GLenum target, GLenum query, GLfloat *v);
-    void glGetMapdv(GLenum target, GLenum query, GLdouble *v);
-    void glGetLightiv(GLenum light, GLenum pname, GLint *params);
-    void glGetLightfv(GLenum light, GLenum pname, GLfloat *params);
-    void glGetClipPlane(GLenum plane, GLdouble *equation);
-    void glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
-    void glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
-    void glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values);
-    void glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values);
-    void glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values);
-    void glPixelTransferi(GLenum pname, GLint param);
-    void glPixelTransferf(GLenum pname, GLfloat param);
-    void glPixelZoom(GLfloat xfactor, GLfloat yfactor);
-    void glAlphaFunc(GLenum func, GLfloat ref);
-    void glEvalPoint2(GLint i, GLint j);
-    void glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
-    void glEvalPoint1(GLint i);
-    void glEvalMesh1(GLenum mode, GLint i1, GLint i2);
-    void glEvalCoord2fv(const GLfloat *u);
-    void glEvalCoord2f(GLfloat u, GLfloat v);
-    void glEvalCoord2dv(const GLdouble *u);
-    void glEvalCoord2d(GLdouble u, GLdouble v);
-    void glEvalCoord1fv(const GLfloat *u);
-    void glEvalCoord1f(GLfloat u);
-    void glEvalCoord1dv(const GLdouble *u);
-    void glEvalCoord1d(GLdouble u);
-    void glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
-    void glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
-    void glMapGrid1f(GLint un, GLfloat u1, GLfloat u2);
-    void glMapGrid1d(GLint un, GLdouble u1, GLdouble u2);
-    void glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);
-    void glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);
-    void glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);
-    void glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);
-    void glPushAttrib(GLbitfield mask);
-    void glPopAttrib();
-    void glAccum(GLenum op, GLfloat value);
-    void glIndexMask(GLuint mask);
-    void glClearIndex(GLfloat c);
-    void glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glPushName(GLuint name);
-    void glPopName();
-    void glPassThrough(GLfloat token);
-    void glLoadName(GLuint name);
-    void glInitNames();
-    GLint glRenderMode(GLenum mode);
-    void glSelectBuffer(GLsizei size, GLuint *buffer);
-    void glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer);
-    void glTexGeniv(GLenum coord, GLenum pname, const GLint *params);
-    void glTexGeni(GLenum coord, GLenum pname, GLint param);
-    void glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params);
-    void glTexGenf(GLenum coord, GLenum pname, GLfloat param);
-    void glTexGendv(GLenum coord, GLenum pname, const GLdouble *params);
-    void glTexGend(GLenum coord, GLenum pname, GLdouble param);
-    void glTexEnviv(GLenum target, GLenum pname, const GLint *params);
-    void glTexEnvi(GLenum target, GLenum pname, GLint param);
-    void glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glTexEnvf(GLenum target, GLenum pname, GLfloat param);
-    void glShadeModel(GLenum mode);
-    void glPolygonStipple(const GLubyte *mask);
-    void glMaterialiv(GLenum face, GLenum pname, const GLint *params);
-    void glMateriali(GLenum face, GLenum pname, GLint param);
-    void glMaterialfv(GLenum face, GLenum pname, const GLfloat *params);
-    void glMaterialf(GLenum face, GLenum pname, GLfloat param);
-    void glLineStipple(GLint factor, GLushort pattern);
-    void glLightModeliv(GLenum pname, const GLint *params);
-    void glLightModeli(GLenum pname, GLint param);
-    void glLightModelfv(GLenum pname, const GLfloat *params);
-    void glLightModelf(GLenum pname, GLfloat param);
-    void glLightiv(GLenum light, GLenum pname, const GLint *params);
-    void glLighti(GLenum light, GLenum pname, GLint param);
-    void glLightfv(GLenum light, GLenum pname, const GLfloat *params);
-    void glLightf(GLenum light, GLenum pname, GLfloat param);
-    void glFogiv(GLenum pname, const GLint *params);
-    void glFogi(GLenum pname, GLint param);
-    void glFogfv(GLenum pname, const GLfloat *params);
-    void glFogf(GLenum pname, GLfloat param);
-    void glColorMaterial(GLenum face, GLenum mode);
-    void glClipPlane(GLenum plane, const GLdouble *equation);
-    void glVertex4sv(const GLshort *v);
-    void glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w);
-    void glVertex4iv(const GLint *v);
-    void glVertex4i(GLint x, GLint y, GLint z, GLint w);
-    void glVertex4fv(const GLfloat *v);
-    void glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void glVertex4dv(const GLdouble *v);
-    void glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glVertex3sv(const GLshort *v);
-    void glVertex3s(GLshort x, GLshort y, GLshort z);
-    void glVertex3iv(const GLint *v);
-    void glVertex3i(GLint x, GLint y, GLint z);
-    void glVertex3fv(const GLfloat *v);
-    void glVertex3f(GLfloat x, GLfloat y, GLfloat z);
-    void glVertex3dv(const GLdouble *v);
-    void glVertex3d(GLdouble x, GLdouble y, GLdouble z);
-    void glVertex2sv(const GLshort *v);
-    void glVertex2s(GLshort x, GLshort y);
-    void glVertex2iv(const GLint *v);
-    void glVertex2i(GLint x, GLint y);
-    void glVertex2fv(const GLfloat *v);
-    void glVertex2f(GLfloat x, GLfloat y);
-    void glVertex2dv(const GLdouble *v);
-    void glVertex2d(GLdouble x, GLdouble y);
-    void glTexCoord4sv(const GLshort *v);
-    void glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q);
-    void glTexCoord4iv(const GLint *v);
-    void glTexCoord4i(GLint s, GLint t, GLint r, GLint q);
-    void glTexCoord4fv(const GLfloat *v);
-    void glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
-    void glTexCoord4dv(const GLdouble *v);
-    void glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q);
-    void glTexCoord3sv(const GLshort *v);
-    void glTexCoord3s(GLshort s, GLshort t, GLshort r);
-    void glTexCoord3iv(const GLint *v);
-    void glTexCoord3i(GLint s, GLint t, GLint r);
-    void glTexCoord3fv(const GLfloat *v);
-    void glTexCoord3f(GLfloat s, GLfloat t, GLfloat r);
-    void glTexCoord3dv(const GLdouble *v);
-    void glTexCoord3d(GLdouble s, GLdouble t, GLdouble r);
-    void glTexCoord2sv(const GLshort *v);
-    void glTexCoord2s(GLshort s, GLshort t);
-    void glTexCoord2iv(const GLint *v);
-    void glTexCoord2i(GLint s, GLint t);
-    void glTexCoord2fv(const GLfloat *v);
-    void glTexCoord2f(GLfloat s, GLfloat t);
-    void glTexCoord2dv(const GLdouble *v);
-    void glTexCoord2d(GLdouble s, GLdouble t);
-    void glTexCoord1sv(const GLshort *v);
-    void glTexCoord1s(GLshort s);
-    void glTexCoord1iv(const GLint *v);
-    void glTexCoord1i(GLint s);
-    void glTexCoord1fv(const GLfloat *v);
-    void glTexCoord1f(GLfloat s);
-    void glTexCoord1dv(const GLdouble *v);
-    void glTexCoord1d(GLdouble s);
-    void glRectsv(const GLshort *v1, const GLshort *v2);
-    void glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
-    void glRectiv(const GLint *v1, const GLint *v2);
-    void glRecti(GLint x1, GLint y1, GLint x2, GLint y2);
-    void glRectfv(const GLfloat *v1, const GLfloat *v2);
-    void glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
-    void glRectdv(const GLdouble *v1, const GLdouble *v2);
-    void glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
-    void glRasterPos4sv(const GLshort *v);
-    void glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w);
-    void glRasterPos4iv(const GLint *v);
-    void glRasterPos4i(GLint x, GLint y, GLint z, GLint w);
-    void glRasterPos4fv(const GLfloat *v);
-    void glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void glRasterPos4dv(const GLdouble *v);
-    void glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glRasterPos3sv(const GLshort *v);
-    void glRasterPos3s(GLshort x, GLshort y, GLshort z);
-    void glRasterPos3iv(const GLint *v);
-    void glRasterPos3i(GLint x, GLint y, GLint z);
-    void glRasterPos3fv(const GLfloat *v);
-    void glRasterPos3f(GLfloat x, GLfloat y, GLfloat z);
-    void glRasterPos3dv(const GLdouble *v);
-    void glRasterPos3d(GLdouble x, GLdouble y, GLdouble z);
-    void glRasterPos2sv(const GLshort *v);
-    void glRasterPos2s(GLshort x, GLshort y);
-    void glRasterPos2iv(const GLint *v);
-    void glRasterPos2i(GLint x, GLint y);
-    void glRasterPos2fv(const GLfloat *v);
-    void glRasterPos2f(GLfloat x, GLfloat y);
-    void glRasterPos2dv(const GLdouble *v);
-    void glRasterPos2d(GLdouble x, GLdouble y);
-    void glNormal3sv(const GLshort *v);
-    void glNormal3s(GLshort nx, GLshort ny, GLshort nz);
-    void glNormal3iv(const GLint *v);
-    void glNormal3i(GLint nx, GLint ny, GLint nz);
-    void glNormal3fv(const GLfloat *v);
-    void glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz);
-    void glNormal3dv(const GLdouble *v);
-    void glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz);
-    void glNormal3bv(const GLbyte *v);
-    void glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz);
-    void glIndexsv(const GLshort *c);
-    void glIndexs(GLshort c);
-    void glIndexiv(const GLint *c);
-    void glIndexi(GLint c);
-    void glIndexfv(const GLfloat *c);
-    void glIndexf(GLfloat c);
-    void glIndexdv(const GLdouble *c);
-    void glIndexd(GLdouble c);
-    void glEnd();
-    void glEdgeFlagv(const GLboolean *flag);
-    void glEdgeFlag(GLboolean flag);
-    void glColor4usv(const GLushort *v);
-    void glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha);
-    void glColor4uiv(const GLuint *v);
-    void glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha);
-    void glColor4ubv(const GLubyte *v);
-    void glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
-    void glColor4sv(const GLshort *v);
-    void glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha);
-    void glColor4iv(const GLint *v);
-    void glColor4i(GLint red, GLint green, GLint blue, GLint alpha);
-    void glColor4fv(const GLfloat *v);
-    void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glColor4dv(const GLdouble *v);
-    void glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
-    void glColor4bv(const GLbyte *v);
-    void glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
-    void glColor3usv(const GLushort *v);
-    void glColor3us(GLushort red, GLushort green, GLushort blue);
-    void glColor3uiv(const GLuint *v);
-    void glColor3ui(GLuint red, GLuint green, GLuint blue);
-    void glColor3ubv(const GLubyte *v);
-    void glColor3ub(GLubyte red, GLubyte green, GLubyte blue);
-    void glColor3sv(const GLshort *v);
-    void glColor3s(GLshort red, GLshort green, GLshort blue);
-    void glColor3iv(const GLint *v);
-    void glColor3i(GLint red, GLint green, GLint blue);
-    void glColor3fv(const GLfloat *v);
-    void glColor3f(GLfloat red, GLfloat green, GLfloat blue);
-    void glColor3dv(const GLdouble *v);
-    void glColor3d(GLdouble red, GLdouble green, GLdouble blue);
-    void glColor3bv(const GLbyte *v);
-    void glColor3b(GLbyte red, GLbyte green, GLbyte blue);
-    void glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap);
-    void glBegin(GLenum mode);
-    void glListBase(GLuint base);
-    GLuint glGenLists(GLsizei range);
-    void glDeleteLists(GLuint list, GLsizei range);
-    void glCallLists(GLsizei n, GLenum type, const GLvoid *lists);
-    void glCallList(GLuint list);
-    void glEndList();
-    void glNewList(GLuint list, GLenum mode);
-
-private:
-    friend class QOpenGLContext;
-
-    static bool isContextCompatible(QOpenGLContext *context);
-    static QOpenGLVersionProfile versionProfile();
-
-    QOpenGLFunctions_1_0_CoreBackend* d_1_0_Core;
-    QOpenGLFunctions_1_0_DeprecatedBackend* d_1_0_Deprecated;
-};
-
-// OpenGL 1.0 core functions
-inline void QOpenGLFunctions_1_0::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_0_Core->f.Viewport(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_1_0::glDepthRange(GLdouble nearVal, GLdouble farVal)
-{
-    d_1_0_Core->f.DepthRange(nearVal, farVal);
-}
-
-inline GLboolean QOpenGLFunctions_1_0::glIsEnabled(GLenum cap)
-{
-    return d_1_0_Core->f.IsEnabled(cap);
-}
-
-inline void QOpenGLFunctions_1_0::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
-}
-
-inline void QOpenGLFunctions_1_0::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
-}
-
-inline void QOpenGLFunctions_1_0::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetTexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_0::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetTexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_0::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
-{
-    d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
-}
-
-inline const GLubyte * QOpenGLFunctions_1_0::glGetString(GLenum name)
-{
-    return d_1_0_Core->f.GetString(name);
-}
-
-inline void QOpenGLFunctions_1_0::glGetIntegerv(GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetIntegerv(pname, params);
-}
-
-inline void QOpenGLFunctions_1_0::glGetFloatv(GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetFloatv(pname, params);
-}
-
-inline GLenum QOpenGLFunctions_1_0::glGetError()
-{
-    return d_1_0_Core->f.GetError();
-}
-
-inline void QOpenGLFunctions_1_0::glGetDoublev(GLenum pname, GLdouble *params)
-{
-    d_1_0_Core->f.GetDoublev(pname, params);
-}
-
-inline void QOpenGLFunctions_1_0::glGetBooleanv(GLenum pname, GLboolean *params)
-{
-    d_1_0_Core->f.GetBooleanv(pname, params);
-}
-
-inline void QOpenGLFunctions_1_0::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
-{
-    d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_1_0::glReadBuffer(GLenum mode)
-{
-    d_1_0_Core->f.ReadBuffer(mode);
-}
-
-inline void QOpenGLFunctions_1_0::glPixelStorei(GLenum pname, GLint param)
-{
-    d_1_0_Core->f.PixelStorei(pname, param);
-}
-
-inline void QOpenGLFunctions_1_0::glPixelStoref(GLenum pname, GLfloat param)
-{
-    d_1_0_Core->f.PixelStoref(pname, param);
-}
-
-inline void QOpenGLFunctions_1_0::glDepthFunc(GLenum func)
-{
-    d_1_0_Core->f.DepthFunc(func);
-}
-
-inline void QOpenGLFunctions_1_0::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
-{
-    d_1_0_Core->f.StencilOp(fail, zfail, zpass);
-}
-
-inline void QOpenGLFunctions_1_0::glStencilFunc(GLenum func, GLint ref, GLuint mask)
-{
-    d_1_0_Core->f.StencilFunc(func, ref, mask);
-}
-
-inline void QOpenGLFunctions_1_0::glLogicOp(GLenum opcode)
-{
-    d_1_0_Core->f.LogicOp(opcode);
-}
-
-inline void QOpenGLFunctions_1_0::glBlendFunc(GLenum sfactor, GLenum dfactor)
-{
-    d_1_0_Core->f.BlendFunc(sfactor, dfactor);
-}
-
-inline void QOpenGLFunctions_1_0::glFlush()
-{
-    d_1_0_Core->f.Flush();
-}
-
-inline void QOpenGLFunctions_1_0::glFinish()
-{
-    d_1_0_Core->f.Finish();
-}
-
-inline void QOpenGLFunctions_1_0::glEnable(GLenum cap)
-{
-    d_1_0_Core->f.Enable(cap);
-}
-
-inline void QOpenGLFunctions_1_0::glDisable(GLenum cap)
-{
-    d_1_0_Core->f.Disable(cap);
-}
-
-inline void QOpenGLFunctions_1_0::glDepthMask(GLboolean flag)
-{
-    d_1_0_Core->f.DepthMask(flag);
-}
-
-inline void QOpenGLFunctions_1_0::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
-{
-    d_1_0_Core->f.ColorMask(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_0::glStencilMask(GLuint mask)
-{
-    d_1_0_Core->f.StencilMask(mask);
-}
-
-inline void QOpenGLFunctions_1_0::glClearDepth(GLdouble depth)
-{
-    d_1_0_Core->f.ClearDepth(depth);
-}
-
-inline void QOpenGLFunctions_1_0::glClearStencil(GLint s)
-{
-    d_1_0_Core->f.ClearStencil(s);
-}
-
-inline void QOpenGLFunctions_1_0::glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Core->f.ClearColor(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_0::glClear(GLbitfield mask)
-{
-    d_1_0_Core->f.Clear(mask);
-}
-
-inline void QOpenGLFunctions_1_0::glDrawBuffer(GLenum mode)
-{
-    d_1_0_Core->f.DrawBuffer(mode);
-}
-
-inline void QOpenGLFunctions_1_0::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Core->f.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_1_0::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Core->f.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_1_0::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_0_Core->f.TexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_0::glTexParameteri(GLenum target, GLenum pname, GLint param)
-{
-    d_1_0_Core->f.TexParameteri(target, pname, param);
-}
-
-inline void QOpenGLFunctions_1_0::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Core->f.TexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_0::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
-{
-    d_1_0_Core->f.TexParameterf(target, pname, param);
-}
-
-inline void QOpenGLFunctions_1_0::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_0_Core->f.Scissor(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_1_0::glPolygonMode(GLenum face, GLenum mode)
-{
-    d_1_0_Core->f.PolygonMode(face, mode);
-}
-
-inline void QOpenGLFunctions_1_0::glPointSize(GLfloat size)
-{
-    d_1_0_Core->f.PointSize(size);
-}
-
-inline void QOpenGLFunctions_1_0::glLineWidth(GLfloat width)
-{
-    d_1_0_Core->f.LineWidth(width);
-}
-
-inline void QOpenGLFunctions_1_0::glHint(GLenum target, GLenum mode)
-{
-    d_1_0_Core->f.Hint(target, mode);
-}
-
-inline void QOpenGLFunctions_1_0::glFrontFace(GLenum mode)
-{
-    d_1_0_Core->f.FrontFace(mode);
-}
-
-inline void QOpenGLFunctions_1_0::glCullFace(GLenum mode)
-{
-    d_1_0_Core->f.CullFace(mode);
-}
-
-
-// OpenGL 1.0 deprecated functions
-inline void QOpenGLFunctions_1_0::glTranslatef(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Translatef(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_0::glTranslated(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Translated(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_0::glScalef(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Scalef(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_0::glScaled(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Scaled(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_0::glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Rotatef(angle, x, y, z);
-}
-
-inline void QOpenGLFunctions_1_0::glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Rotated(angle, x, y, z);
-}
-
-inline void QOpenGLFunctions_1_0::glPushMatrix()
-{
-    d_1_0_Deprecated->f.PushMatrix();
-}
-
-inline void QOpenGLFunctions_1_0::glPopMatrix()
-{
-    d_1_0_Deprecated->f.PopMatrix();
-}
-
-inline void QOpenGLFunctions_1_0::glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
-{
-    d_1_0_Deprecated->f.Ortho(left, right, bottom, top, zNear, zFar);
-}
-
-inline void QOpenGLFunctions_1_0::glMultMatrixd(const GLdouble *m)
-{
-    d_1_0_Deprecated->f.MultMatrixd(m);
-}
-
-inline void QOpenGLFunctions_1_0::glMultMatrixf(const GLfloat *m)
-{
-    d_1_0_Deprecated->f.MultMatrixf(m);
-}
-
-inline void QOpenGLFunctions_1_0::glMatrixMode(GLenum mode)
-{
-    d_1_0_Deprecated->f.MatrixMode(mode);
-}
-
-inline void QOpenGLFunctions_1_0::glLoadMatrixd(const GLdouble *m)
-{
-    d_1_0_Deprecated->f.LoadMatrixd(m);
-}
-
-inline void QOpenGLFunctions_1_0::glLoadMatrixf(const GLfloat *m)
-{
-    d_1_0_Deprecated->f.LoadMatrixf(m);
-}
-
-inline void QOpenGLFunctions_1_0::glLoadIdentity()
-{
-    d_1_0_Deprecated->f.LoadIdentity();
-}
-
-inline void QOpenGLFunctions_1_0::glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
-{
-    d_1_0_Deprecated->f.Frustum(left, right, bottom, top, zNear, zFar);
-}
-
-inline GLboolean QOpenGLFunctions_1_0::glIsList(GLuint list)
-{
-    return d_1_0_Deprecated->f.IsList(list);
-}
-
-inline void QOpenGLFunctions_1_0::glGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetTexGeniv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_1_0::glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetTexGenfv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_1_0::glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
-{
-    d_1_0_Deprecated->f.GetTexGendv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_1_0::glGetTexEnviv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetTexEnviv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_0::glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetTexEnvfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_0::glGetPolygonStipple(GLubyte *mask)
-{
-    d_1_0_Deprecated->f.GetPolygonStipple(mask);
-}
-
-inline void QOpenGLFunctions_1_0::glGetPixelMapusv(GLenum map, GLushort *values)
-{
-    d_1_0_Deprecated->f.GetPixelMapusv(map, values);
-}
-
-inline void QOpenGLFunctions_1_0::glGetPixelMapuiv(GLenum map, GLuint *values)
-{
-    d_1_0_Deprecated->f.GetPixelMapuiv(map, values);
-}
-
-inline void QOpenGLFunctions_1_0::glGetPixelMapfv(GLenum map, GLfloat *values)
-{
-    d_1_0_Deprecated->f.GetPixelMapfv(map, values);
-}
-
-inline void QOpenGLFunctions_1_0::glGetMaterialiv(GLenum face, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetMaterialiv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_1_0::glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetMaterialfv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_1_0::glGetMapiv(GLenum target, GLenum query, GLint *v)
-{
-    d_1_0_Deprecated->f.GetMapiv(target, query, v);
-}
-
-inline void QOpenGLFunctions_1_0::glGetMapfv(GLenum target, GLenum query, GLfloat *v)
-{
-    d_1_0_Deprecated->f.GetMapfv(target, query, v);
-}
-
-inline void QOpenGLFunctions_1_0::glGetMapdv(GLenum target, GLenum query, GLdouble *v)
-{
-    d_1_0_Deprecated->f.GetMapdv(target, query, v);
-}
-
-inline void QOpenGLFunctions_1_0::glGetLightiv(GLenum light, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetLightiv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_1_0::glGetLightfv(GLenum light, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetLightfv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_1_0::glGetClipPlane(GLenum plane, GLdouble *equation)
-{
-    d_1_0_Deprecated->f.GetClipPlane(plane, equation);
-}
-
-inline void QOpenGLFunctions_1_0::glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Deprecated->f.DrawPixels(width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_1_0::glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
-{
-    d_1_0_Deprecated->f.CopyPixels(x, y, width, height, type);
-}
-
-inline void QOpenGLFunctions_1_0::glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values)
-{
-    d_1_0_Deprecated->f.PixelMapusv(map, mapsize, values);
-}
-
-inline void QOpenGLFunctions_1_0::glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values)
-{
-    d_1_0_Deprecated->f.PixelMapuiv(map, mapsize, values);
-}
-
-inline void QOpenGLFunctions_1_0::glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values)
-{
-    d_1_0_Deprecated->f.PixelMapfv(map, mapsize, values);
-}
-
-inline void QOpenGLFunctions_1_0::glPixelTransferi(GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.PixelTransferi(pname, param);
-}
-
-inline void QOpenGLFunctions_1_0::glPixelTransferf(GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.PixelTransferf(pname, param);
-}
-
-inline void QOpenGLFunctions_1_0::glPixelZoom(GLfloat xfactor, GLfloat yfactor)
-{
-    d_1_0_Deprecated->f.PixelZoom(xfactor, yfactor);
-}
-
-inline void QOpenGLFunctions_1_0::glAlphaFunc(GLenum func, GLfloat ref)
-{
-    d_1_0_Deprecated->f.AlphaFunc(func, ref);
-}
-
-inline void QOpenGLFunctions_1_0::glEvalPoint2(GLint i, GLint j)
-{
-    d_1_0_Deprecated->f.EvalPoint2(i, j);
-}
-
-inline void QOpenGLFunctions_1_0::glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
-{
-    d_1_0_Deprecated->f.EvalMesh2(mode, i1, i2, j1, j2);
-}
-
-inline void QOpenGLFunctions_1_0::glEvalPoint1(GLint i)
-{
-    d_1_0_Deprecated->f.EvalPoint1(i);
-}
-
-inline void QOpenGLFunctions_1_0::glEvalMesh1(GLenum mode, GLint i1, GLint i2)
-{
-    d_1_0_Deprecated->f.EvalMesh1(mode, i1, i2);
-}
-
-inline void QOpenGLFunctions_1_0::glEvalCoord2fv(const GLfloat *u)
-{
-    d_1_0_Deprecated->f.EvalCoord2fv(u);
-}
-
-inline void QOpenGLFunctions_1_0::glEvalCoord2f(GLfloat u, GLfloat v)
-{
-    d_1_0_Deprecated->f.EvalCoord2f(u, v);
-}
-
-inline void QOpenGLFunctions_1_0::glEvalCoord2dv(const GLdouble *u)
-{
-    d_1_0_Deprecated->f.EvalCoord2dv(u);
-}
-
-inline void QOpenGLFunctions_1_0::glEvalCoord2d(GLdouble u, GLdouble v)
-{
-    d_1_0_Deprecated->f.EvalCoord2d(u, v);
-}
-
-inline void QOpenGLFunctions_1_0::glEvalCoord1fv(const GLfloat *u)
-{
-    d_1_0_Deprecated->f.EvalCoord1fv(u);
-}
-
-inline void QOpenGLFunctions_1_0::glEvalCoord1f(GLfloat u)
-{
-    d_1_0_Deprecated->f.EvalCoord1f(u);
-}
-
-inline void QOpenGLFunctions_1_0::glEvalCoord1dv(const GLdouble *u)
-{
-    d_1_0_Deprecated->f.EvalCoord1dv(u);
-}
-
-inline void QOpenGLFunctions_1_0::glEvalCoord1d(GLdouble u)
-{
-    d_1_0_Deprecated->f.EvalCoord1d(u);
-}
-
-inline void QOpenGLFunctions_1_0::glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
-{
-    d_1_0_Deprecated->f.MapGrid2f(un, u1, u2, vn, v1, v2);
-}
-
-inline void QOpenGLFunctions_1_0::glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
-{
-    d_1_0_Deprecated->f.MapGrid2d(un, u1, u2, vn, v1, v2);
-}
-
-inline void QOpenGLFunctions_1_0::glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
-{
-    d_1_0_Deprecated->f.MapGrid1f(un, u1, u2);
-}
-
-inline void QOpenGLFunctions_1_0::glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
-{
-    d_1_0_Deprecated->f.MapGrid1d(un, u1, u2);
-}
-
-inline void QOpenGLFunctions_1_0::glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
-{
-    d_1_0_Deprecated->f.Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
-}
-
-inline void QOpenGLFunctions_1_0::glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
-{
-    d_1_0_Deprecated->f.Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
-}
-
-inline void QOpenGLFunctions_1_0::glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
-{
-    d_1_0_Deprecated->f.Map1f(target, u1, u2, stride, order, points);
-}
-
-inline void QOpenGLFunctions_1_0::glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
-{
-    d_1_0_Deprecated->f.Map1d(target, u1, u2, stride, order, points);
-}
-
-inline void QOpenGLFunctions_1_0::glPushAttrib(GLbitfield mask)
-{
-    d_1_0_Deprecated->f.PushAttrib(mask);
-}
-
-inline void QOpenGLFunctions_1_0::glPopAttrib()
-{
-    d_1_0_Deprecated->f.PopAttrib();
-}
-
-inline void QOpenGLFunctions_1_0::glAccum(GLenum op, GLfloat value)
-{
-    d_1_0_Deprecated->f.Accum(op, value);
-}
-
-inline void QOpenGLFunctions_1_0::glIndexMask(GLuint mask)
-{
-    d_1_0_Deprecated->f.IndexMask(mask);
-}
-
-inline void QOpenGLFunctions_1_0::glClearIndex(GLfloat c)
-{
-    d_1_0_Deprecated->f.ClearIndex(c);
-}
-
-inline void QOpenGLFunctions_1_0::glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Deprecated->f.ClearAccum(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_0::glPushName(GLuint name)
-{
-    d_1_0_Deprecated->f.PushName(name);
-}
-
-inline void QOpenGLFunctions_1_0::glPopName()
-{
-    d_1_0_Deprecated->f.PopName();
-}
-
-inline void QOpenGLFunctions_1_0::glPassThrough(GLfloat token)
-{
-    d_1_0_Deprecated->f.PassThrough(token);
-}
-
-inline void QOpenGLFunctions_1_0::glLoadName(GLuint name)
-{
-    d_1_0_Deprecated->f.LoadName(name);
-}
-
-inline void QOpenGLFunctions_1_0::glInitNames()
-{
-    d_1_0_Deprecated->f.InitNames();
-}
-
-inline GLint QOpenGLFunctions_1_0::glRenderMode(GLenum mode)
-{
-    return d_1_0_Deprecated->f.RenderMode(mode);
-}
-
-inline void QOpenGLFunctions_1_0::glSelectBuffer(GLsizei size, GLuint *buffer)
-{
-    d_1_0_Deprecated->f.SelectBuffer(size, buffer);
-}
-
-inline void QOpenGLFunctions_1_0::glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
-{
-    d_1_0_Deprecated->f.FeedbackBuffer(size, type, buffer);
-}
-
-inline void QOpenGLFunctions_1_0::glTexGeniv(GLenum coord, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.TexGeniv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_1_0::glTexGeni(GLenum coord, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.TexGeni(coord, pname, param);
-}
-
-inline void QOpenGLFunctions_1_0::glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.TexGenfv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_1_0::glTexGenf(GLenum coord, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.TexGenf(coord, pname, param);
-}
-
-inline void QOpenGLFunctions_1_0::glTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
-{
-    d_1_0_Deprecated->f.TexGendv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_1_0::glTexGend(GLenum coord, GLenum pname, GLdouble param)
-{
-    d_1_0_Deprecated->f.TexGend(coord, pname, param);
-}
-
-inline void QOpenGLFunctions_1_0::glTexEnviv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.TexEnviv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_0::glTexEnvi(GLenum target, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.TexEnvi(target, pname, param);
-}
-
-inline void QOpenGLFunctions_1_0::glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.TexEnvfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_0::glTexEnvf(GLenum target, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.TexEnvf(target, pname, param);
-}
-
-inline void QOpenGLFunctions_1_0::glShadeModel(GLenum mode)
-{
-    d_1_0_Deprecated->f.ShadeModel(mode);
-}
-
-inline void QOpenGLFunctions_1_0::glPolygonStipple(const GLubyte *mask)
-{
-    d_1_0_Deprecated->f.PolygonStipple(mask);
-}
-
-inline void QOpenGLFunctions_1_0::glMaterialiv(GLenum face, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.Materialiv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_1_0::glMateriali(GLenum face, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.Materiali(face, pname, param);
-}
-
-inline void QOpenGLFunctions_1_0::glMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.Materialfv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_1_0::glMaterialf(GLenum face, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.Materialf(face, pname, param);
-}
-
-inline void QOpenGLFunctions_1_0::glLineStipple(GLint factor, GLushort pattern)
-{
-    d_1_0_Deprecated->f.LineStipple(factor, pattern);
-}
-
-inline void QOpenGLFunctions_1_0::glLightModeliv(GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.LightModeliv(pname, params);
-}
-
-inline void QOpenGLFunctions_1_0::glLightModeli(GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.LightModeli(pname, param);
-}
-
-inline void QOpenGLFunctions_1_0::glLightModelfv(GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.LightModelfv(pname, params);
-}
-
-inline void QOpenGLFunctions_1_0::glLightModelf(GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.LightModelf(pname, param);
-}
-
-inline void QOpenGLFunctions_1_0::glLightiv(GLenum light, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.Lightiv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_1_0::glLighti(GLenum light, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.Lighti(light, pname, param);
-}
-
-inline void QOpenGLFunctions_1_0::glLightfv(GLenum light, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.Lightfv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_1_0::glLightf(GLenum light, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.Lightf(light, pname, param);
-}
-
-inline void QOpenGLFunctions_1_0::glFogiv(GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.Fogiv(pname, params);
-}
-
-inline void QOpenGLFunctions_1_0::glFogi(GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.Fogi(pname, param);
-}
-
-inline void QOpenGLFunctions_1_0::glFogfv(GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.Fogfv(pname, params);
-}
-
-inline void QOpenGLFunctions_1_0::glFogf(GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.Fogf(pname, param);
-}
-
-inline void QOpenGLFunctions_1_0::glColorMaterial(GLenum face, GLenum mode)
-{
-    d_1_0_Deprecated->f.ColorMaterial(face, mode);
-}
-
-inline void QOpenGLFunctions_1_0::glClipPlane(GLenum plane, const GLdouble *equation)
-{
-    d_1_0_Deprecated->f.ClipPlane(plane, equation);
-}
-
-inline void QOpenGLFunctions_1_0::glVertex4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Vertex4sv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
-{
-    d_1_0_Deprecated->f.Vertex4s(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_1_0::glVertex4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Vertex4iv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glVertex4i(GLint x, GLint y, GLint z, GLint w)
-{
-    d_1_0_Deprecated->f.Vertex4i(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_1_0::glVertex4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Vertex4fv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    d_1_0_Deprecated->f.Vertex4f(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_1_0::glVertex4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Vertex4dv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_1_0_Deprecated->f.Vertex4d(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_1_0::glVertex3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Vertex3sv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glVertex3s(GLshort x, GLshort y, GLshort z)
-{
-    d_1_0_Deprecated->f.Vertex3s(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_0::glVertex3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Vertex3iv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glVertex3i(GLint x, GLint y, GLint z)
-{
-    d_1_0_Deprecated->f.Vertex3i(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_0::glVertex3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Vertex3fv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glVertex3f(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Vertex3f(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_0::glVertex3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Vertex3dv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glVertex3d(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Vertex3d(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_0::glVertex2sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Vertex2sv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glVertex2s(GLshort x, GLshort y)
-{
-    d_1_0_Deprecated->f.Vertex2s(x, y);
-}
-
-inline void QOpenGLFunctions_1_0::glVertex2iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Vertex2iv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glVertex2i(GLint x, GLint y)
-{
-    d_1_0_Deprecated->f.Vertex2i(x, y);
-}
-
-inline void QOpenGLFunctions_1_0::glVertex2fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Vertex2fv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glVertex2f(GLfloat x, GLfloat y)
-{
-    d_1_0_Deprecated->f.Vertex2f(x, y);
-}
-
-inline void QOpenGLFunctions_1_0::glVertex2dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Vertex2dv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glVertex2d(GLdouble x, GLdouble y)
-{
-    d_1_0_Deprecated->f.Vertex2d(x, y);
-}
-
-inline void QOpenGLFunctions_1_0::glTexCoord4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord4sv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
-{
-    d_1_0_Deprecated->f.TexCoord4s(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_1_0::glTexCoord4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord4iv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
-{
-    d_1_0_Deprecated->f.TexCoord4i(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_1_0::glTexCoord4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord4fv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
-{
-    d_1_0_Deprecated->f.TexCoord4f(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_1_0::glTexCoord4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord4dv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
-{
-    d_1_0_Deprecated->f.TexCoord4d(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_1_0::glTexCoord3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord3sv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glTexCoord3s(GLshort s, GLshort t, GLshort r)
-{
-    d_1_0_Deprecated->f.TexCoord3s(s, t, r);
-}
-
-inline void QOpenGLFunctions_1_0::glTexCoord3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord3iv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glTexCoord3i(GLint s, GLint t, GLint r)
-{
-    d_1_0_Deprecated->f.TexCoord3i(s, t, r);
-}
-
-inline void QOpenGLFunctions_1_0::glTexCoord3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord3fv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
-{
-    d_1_0_Deprecated->f.TexCoord3f(s, t, r);
-}
-
-inline void QOpenGLFunctions_1_0::glTexCoord3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord3dv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
-{
-    d_1_0_Deprecated->f.TexCoord3d(s, t, r);
-}
-
-inline void QOpenGLFunctions_1_0::glTexCoord2sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord2sv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glTexCoord2s(GLshort s, GLshort t)
-{
-    d_1_0_Deprecated->f.TexCoord2s(s, t);
-}
-
-inline void QOpenGLFunctions_1_0::glTexCoord2iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord2iv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glTexCoord2i(GLint s, GLint t)
-{
-    d_1_0_Deprecated->f.TexCoord2i(s, t);
-}
-
-inline void QOpenGLFunctions_1_0::glTexCoord2fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord2fv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glTexCoord2f(GLfloat s, GLfloat t)
-{
-    d_1_0_Deprecated->f.TexCoord2f(s, t);
-}
-
-inline void QOpenGLFunctions_1_0::glTexCoord2dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord2dv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glTexCoord2d(GLdouble s, GLdouble t)
-{
-    d_1_0_Deprecated->f.TexCoord2d(s, t);
-}
-
-inline void QOpenGLFunctions_1_0::glTexCoord1sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord1sv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glTexCoord1s(GLshort s)
-{
-    d_1_0_Deprecated->f.TexCoord1s(s);
-}
-
-inline void QOpenGLFunctions_1_0::glTexCoord1iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord1iv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glTexCoord1i(GLint s)
-{
-    d_1_0_Deprecated->f.TexCoord1i(s);
-}
-
-inline void QOpenGLFunctions_1_0::glTexCoord1fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord1fv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glTexCoord1f(GLfloat s)
-{
-    d_1_0_Deprecated->f.TexCoord1f(s);
-}
-
-inline void QOpenGLFunctions_1_0::glTexCoord1dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord1dv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glTexCoord1d(GLdouble s)
-{
-    d_1_0_Deprecated->f.TexCoord1d(s);
-}
-
-inline void QOpenGLFunctions_1_0::glRectsv(const GLshort *v1, const GLshort *v2)
-{
-    d_1_0_Deprecated->f.Rectsv(v1, v2);
-}
-
-inline void QOpenGLFunctions_1_0::glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
-{
-    d_1_0_Deprecated->f.Rects(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_1_0::glRectiv(const GLint *v1, const GLint *v2)
-{
-    d_1_0_Deprecated->f.Rectiv(v1, v2);
-}
-
-inline void QOpenGLFunctions_1_0::glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
-{
-    d_1_0_Deprecated->f.Recti(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_1_0::glRectfv(const GLfloat *v1, const GLfloat *v2)
-{
-    d_1_0_Deprecated->f.Rectfv(v1, v2);
-}
-
-inline void QOpenGLFunctions_1_0::glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
-{
-    d_1_0_Deprecated->f.Rectf(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_1_0::glRectdv(const GLdouble *v1, const GLdouble *v2)
-{
-    d_1_0_Deprecated->f.Rectdv(v1, v2);
-}
-
-inline void QOpenGLFunctions_1_0::glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
-{
-    d_1_0_Deprecated->f.Rectd(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_1_0::glRasterPos4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.RasterPos4sv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
-{
-    d_1_0_Deprecated->f.RasterPos4s(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_1_0::glRasterPos4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.RasterPos4iv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
-{
-    d_1_0_Deprecated->f.RasterPos4i(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_1_0::glRasterPos4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.RasterPos4fv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    d_1_0_Deprecated->f.RasterPos4f(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_1_0::glRasterPos4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.RasterPos4dv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_1_0_Deprecated->f.RasterPos4d(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_1_0::glRasterPos3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.RasterPos3sv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glRasterPos3s(GLshort x, GLshort y, GLshort z)
-{
-    d_1_0_Deprecated->f.RasterPos3s(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_0::glRasterPos3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.RasterPos3iv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glRasterPos3i(GLint x, GLint y, GLint z)
-{
-    d_1_0_Deprecated->f.RasterPos3i(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_0::glRasterPos3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.RasterPos3fv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.RasterPos3f(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_0::glRasterPos3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.RasterPos3dv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.RasterPos3d(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_0::glRasterPos2sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.RasterPos2sv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glRasterPos2s(GLshort x, GLshort y)
-{
-    d_1_0_Deprecated->f.RasterPos2s(x, y);
-}
-
-inline void QOpenGLFunctions_1_0::glRasterPos2iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.RasterPos2iv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glRasterPos2i(GLint x, GLint y)
-{
-    d_1_0_Deprecated->f.RasterPos2i(x, y);
-}
-
-inline void QOpenGLFunctions_1_0::glRasterPos2fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.RasterPos2fv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glRasterPos2f(GLfloat x, GLfloat y)
-{
-    d_1_0_Deprecated->f.RasterPos2f(x, y);
-}
-
-inline void QOpenGLFunctions_1_0::glRasterPos2dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.RasterPos2dv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glRasterPos2d(GLdouble x, GLdouble y)
-{
-    d_1_0_Deprecated->f.RasterPos2d(x, y);
-}
-
-inline void QOpenGLFunctions_1_0::glNormal3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Normal3sv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glNormal3s(GLshort nx, GLshort ny, GLshort nz)
-{
-    d_1_0_Deprecated->f.Normal3s(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_1_0::glNormal3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Normal3iv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glNormal3i(GLint nx, GLint ny, GLint nz)
-{
-    d_1_0_Deprecated->f.Normal3i(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_1_0::glNormal3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Normal3fv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
-{
-    d_1_0_Deprecated->f.Normal3f(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_1_0::glNormal3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Normal3dv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
-{
-    d_1_0_Deprecated->f.Normal3d(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_1_0::glNormal3bv(const GLbyte *v)
-{
-    d_1_0_Deprecated->f.Normal3bv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
-{
-    d_1_0_Deprecated->f.Normal3b(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_1_0::glIndexsv(const GLshort *c)
-{
-    d_1_0_Deprecated->f.Indexsv(c);
-}
-
-inline void QOpenGLFunctions_1_0::glIndexs(GLshort c)
-{
-    d_1_0_Deprecated->f.Indexs(c);
-}
-
-inline void QOpenGLFunctions_1_0::glIndexiv(const GLint *c)
-{
-    d_1_0_Deprecated->f.Indexiv(c);
-}
-
-inline void QOpenGLFunctions_1_0::glIndexi(GLint c)
-{
-    d_1_0_Deprecated->f.Indexi(c);
-}
-
-inline void QOpenGLFunctions_1_0::glIndexfv(const GLfloat *c)
-{
-    d_1_0_Deprecated->f.Indexfv(c);
-}
-
-inline void QOpenGLFunctions_1_0::glIndexf(GLfloat c)
-{
-    d_1_0_Deprecated->f.Indexf(c);
-}
-
-inline void QOpenGLFunctions_1_0::glIndexdv(const GLdouble *c)
-{
-    d_1_0_Deprecated->f.Indexdv(c);
-}
-
-inline void QOpenGLFunctions_1_0::glIndexd(GLdouble c)
-{
-    d_1_0_Deprecated->f.Indexd(c);
-}
-
-inline void QOpenGLFunctions_1_0::glEnd()
-{
-    d_1_0_Deprecated->f.End();
-}
-
-inline void QOpenGLFunctions_1_0::glEdgeFlagv(const GLboolean *flag)
-{
-    d_1_0_Deprecated->f.EdgeFlagv(flag);
-}
-
-inline void QOpenGLFunctions_1_0::glEdgeFlag(GLboolean flag)
-{
-    d_1_0_Deprecated->f.EdgeFlag(flag);
-}
-
-inline void QOpenGLFunctions_1_0::glColor4usv(const GLushort *v)
-{
-    d_1_0_Deprecated->f.Color4usv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
-{
-    d_1_0_Deprecated->f.Color4us(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_0::glColor4uiv(const GLuint *v)
-{
-    d_1_0_Deprecated->f.Color4uiv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
-{
-    d_1_0_Deprecated->f.Color4ui(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_0::glColor4ubv(const GLubyte *v)
-{
-    d_1_0_Deprecated->f.Color4ubv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
-{
-    d_1_0_Deprecated->f.Color4ub(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_0::glColor4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Color4sv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
-{
-    d_1_0_Deprecated->f.Color4s(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_0::glColor4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Color4iv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
-{
-    d_1_0_Deprecated->f.Color4i(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_0::glColor4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Color4fv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Deprecated->f.Color4f(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_0::glColor4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Color4dv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
-{
-    d_1_0_Deprecated->f.Color4d(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_0::glColor4bv(const GLbyte *v)
-{
-    d_1_0_Deprecated->f.Color4bv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
-{
-    d_1_0_Deprecated->f.Color4b(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_0::glColor3usv(const GLushort *v)
-{
-    d_1_0_Deprecated->f.Color3usv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glColor3us(GLushort red, GLushort green, GLushort blue)
-{
-    d_1_0_Deprecated->f.Color3us(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_0::glColor3uiv(const GLuint *v)
-{
-    d_1_0_Deprecated->f.Color3uiv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glColor3ui(GLuint red, GLuint green, GLuint blue)
-{
-    d_1_0_Deprecated->f.Color3ui(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_0::glColor3ubv(const GLubyte *v)
-{
-    d_1_0_Deprecated->f.Color3ubv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
-{
-    d_1_0_Deprecated->f.Color3ub(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_0::glColor3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Color3sv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glColor3s(GLshort red, GLshort green, GLshort blue)
-{
-    d_1_0_Deprecated->f.Color3s(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_0::glColor3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Color3iv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glColor3i(GLint red, GLint green, GLint blue)
-{
-    d_1_0_Deprecated->f.Color3i(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_0::glColor3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Color3fv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glColor3f(GLfloat red, GLfloat green, GLfloat blue)
-{
-    d_1_0_Deprecated->f.Color3f(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_0::glColor3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Color3dv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glColor3d(GLdouble red, GLdouble green, GLdouble blue)
-{
-    d_1_0_Deprecated->f.Color3d(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_0::glColor3bv(const GLbyte *v)
-{
-    d_1_0_Deprecated->f.Color3bv(v);
-}
-
-inline void QOpenGLFunctions_1_0::glColor3b(GLbyte red, GLbyte green, GLbyte blue)
-{
-    d_1_0_Deprecated->f.Color3b(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_0::glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
-{
-    d_1_0_Deprecated->f.Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
-}
-
-inline void QOpenGLFunctions_1_0::glBegin(GLenum mode)
-{
-    d_1_0_Deprecated->f.Begin(mode);
-}
-
-inline void QOpenGLFunctions_1_0::glListBase(GLuint base)
-{
-    d_1_0_Deprecated->f.ListBase(base);
-}
-
-inline GLuint QOpenGLFunctions_1_0::glGenLists(GLsizei range)
-{
-    return d_1_0_Deprecated->f.GenLists(range);
-}
-
-inline void QOpenGLFunctions_1_0::glDeleteLists(GLuint list, GLsizei range)
-{
-    d_1_0_Deprecated->f.DeleteLists(list, range);
-}
-
-inline void QOpenGLFunctions_1_0::glCallLists(GLsizei n, GLenum type, const GLvoid *lists)
-{
-    d_1_0_Deprecated->f.CallLists(n, type, lists);
-}
-
-inline void QOpenGLFunctions_1_0::glCallList(GLuint list)
-{
-    d_1_0_Deprecated->f.CallList(list);
-}
-
-inline void QOpenGLFunctions_1_0::glEndList()
-{
-    d_1_0_Deprecated->f.EndList();
-}
-
-inline void QOpenGLFunctions_1_0::glNewList(GLuint list, GLenum mode)
-{
-    d_1_0_Deprecated->f.NewList(list, mode);
-}
-
-
-
-QT_END_NAMESPACE
-
-#endif // QT_NO_OPENGL && !QT_OPENGL_ES_2
-
-#endif
diff --git a/src/gui/opengl/qopenglfunctions_1_1.cpp b/src/gui/opengl/qopenglfunctions_1_1.cpp
deleted file mode 100644
index b0f7538d48..0000000000
--- a/src/gui/opengl/qopenglfunctions_1_1.cpp
+++ /dev/null
@@ -1,154 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#include "qopenglfunctions_1_1.h"
-#include "qopenglcontext.h"
-
-QT_BEGIN_NAMESPACE
-
-/*!
-    \class QOpenGLFunctions_1_1
-    \inmodule QtGui
-    \since 5.1
-    \wrapper
-    \brief The QOpenGLFunctions_1_1 class provides all functions for OpenGL 1.1 specification.
-
-    This class is a wrapper for functions from OpenGL 1.1 specification.
-    See reference pages on \l {http://www.opengl.org/sdk/docs/}{opengl.org}
-    for function documentation.
-
-    \sa QAbstractOpenGLFunctions
-*/
-
-QOpenGLFunctions_1_1::QOpenGLFunctions_1_1()
- : QAbstractOpenGLFunctions()
- , d_1_0_Core(nullptr)
- , d_1_1_Core(nullptr)
- , d_1_0_Deprecated(nullptr)
- , d_1_1_Deprecated(nullptr)
-{
-}
-
-QOpenGLFunctions_1_1::~QOpenGLFunctions_1_1()
-{
-    if (d_1_0_Core) {
-        d_1_0_Core->refs.deref();
-        Q_ASSERT(d_1_0_Core->refs.loadRelaxed());
-    }
-    if (d_1_1_Core) {
-        d_1_1_Core->refs.deref();
-        Q_ASSERT(d_1_1_Core->refs.loadRelaxed());
-    }
-    if (d_1_0_Deprecated) {
-        d_1_0_Deprecated->refs.deref();
-        Q_ASSERT(d_1_0_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_1_Deprecated) {
-        d_1_1_Deprecated->refs.deref();
-        Q_ASSERT(d_1_1_Deprecated->refs.loadRelaxed());
-    }
-}
-
-bool QOpenGLFunctions_1_1::initializeOpenGLFunctions()
-{
-    if ( isInitialized() )
-        return true;
-
-    QOpenGLContext* context = QOpenGLContext::currentContext();
-
-    // If owned by a context object make sure it is current.
-    // Also check that current context is capable of resolving all needed functions
-    if (((owningContext() && owningContext() == context) || !owningContext())
-        && QOpenGLFunctions_1_1::isContextCompatible(context))
-    {
-        // Associate with private implementation, creating if necessary
-        // Function pointers in the backends are resolved at creation time
-        QOpenGLVersionFunctionsBackend* d = nullptr;
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
-        d_1_0_Deprecated = static_cast<QOpenGLFunctions_1_0_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
-        d_1_1_Deprecated = static_cast<QOpenGLFunctions_1_1_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        QAbstractOpenGLFunctions::initializeOpenGLFunctions();
-    }
-    return isInitialized();
-}
-
-bool QOpenGLFunctions_1_1::isContextCompatible(QOpenGLContext *context)
-{
-    Q_ASSERT(context);
-    QSurfaceFormat f = context->format();
-    const QPair<int, int> v = qMakePair(f.majorVersion(), f.minorVersion());
-    if (v < qMakePair(1, 1))
-        return false;
-
-    if (f.profile() == QSurfaceFormat::CoreProfile)
-        return false;
-
-    return true;
-}
-
-QOpenGLVersionProfile QOpenGLFunctions_1_1::versionProfile()
-{
-    QOpenGLVersionProfile v;
-    v.setVersion(1, 1);
-    return v;
-}
-
-QT_END_NAMESPACE
diff --git a/src/gui/opengl/qopenglfunctions_1_1.h b/src/gui/opengl/qopenglfunctions_1_1.h
deleted file mode 100644
index 8a9f16ec4c..0000000000
--- a/src/gui/opengl/qopenglfunctions_1_1.h
+++ /dev/null
@@ -1,2119 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#ifndef QOPENGLVERSIONFUNCTIONS_1_1_H
-#define QOPENGLVERSIONFUNCTIONS_1_1_H
-
-#include <QtGui/qtguiglobal.h>
-
-#if !defined(QT_NO_OPENGL) && !defined(QT_OPENGL_ES_2)
-
-#include <QtGui/QOpenGLVersionFunctions>
-#include <QtGui/qopenglcontext.h>
-
-QT_BEGIN_NAMESPACE
-
-class Q_GUI_EXPORT QOpenGLFunctions_1_1 : public QAbstractOpenGLFunctions
-{
-public:
-    QOpenGLFunctions_1_1();
-    ~QOpenGLFunctions_1_1();
-
-    bool initializeOpenGLFunctions() override;
-
-    // OpenGL 1.0 core functions
-    void glViewport(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glDepthRange(GLdouble nearVal, GLdouble farVal);
-    GLboolean glIsEnabled(GLenum cap);
-    void glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params);
-    void glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params);
-    void glGetTexParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
-    const GLubyte * glGetString(GLenum name);
-    void glGetIntegerv(GLenum pname, GLint *params);
-    void glGetFloatv(GLenum pname, GLfloat *params);
-    GLenum glGetError();
-    void glGetDoublev(GLenum pname, GLdouble *params);
-    void glGetBooleanv(GLenum pname, GLboolean *params);
-    void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
-    void glReadBuffer(GLenum mode);
-    void glPixelStorei(GLenum pname, GLint param);
-    void glPixelStoref(GLenum pname, GLfloat param);
-    void glDepthFunc(GLenum func);
-    void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass);
-    void glStencilFunc(GLenum func, GLint ref, GLuint mask);
-    void glLogicOp(GLenum opcode);
-    void glBlendFunc(GLenum sfactor, GLenum dfactor);
-    void glFlush();
-    void glFinish();
-    void glEnable(GLenum cap);
-    void glDisable(GLenum cap);
-    void glDepthMask(GLboolean flag);
-    void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
-    void glStencilMask(GLuint mask);
-    void glClearDepth(GLdouble depth);
-    void glClearStencil(GLint s);
-    void glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glClear(GLbitfield mask);
-    void glDrawBuffer(GLenum mode);
-    void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glTexParameteri(GLenum target, GLenum pname, GLint param);
-    void glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glTexParameterf(GLenum target, GLenum pname, GLfloat param);
-    void glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glPolygonMode(GLenum face, GLenum mode);
-    void glPointSize(GLfloat size);
-    void glLineWidth(GLfloat width);
-    void glHint(GLenum target, GLenum mode);
-    void glFrontFace(GLenum mode);
-    void glCullFace(GLenum mode);
-
-    // OpenGL 1.1 core functions
-    void glIndexubv(const GLubyte *c);
-    void glIndexub(GLubyte c);
-    GLboolean glIsTexture(GLuint texture);
-    void glGenTextures(GLsizei n, GLuint *textures);
-    void glDeleteTextures(GLsizei n, const GLuint *textures);
-    void glBindTexture(GLenum target, GLuint texture);
-    void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
-    void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
-    void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
-    void glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
-    void glPolygonOffset(GLfloat factor, GLfloat units);
-    void glGetPointerv(GLenum pname, GLvoid* *params);
-    void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
-    void glDrawArrays(GLenum mode, GLint first, GLsizei count);
-
-    // OpenGL 1.0 deprecated functions
-    void glTranslatef(GLfloat x, GLfloat y, GLfloat z);
-    void glTranslated(GLdouble x, GLdouble y, GLdouble z);
-    void glScalef(GLfloat x, GLfloat y, GLfloat z);
-    void glScaled(GLdouble x, GLdouble y, GLdouble z);
-    void glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
-    void glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
-    void glPushMatrix();
-    void glPopMatrix();
-    void glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
-    void glMultMatrixd(const GLdouble *m);
-    void glMultMatrixf(const GLfloat *m);
-    void glMatrixMode(GLenum mode);
-    void glLoadMatrixd(const GLdouble *m);
-    void glLoadMatrixf(const GLfloat *m);
-    void glLoadIdentity();
-    void glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
-    GLboolean glIsList(GLuint list);
-    void glGetTexGeniv(GLenum coord, GLenum pname, GLint *params);
-    void glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params);
-    void glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params);
-    void glGetTexEnviv(GLenum target, GLenum pname, GLint *params);
-    void glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetPolygonStipple(GLubyte *mask);
-    void glGetPixelMapusv(GLenum map, GLushort *values);
-    void glGetPixelMapuiv(GLenum map, GLuint *values);
-    void glGetPixelMapfv(GLenum map, GLfloat *values);
-    void glGetMaterialiv(GLenum face, GLenum pname, GLint *params);
-    void glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params);
-    void glGetMapiv(GLenum target, GLenum query, GLint *v);
-    void glGetMapfv(GLenum target, GLenum query, GLfloat *v);
-    void glGetMapdv(GLenum target, GLenum query, GLdouble *v);
-    void glGetLightiv(GLenum light, GLenum pname, GLint *params);
-    void glGetLightfv(GLenum light, GLenum pname, GLfloat *params);
-    void glGetClipPlane(GLenum plane, GLdouble *equation);
-    void glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
-    void glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
-    void glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values);
-    void glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values);
-    void glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values);
-    void glPixelTransferi(GLenum pname, GLint param);
-    void glPixelTransferf(GLenum pname, GLfloat param);
-    void glPixelZoom(GLfloat xfactor, GLfloat yfactor);
-    void glAlphaFunc(GLenum func, GLfloat ref);
-    void glEvalPoint2(GLint i, GLint j);
-    void glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
-    void glEvalPoint1(GLint i);
-    void glEvalMesh1(GLenum mode, GLint i1, GLint i2);
-    void glEvalCoord2fv(const GLfloat *u);
-    void glEvalCoord2f(GLfloat u, GLfloat v);
-    void glEvalCoord2dv(const GLdouble *u);
-    void glEvalCoord2d(GLdouble u, GLdouble v);
-    void glEvalCoord1fv(const GLfloat *u);
-    void glEvalCoord1f(GLfloat u);
-    void glEvalCoord1dv(const GLdouble *u);
-    void glEvalCoord1d(GLdouble u);
-    void glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
-    void glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
-    void glMapGrid1f(GLint un, GLfloat u1, GLfloat u2);
-    void glMapGrid1d(GLint un, GLdouble u1, GLdouble u2);
-    void glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);
-    void glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);
-    void glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);
-    void glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);
-    void glPushAttrib(GLbitfield mask);
-    void glPopAttrib();
-    void glAccum(GLenum op, GLfloat value);
-    void glIndexMask(GLuint mask);
-    void glClearIndex(GLfloat c);
-    void glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glPushName(GLuint name);
-    void glPopName();
-    void glPassThrough(GLfloat token);
-    void glLoadName(GLuint name);
-    void glInitNames();
-    GLint glRenderMode(GLenum mode);
-    void glSelectBuffer(GLsizei size, GLuint *buffer);
-    void glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer);
-    void glTexGeniv(GLenum coord, GLenum pname, const GLint *params);
-    void glTexGeni(GLenum coord, GLenum pname, GLint param);
-    void glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params);
-    void glTexGenf(GLenum coord, GLenum pname, GLfloat param);
-    void glTexGendv(GLenum coord, GLenum pname, const GLdouble *params);
-    void glTexGend(GLenum coord, GLenum pname, GLdouble param);
-    void glTexEnviv(GLenum target, GLenum pname, const GLint *params);
-    void glTexEnvi(GLenum target, GLenum pname, GLint param);
-    void glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glTexEnvf(GLenum target, GLenum pname, GLfloat param);
-    void glShadeModel(GLenum mode);
-    void glPolygonStipple(const GLubyte *mask);
-    void glMaterialiv(GLenum face, GLenum pname, const GLint *params);
-    void glMateriali(GLenum face, GLenum pname, GLint param);
-    void glMaterialfv(GLenum face, GLenum pname, const GLfloat *params);
-    void glMaterialf(GLenum face, GLenum pname, GLfloat param);
-    void glLineStipple(GLint factor, GLushort pattern);
-    void glLightModeliv(GLenum pname, const GLint *params);
-    void glLightModeli(GLenum pname, GLint param);
-    void glLightModelfv(GLenum pname, const GLfloat *params);
-    void glLightModelf(GLenum pname, GLfloat param);
-    void glLightiv(GLenum light, GLenum pname, const GLint *params);
-    void glLighti(GLenum light, GLenum pname, GLint param);
-    void glLightfv(GLenum light, GLenum pname, const GLfloat *params);
-    void glLightf(GLenum light, GLenum pname, GLfloat param);
-    void glFogiv(GLenum pname, const GLint *params);
-    void glFogi(GLenum pname, GLint param);
-    void glFogfv(GLenum pname, const GLfloat *params);
-    void glFogf(GLenum pname, GLfloat param);
-    void glColorMaterial(GLenum face, GLenum mode);
-    void glClipPlane(GLenum plane, const GLdouble *equation);
-    void glVertex4sv(const GLshort *v);
-    void glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w);
-    void glVertex4iv(const GLint *v);
-    void glVertex4i(GLint x, GLint y, GLint z, GLint w);
-    void glVertex4fv(const GLfloat *v);
-    void glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void glVertex4dv(const GLdouble *v);
-    void glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glVertex3sv(const GLshort *v);
-    void glVertex3s(GLshort x, GLshort y, GLshort z);
-    void glVertex3iv(const GLint *v);
-    void glVertex3i(GLint x, GLint y, GLint z);
-    void glVertex3fv(const GLfloat *v);
-    void glVertex3f(GLfloat x, GLfloat y, GLfloat z);
-    void glVertex3dv(const GLdouble *v);
-    void glVertex3d(GLdouble x, GLdouble y, GLdouble z);
-    void glVertex2sv(const GLshort *v);
-    void glVertex2s(GLshort x, GLshort y);
-    void glVertex2iv(const GLint *v);
-    void glVertex2i(GLint x, GLint y);
-    void glVertex2fv(const GLfloat *v);
-    void glVertex2f(GLfloat x, GLfloat y);
-    void glVertex2dv(const GLdouble *v);
-    void glVertex2d(GLdouble x, GLdouble y);
-    void glTexCoord4sv(const GLshort *v);
-    void glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q);
-    void glTexCoord4iv(const GLint *v);
-    void glTexCoord4i(GLint s, GLint t, GLint r, GLint q);
-    void glTexCoord4fv(const GLfloat *v);
-    void glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
-    void glTexCoord4dv(const GLdouble *v);
-    void glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q);
-    void glTexCoord3sv(const GLshort *v);
-    void glTexCoord3s(GLshort s, GLshort t, GLshort r);
-    void glTexCoord3iv(const GLint *v);
-    void glTexCoord3i(GLint s, GLint t, GLint r);
-    void glTexCoord3fv(const GLfloat *v);
-    void glTexCoord3f(GLfloat s, GLfloat t, GLfloat r);
-    void glTexCoord3dv(const GLdouble *v);
-    void glTexCoord3d(GLdouble s, GLdouble t, GLdouble r);
-    void glTexCoord2sv(const GLshort *v);
-    void glTexCoord2s(GLshort s, GLshort t);
-    void glTexCoord2iv(const GLint *v);
-    void glTexCoord2i(GLint s, GLint t);
-    void glTexCoord2fv(const GLfloat *v);
-    void glTexCoord2f(GLfloat s, GLfloat t);
-    void glTexCoord2dv(const GLdouble *v);
-    void glTexCoord2d(GLdouble s, GLdouble t);
-    void glTexCoord1sv(const GLshort *v);
-    void glTexCoord1s(GLshort s);
-    void glTexCoord1iv(const GLint *v);
-    void glTexCoord1i(GLint s);
-    void glTexCoord1fv(const GLfloat *v);
-    void glTexCoord1f(GLfloat s);
-    void glTexCoord1dv(const GLdouble *v);
-    void glTexCoord1d(GLdouble s);
-    void glRectsv(const GLshort *v1, const GLshort *v2);
-    void glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
-    void glRectiv(const GLint *v1, const GLint *v2);
-    void glRecti(GLint x1, GLint y1, GLint x2, GLint y2);
-    void glRectfv(const GLfloat *v1, const GLfloat *v2);
-    void glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
-    void glRectdv(const GLdouble *v1, const GLdouble *v2);
-    void glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
-    void glRasterPos4sv(const GLshort *v);
-    void glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w);
-    void glRasterPos4iv(const GLint *v);
-    void glRasterPos4i(GLint x, GLint y, GLint z, GLint w);
-    void glRasterPos4fv(const GLfloat *v);
-    void glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void glRasterPos4dv(const GLdouble *v);
-    void glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glRasterPos3sv(const GLshort *v);
-    void glRasterPos3s(GLshort x, GLshort y, GLshort z);
-    void glRasterPos3iv(const GLint *v);
-    void glRasterPos3i(GLint x, GLint y, GLint z);
-    void glRasterPos3fv(const GLfloat *v);
-    void glRasterPos3f(GLfloat x, GLfloat y, GLfloat z);
-    void glRasterPos3dv(const GLdouble *v);
-    void glRasterPos3d(GLdouble x, GLdouble y, GLdouble z);
-    void glRasterPos2sv(const GLshort *v);
-    void glRasterPos2s(GLshort x, GLshort y);
-    void glRasterPos2iv(const GLint *v);
-    void glRasterPos2i(GLint x, GLint y);
-    void glRasterPos2fv(const GLfloat *v);
-    void glRasterPos2f(GLfloat x, GLfloat y);
-    void glRasterPos2dv(const GLdouble *v);
-    void glRasterPos2d(GLdouble x, GLdouble y);
-    void glNormal3sv(const GLshort *v);
-    void glNormal3s(GLshort nx, GLshort ny, GLshort nz);
-    void glNormal3iv(const GLint *v);
-    void glNormal3i(GLint nx, GLint ny, GLint nz);
-    void glNormal3fv(const GLfloat *v);
-    void glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz);
-    void glNormal3dv(const GLdouble *v);
-    void glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz);
-    void glNormal3bv(const GLbyte *v);
-    void glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz);
-    void glIndexsv(const GLshort *c);
-    void glIndexs(GLshort c);
-    void glIndexiv(const GLint *c);
-    void glIndexi(GLint c);
-    void glIndexfv(const GLfloat *c);
-    void glIndexf(GLfloat c);
-    void glIndexdv(const GLdouble *c);
-    void glIndexd(GLdouble c);
-    void glEnd();
-    void glEdgeFlagv(const GLboolean *flag);
-    void glEdgeFlag(GLboolean flag);
-    void glColor4usv(const GLushort *v);
-    void glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha);
-    void glColor4uiv(const GLuint *v);
-    void glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha);
-    void glColor4ubv(const GLubyte *v);
-    void glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
-    void glColor4sv(const GLshort *v);
-    void glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha);
-    void glColor4iv(const GLint *v);
-    void glColor4i(GLint red, GLint green, GLint blue, GLint alpha);
-    void glColor4fv(const GLfloat *v);
-    void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glColor4dv(const GLdouble *v);
-    void glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
-    void glColor4bv(const GLbyte *v);
-    void glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
-    void glColor3usv(const GLushort *v);
-    void glColor3us(GLushort red, GLushort green, GLushort blue);
-    void glColor3uiv(const GLuint *v);
-    void glColor3ui(GLuint red, GLuint green, GLuint blue);
-    void glColor3ubv(const GLubyte *v);
-    void glColor3ub(GLubyte red, GLubyte green, GLubyte blue);
-    void glColor3sv(const GLshort *v);
-    void glColor3s(GLshort red, GLshort green, GLshort blue);
-    void glColor3iv(const GLint *v);
-    void glColor3i(GLint red, GLint green, GLint blue);
-    void glColor3fv(const GLfloat *v);
-    void glColor3f(GLfloat red, GLfloat green, GLfloat blue);
-    void glColor3dv(const GLdouble *v);
-    void glColor3d(GLdouble red, GLdouble green, GLdouble blue);
-    void glColor3bv(const GLbyte *v);
-    void glColor3b(GLbyte red, GLbyte green, GLbyte blue);
-    void glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap);
-    void glBegin(GLenum mode);
-    void glListBase(GLuint base);
-    GLuint glGenLists(GLsizei range);
-    void glDeleteLists(GLuint list, GLsizei range);
-    void glCallLists(GLsizei n, GLenum type, const GLvoid *lists);
-    void glCallList(GLuint list);
-    void glEndList();
-    void glNewList(GLuint list, GLenum mode);
-
-    // OpenGL 1.1 deprecated functions
-    void glPushClientAttrib(GLbitfield mask);
-    void glPopClientAttrib();
-    void glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities);
-    GLboolean glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences);
-    void glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer);
-    void glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glEnableClientState(GLenum array);
-    void glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer);
-    void glDisableClientState(GLenum array);
-    void glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glArrayElement(GLint i);
-
-private:
-    friend class QOpenGLContext;
-
-    static bool isContextCompatible(QOpenGLContext *context);
-    static QOpenGLVersionProfile versionProfile();
-
-    QOpenGLFunctions_1_0_CoreBackend* d_1_0_Core;
-    QOpenGLFunctions_1_1_CoreBackend* d_1_1_Core;
-    QOpenGLFunctions_1_0_DeprecatedBackend* d_1_0_Deprecated;
-    QOpenGLFunctions_1_1_DeprecatedBackend* d_1_1_Deprecated;
-};
-
-// OpenGL 1.0 core functions
-inline void QOpenGLFunctions_1_1::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_0_Core->f.Viewport(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_1_1::glDepthRange(GLdouble nearVal, GLdouble farVal)
-{
-    d_1_0_Core->f.DepthRange(nearVal, farVal);
-}
-
-inline GLboolean QOpenGLFunctions_1_1::glIsEnabled(GLenum cap)
-{
-    return d_1_0_Core->f.IsEnabled(cap);
-}
-
-inline void QOpenGLFunctions_1_1::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
-}
-
-inline void QOpenGLFunctions_1_1::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
-}
-
-inline void QOpenGLFunctions_1_1::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetTexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_1::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetTexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_1::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
-{
-    d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
-}
-
-inline const GLubyte * QOpenGLFunctions_1_1::glGetString(GLenum name)
-{
-    return d_1_0_Core->f.GetString(name);
-}
-
-inline void QOpenGLFunctions_1_1::glGetIntegerv(GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetIntegerv(pname, params);
-}
-
-inline void QOpenGLFunctions_1_1::glGetFloatv(GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetFloatv(pname, params);
-}
-
-inline GLenum QOpenGLFunctions_1_1::glGetError()
-{
-    return d_1_0_Core->f.GetError();
-}
-
-inline void QOpenGLFunctions_1_1::glGetDoublev(GLenum pname, GLdouble *params)
-{
-    d_1_0_Core->f.GetDoublev(pname, params);
-}
-
-inline void QOpenGLFunctions_1_1::glGetBooleanv(GLenum pname, GLboolean *params)
-{
-    d_1_0_Core->f.GetBooleanv(pname, params);
-}
-
-inline void QOpenGLFunctions_1_1::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
-{
-    d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_1_1::glReadBuffer(GLenum mode)
-{
-    d_1_0_Core->f.ReadBuffer(mode);
-}
-
-inline void QOpenGLFunctions_1_1::glPixelStorei(GLenum pname, GLint param)
-{
-    d_1_0_Core->f.PixelStorei(pname, param);
-}
-
-inline void QOpenGLFunctions_1_1::glPixelStoref(GLenum pname, GLfloat param)
-{
-    d_1_0_Core->f.PixelStoref(pname, param);
-}
-
-inline void QOpenGLFunctions_1_1::glDepthFunc(GLenum func)
-{
-    d_1_0_Core->f.DepthFunc(func);
-}
-
-inline void QOpenGLFunctions_1_1::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
-{
-    d_1_0_Core->f.StencilOp(fail, zfail, zpass);
-}
-
-inline void QOpenGLFunctions_1_1::glStencilFunc(GLenum func, GLint ref, GLuint mask)
-{
-    d_1_0_Core->f.StencilFunc(func, ref, mask);
-}
-
-inline void QOpenGLFunctions_1_1::glLogicOp(GLenum opcode)
-{
-    d_1_0_Core->f.LogicOp(opcode);
-}
-
-inline void QOpenGLFunctions_1_1::glBlendFunc(GLenum sfactor, GLenum dfactor)
-{
-    d_1_0_Core->f.BlendFunc(sfactor, dfactor);
-}
-
-inline void QOpenGLFunctions_1_1::glFlush()
-{
-    d_1_0_Core->f.Flush();
-}
-
-inline void QOpenGLFunctions_1_1::glFinish()
-{
-    d_1_0_Core->f.Finish();
-}
-
-inline void QOpenGLFunctions_1_1::glEnable(GLenum cap)
-{
-    d_1_0_Core->f.Enable(cap);
-}
-
-inline void QOpenGLFunctions_1_1::glDisable(GLenum cap)
-{
-    d_1_0_Core->f.Disable(cap);
-}
-
-inline void QOpenGLFunctions_1_1::glDepthMask(GLboolean flag)
-{
-    d_1_0_Core->f.DepthMask(flag);
-}
-
-inline void QOpenGLFunctions_1_1::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
-{
-    d_1_0_Core->f.ColorMask(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_1::glStencilMask(GLuint mask)
-{
-    d_1_0_Core->f.StencilMask(mask);
-}
-
-inline void QOpenGLFunctions_1_1::glClearDepth(GLdouble depth)
-{
-    d_1_0_Core->f.ClearDepth(depth);
-}
-
-inline void QOpenGLFunctions_1_1::glClearStencil(GLint s)
-{
-    d_1_0_Core->f.ClearStencil(s);
-}
-
-inline void QOpenGLFunctions_1_1::glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Core->f.ClearColor(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_1::glClear(GLbitfield mask)
-{
-    d_1_0_Core->f.Clear(mask);
-}
-
-inline void QOpenGLFunctions_1_1::glDrawBuffer(GLenum mode)
-{
-    d_1_0_Core->f.DrawBuffer(mode);
-}
-
-inline void QOpenGLFunctions_1_1::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Core->f.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_1_1::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Core->f.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_1_1::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_0_Core->f.TexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_1::glTexParameteri(GLenum target, GLenum pname, GLint param)
-{
-    d_1_0_Core->f.TexParameteri(target, pname, param);
-}
-
-inline void QOpenGLFunctions_1_1::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Core->f.TexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_1::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
-{
-    d_1_0_Core->f.TexParameterf(target, pname, param);
-}
-
-inline void QOpenGLFunctions_1_1::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_0_Core->f.Scissor(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_1_1::glPolygonMode(GLenum face, GLenum mode)
-{
-    d_1_0_Core->f.PolygonMode(face, mode);
-}
-
-inline void QOpenGLFunctions_1_1::glPointSize(GLfloat size)
-{
-    d_1_0_Core->f.PointSize(size);
-}
-
-inline void QOpenGLFunctions_1_1::glLineWidth(GLfloat width)
-{
-    d_1_0_Core->f.LineWidth(width);
-}
-
-inline void QOpenGLFunctions_1_1::glHint(GLenum target, GLenum mode)
-{
-    d_1_0_Core->f.Hint(target, mode);
-}
-
-inline void QOpenGLFunctions_1_1::glFrontFace(GLenum mode)
-{
-    d_1_0_Core->f.FrontFace(mode);
-}
-
-inline void QOpenGLFunctions_1_1::glCullFace(GLenum mode)
-{
-    d_1_0_Core->f.CullFace(mode);
-}
-
-
-// OpenGL 1.1 core functions
-inline void QOpenGLFunctions_1_1::glIndexubv(const GLubyte *c)
-{
-    d_1_1_Deprecated->f.Indexubv(c);
-}
-
-inline void QOpenGLFunctions_1_1::glIndexub(GLubyte c)
-{
-    d_1_1_Deprecated->f.Indexub(c);
-}
-
-inline GLboolean QOpenGLFunctions_1_1::glIsTexture(GLuint texture)
-{
-    return d_1_1_Core->f.IsTexture(texture);
-}
-
-inline void QOpenGLFunctions_1_1::glGenTextures(GLsizei n, GLuint *textures)
-{
-    d_1_1_Core->f.GenTextures(n, textures);
-}
-
-inline void QOpenGLFunctions_1_1::glDeleteTextures(GLsizei n, const GLuint *textures)
-{
-    d_1_1_Core->f.DeleteTextures(n, textures);
-}
-
-inline void QOpenGLFunctions_1_1::glBindTexture(GLenum target, GLuint texture)
-{
-    d_1_1_Core->f.BindTexture(target, texture);
-}
-
-inline void QOpenGLFunctions_1_1::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_1_Core->f.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_1_1::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_1_Core->f.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_1_1::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_1_Core->f.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_1_1::glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
-{
-    d_1_1_Core->f.CopyTexSubImage1D(target, level, xoffset, x, y, width);
-}
-
-inline void QOpenGLFunctions_1_1::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
-{
-    d_1_1_Core->f.CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
-}
-
-inline void QOpenGLFunctions_1_1::glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
-{
-    d_1_1_Core->f.CopyTexImage1D(target, level, internalformat, x, y, width, border);
-}
-
-inline void QOpenGLFunctions_1_1::glPolygonOffset(GLfloat factor, GLfloat units)
-{
-    d_1_1_Core->f.PolygonOffset(factor, units);
-}
-
-inline void QOpenGLFunctions_1_1::glGetPointerv(GLenum pname, GLvoid* *params)
-{
-    d_1_1_Deprecated->f.GetPointerv(pname, params);
-}
-
-inline void QOpenGLFunctions_1_1::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
-{
-    d_1_1_Core->f.DrawElements(mode, count, type, indices);
-}
-
-inline void QOpenGLFunctions_1_1::glDrawArrays(GLenum mode, GLint first, GLsizei count)
-{
-    d_1_1_Core->f.DrawArrays(mode, first, count);
-}
-
-
-// OpenGL 1.0 deprecated functions
-inline void QOpenGLFunctions_1_1::glTranslatef(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Translatef(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_1::glTranslated(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Translated(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_1::glScalef(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Scalef(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_1::glScaled(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Scaled(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_1::glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Rotatef(angle, x, y, z);
-}
-
-inline void QOpenGLFunctions_1_1::glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Rotated(angle, x, y, z);
-}
-
-inline void QOpenGLFunctions_1_1::glPushMatrix()
-{
-    d_1_0_Deprecated->f.PushMatrix();
-}
-
-inline void QOpenGLFunctions_1_1::glPopMatrix()
-{
-    d_1_0_Deprecated->f.PopMatrix();
-}
-
-inline void QOpenGLFunctions_1_1::glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
-{
-    d_1_0_Deprecated->f.Ortho(left, right, bottom, top, zNear, zFar);
-}
-
-inline void QOpenGLFunctions_1_1::glMultMatrixd(const GLdouble *m)
-{
-    d_1_0_Deprecated->f.MultMatrixd(m);
-}
-
-inline void QOpenGLFunctions_1_1::glMultMatrixf(const GLfloat *m)
-{
-    d_1_0_Deprecated->f.MultMatrixf(m);
-}
-
-inline void QOpenGLFunctions_1_1::glMatrixMode(GLenum mode)
-{
-    d_1_0_Deprecated->f.MatrixMode(mode);
-}
-
-inline void QOpenGLFunctions_1_1::glLoadMatrixd(const GLdouble *m)
-{
-    d_1_0_Deprecated->f.LoadMatrixd(m);
-}
-
-inline void QOpenGLFunctions_1_1::glLoadMatrixf(const GLfloat *m)
-{
-    d_1_0_Deprecated->f.LoadMatrixf(m);
-}
-
-inline void QOpenGLFunctions_1_1::glLoadIdentity()
-{
-    d_1_0_Deprecated->f.LoadIdentity();
-}
-
-inline void QOpenGLFunctions_1_1::glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
-{
-    d_1_0_Deprecated->f.Frustum(left, right, bottom, top, zNear, zFar);
-}
-
-inline GLboolean QOpenGLFunctions_1_1::glIsList(GLuint list)
-{
-    return d_1_0_Deprecated->f.IsList(list);
-}
-
-inline void QOpenGLFunctions_1_1::glGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetTexGeniv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_1_1::glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetTexGenfv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_1_1::glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
-{
-    d_1_0_Deprecated->f.GetTexGendv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_1_1::glGetTexEnviv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetTexEnviv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_1::glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetTexEnvfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_1::glGetPolygonStipple(GLubyte *mask)
-{
-    d_1_0_Deprecated->f.GetPolygonStipple(mask);
-}
-
-inline void QOpenGLFunctions_1_1::glGetPixelMapusv(GLenum map, GLushort *values)
-{
-    d_1_0_Deprecated->f.GetPixelMapusv(map, values);
-}
-
-inline void QOpenGLFunctions_1_1::glGetPixelMapuiv(GLenum map, GLuint *values)
-{
-    d_1_0_Deprecated->f.GetPixelMapuiv(map, values);
-}
-
-inline void QOpenGLFunctions_1_1::glGetPixelMapfv(GLenum map, GLfloat *values)
-{
-    d_1_0_Deprecated->f.GetPixelMapfv(map, values);
-}
-
-inline void QOpenGLFunctions_1_1::glGetMaterialiv(GLenum face, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetMaterialiv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_1_1::glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetMaterialfv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_1_1::glGetMapiv(GLenum target, GLenum query, GLint *v)
-{
-    d_1_0_Deprecated->f.GetMapiv(target, query, v);
-}
-
-inline void QOpenGLFunctions_1_1::glGetMapfv(GLenum target, GLenum query, GLfloat *v)
-{
-    d_1_0_Deprecated->f.GetMapfv(target, query, v);
-}
-
-inline void QOpenGLFunctions_1_1::glGetMapdv(GLenum target, GLenum query, GLdouble *v)
-{
-    d_1_0_Deprecated->f.GetMapdv(target, query, v);
-}
-
-inline void QOpenGLFunctions_1_1::glGetLightiv(GLenum light, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetLightiv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_1_1::glGetLightfv(GLenum light, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetLightfv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_1_1::glGetClipPlane(GLenum plane, GLdouble *equation)
-{
-    d_1_0_Deprecated->f.GetClipPlane(plane, equation);
-}
-
-inline void QOpenGLFunctions_1_1::glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Deprecated->f.DrawPixels(width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_1_1::glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
-{
-    d_1_0_Deprecated->f.CopyPixels(x, y, width, height, type);
-}
-
-inline void QOpenGLFunctions_1_1::glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values)
-{
-    d_1_0_Deprecated->f.PixelMapusv(map, mapsize, values);
-}
-
-inline void QOpenGLFunctions_1_1::glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values)
-{
-    d_1_0_Deprecated->f.PixelMapuiv(map, mapsize, values);
-}
-
-inline void QOpenGLFunctions_1_1::glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values)
-{
-    d_1_0_Deprecated->f.PixelMapfv(map, mapsize, values);
-}
-
-inline void QOpenGLFunctions_1_1::glPixelTransferi(GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.PixelTransferi(pname, param);
-}
-
-inline void QOpenGLFunctions_1_1::glPixelTransferf(GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.PixelTransferf(pname, param);
-}
-
-inline void QOpenGLFunctions_1_1::glPixelZoom(GLfloat xfactor, GLfloat yfactor)
-{
-    d_1_0_Deprecated->f.PixelZoom(xfactor, yfactor);
-}
-
-inline void QOpenGLFunctions_1_1::glAlphaFunc(GLenum func, GLfloat ref)
-{
-    d_1_0_Deprecated->f.AlphaFunc(func, ref);
-}
-
-inline void QOpenGLFunctions_1_1::glEvalPoint2(GLint i, GLint j)
-{
-    d_1_0_Deprecated->f.EvalPoint2(i, j);
-}
-
-inline void QOpenGLFunctions_1_1::glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
-{
-    d_1_0_Deprecated->f.EvalMesh2(mode, i1, i2, j1, j2);
-}
-
-inline void QOpenGLFunctions_1_1::glEvalPoint1(GLint i)
-{
-    d_1_0_Deprecated->f.EvalPoint1(i);
-}
-
-inline void QOpenGLFunctions_1_1::glEvalMesh1(GLenum mode, GLint i1, GLint i2)
-{
-    d_1_0_Deprecated->f.EvalMesh1(mode, i1, i2);
-}
-
-inline void QOpenGLFunctions_1_1::glEvalCoord2fv(const GLfloat *u)
-{
-    d_1_0_Deprecated->f.EvalCoord2fv(u);
-}
-
-inline void QOpenGLFunctions_1_1::glEvalCoord2f(GLfloat u, GLfloat v)
-{
-    d_1_0_Deprecated->f.EvalCoord2f(u, v);
-}
-
-inline void QOpenGLFunctions_1_1::glEvalCoord2dv(const GLdouble *u)
-{
-    d_1_0_Deprecated->f.EvalCoord2dv(u);
-}
-
-inline void QOpenGLFunctions_1_1::glEvalCoord2d(GLdouble u, GLdouble v)
-{
-    d_1_0_Deprecated->f.EvalCoord2d(u, v);
-}
-
-inline void QOpenGLFunctions_1_1::glEvalCoord1fv(const GLfloat *u)
-{
-    d_1_0_Deprecated->f.EvalCoord1fv(u);
-}
-
-inline void QOpenGLFunctions_1_1::glEvalCoord1f(GLfloat u)
-{
-    d_1_0_Deprecated->f.EvalCoord1f(u);
-}
-
-inline void QOpenGLFunctions_1_1::glEvalCoord1dv(const GLdouble *u)
-{
-    d_1_0_Deprecated->f.EvalCoord1dv(u);
-}
-
-inline void QOpenGLFunctions_1_1::glEvalCoord1d(GLdouble u)
-{
-    d_1_0_Deprecated->f.EvalCoord1d(u);
-}
-
-inline void QOpenGLFunctions_1_1::glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
-{
-    d_1_0_Deprecated->f.MapGrid2f(un, u1, u2, vn, v1, v2);
-}
-
-inline void QOpenGLFunctions_1_1::glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
-{
-    d_1_0_Deprecated->f.MapGrid2d(un, u1, u2, vn, v1, v2);
-}
-
-inline void QOpenGLFunctions_1_1::glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
-{
-    d_1_0_Deprecated->f.MapGrid1f(un, u1, u2);
-}
-
-inline void QOpenGLFunctions_1_1::glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
-{
-    d_1_0_Deprecated->f.MapGrid1d(un, u1, u2);
-}
-
-inline void QOpenGLFunctions_1_1::glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
-{
-    d_1_0_Deprecated->f.Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
-}
-
-inline void QOpenGLFunctions_1_1::glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
-{
-    d_1_0_Deprecated->f.Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
-}
-
-inline void QOpenGLFunctions_1_1::glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
-{
-    d_1_0_Deprecated->f.Map1f(target, u1, u2, stride, order, points);
-}
-
-inline void QOpenGLFunctions_1_1::glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
-{
-    d_1_0_Deprecated->f.Map1d(target, u1, u2, stride, order, points);
-}
-
-inline void QOpenGLFunctions_1_1::glPushAttrib(GLbitfield mask)
-{
-    d_1_0_Deprecated->f.PushAttrib(mask);
-}
-
-inline void QOpenGLFunctions_1_1::glPopAttrib()
-{
-    d_1_0_Deprecated->f.PopAttrib();
-}
-
-inline void QOpenGLFunctions_1_1::glAccum(GLenum op, GLfloat value)
-{
-    d_1_0_Deprecated->f.Accum(op, value);
-}
-
-inline void QOpenGLFunctions_1_1::glIndexMask(GLuint mask)
-{
-    d_1_0_Deprecated->f.IndexMask(mask);
-}
-
-inline void QOpenGLFunctions_1_1::glClearIndex(GLfloat c)
-{
-    d_1_0_Deprecated->f.ClearIndex(c);
-}
-
-inline void QOpenGLFunctions_1_1::glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Deprecated->f.ClearAccum(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_1::glPushName(GLuint name)
-{
-    d_1_0_Deprecated->f.PushName(name);
-}
-
-inline void QOpenGLFunctions_1_1::glPopName()
-{
-    d_1_0_Deprecated->f.PopName();
-}
-
-inline void QOpenGLFunctions_1_1::glPassThrough(GLfloat token)
-{
-    d_1_0_Deprecated->f.PassThrough(token);
-}
-
-inline void QOpenGLFunctions_1_1::glLoadName(GLuint name)
-{
-    d_1_0_Deprecated->f.LoadName(name);
-}
-
-inline void QOpenGLFunctions_1_1::glInitNames()
-{
-    d_1_0_Deprecated->f.InitNames();
-}
-
-inline GLint QOpenGLFunctions_1_1::glRenderMode(GLenum mode)
-{
-    return d_1_0_Deprecated->f.RenderMode(mode);
-}
-
-inline void QOpenGLFunctions_1_1::glSelectBuffer(GLsizei size, GLuint *buffer)
-{
-    d_1_0_Deprecated->f.SelectBuffer(size, buffer);
-}
-
-inline void QOpenGLFunctions_1_1::glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
-{
-    d_1_0_Deprecated->f.FeedbackBuffer(size, type, buffer);
-}
-
-inline void QOpenGLFunctions_1_1::glTexGeniv(GLenum coord, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.TexGeniv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_1_1::glTexGeni(GLenum coord, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.TexGeni(coord, pname, param);
-}
-
-inline void QOpenGLFunctions_1_1::glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.TexGenfv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_1_1::glTexGenf(GLenum coord, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.TexGenf(coord, pname, param);
-}
-
-inline void QOpenGLFunctions_1_1::glTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
-{
-    d_1_0_Deprecated->f.TexGendv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_1_1::glTexGend(GLenum coord, GLenum pname, GLdouble param)
-{
-    d_1_0_Deprecated->f.TexGend(coord, pname, param);
-}
-
-inline void QOpenGLFunctions_1_1::glTexEnviv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.TexEnviv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_1::glTexEnvi(GLenum target, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.TexEnvi(target, pname, param);
-}
-
-inline void QOpenGLFunctions_1_1::glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.TexEnvfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_1::glTexEnvf(GLenum target, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.TexEnvf(target, pname, param);
-}
-
-inline void QOpenGLFunctions_1_1::glShadeModel(GLenum mode)
-{
-    d_1_0_Deprecated->f.ShadeModel(mode);
-}
-
-inline void QOpenGLFunctions_1_1::glPolygonStipple(const GLubyte *mask)
-{
-    d_1_0_Deprecated->f.PolygonStipple(mask);
-}
-
-inline void QOpenGLFunctions_1_1::glMaterialiv(GLenum face, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.Materialiv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_1_1::glMateriali(GLenum face, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.Materiali(face, pname, param);
-}
-
-inline void QOpenGLFunctions_1_1::glMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.Materialfv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_1_1::glMaterialf(GLenum face, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.Materialf(face, pname, param);
-}
-
-inline void QOpenGLFunctions_1_1::glLineStipple(GLint factor, GLushort pattern)
-{
-    d_1_0_Deprecated->f.LineStipple(factor, pattern);
-}
-
-inline void QOpenGLFunctions_1_1::glLightModeliv(GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.LightModeliv(pname, params);
-}
-
-inline void QOpenGLFunctions_1_1::glLightModeli(GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.LightModeli(pname, param);
-}
-
-inline void QOpenGLFunctions_1_1::glLightModelfv(GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.LightModelfv(pname, params);
-}
-
-inline void QOpenGLFunctions_1_1::glLightModelf(GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.LightModelf(pname, param);
-}
-
-inline void QOpenGLFunctions_1_1::glLightiv(GLenum light, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.Lightiv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_1_1::glLighti(GLenum light, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.Lighti(light, pname, param);
-}
-
-inline void QOpenGLFunctions_1_1::glLightfv(GLenum light, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.Lightfv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_1_1::glLightf(GLenum light, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.Lightf(light, pname, param);
-}
-
-inline void QOpenGLFunctions_1_1::glFogiv(GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.Fogiv(pname, params);
-}
-
-inline void QOpenGLFunctions_1_1::glFogi(GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.Fogi(pname, param);
-}
-
-inline void QOpenGLFunctions_1_1::glFogfv(GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.Fogfv(pname, params);
-}
-
-inline void QOpenGLFunctions_1_1::glFogf(GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.Fogf(pname, param);
-}
-
-inline void QOpenGLFunctions_1_1::glColorMaterial(GLenum face, GLenum mode)
-{
-    d_1_0_Deprecated->f.ColorMaterial(face, mode);
-}
-
-inline void QOpenGLFunctions_1_1::glClipPlane(GLenum plane, const GLdouble *equation)
-{
-    d_1_0_Deprecated->f.ClipPlane(plane, equation);
-}
-
-inline void QOpenGLFunctions_1_1::glVertex4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Vertex4sv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
-{
-    d_1_0_Deprecated->f.Vertex4s(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_1_1::glVertex4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Vertex4iv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glVertex4i(GLint x, GLint y, GLint z, GLint w)
-{
-    d_1_0_Deprecated->f.Vertex4i(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_1_1::glVertex4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Vertex4fv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    d_1_0_Deprecated->f.Vertex4f(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_1_1::glVertex4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Vertex4dv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_1_0_Deprecated->f.Vertex4d(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_1_1::glVertex3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Vertex3sv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glVertex3s(GLshort x, GLshort y, GLshort z)
-{
-    d_1_0_Deprecated->f.Vertex3s(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_1::glVertex3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Vertex3iv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glVertex3i(GLint x, GLint y, GLint z)
-{
-    d_1_0_Deprecated->f.Vertex3i(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_1::glVertex3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Vertex3fv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glVertex3f(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Vertex3f(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_1::glVertex3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Vertex3dv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glVertex3d(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Vertex3d(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_1::glVertex2sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Vertex2sv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glVertex2s(GLshort x, GLshort y)
-{
-    d_1_0_Deprecated->f.Vertex2s(x, y);
-}
-
-inline void QOpenGLFunctions_1_1::glVertex2iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Vertex2iv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glVertex2i(GLint x, GLint y)
-{
-    d_1_0_Deprecated->f.Vertex2i(x, y);
-}
-
-inline void QOpenGLFunctions_1_1::glVertex2fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Vertex2fv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glVertex2f(GLfloat x, GLfloat y)
-{
-    d_1_0_Deprecated->f.Vertex2f(x, y);
-}
-
-inline void QOpenGLFunctions_1_1::glVertex2dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Vertex2dv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glVertex2d(GLdouble x, GLdouble y)
-{
-    d_1_0_Deprecated->f.Vertex2d(x, y);
-}
-
-inline void QOpenGLFunctions_1_1::glTexCoord4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord4sv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
-{
-    d_1_0_Deprecated->f.TexCoord4s(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_1_1::glTexCoord4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord4iv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
-{
-    d_1_0_Deprecated->f.TexCoord4i(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_1_1::glTexCoord4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord4fv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
-{
-    d_1_0_Deprecated->f.TexCoord4f(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_1_1::glTexCoord4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord4dv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
-{
-    d_1_0_Deprecated->f.TexCoord4d(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_1_1::glTexCoord3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord3sv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glTexCoord3s(GLshort s, GLshort t, GLshort r)
-{
-    d_1_0_Deprecated->f.TexCoord3s(s, t, r);
-}
-
-inline void QOpenGLFunctions_1_1::glTexCoord3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord3iv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glTexCoord3i(GLint s, GLint t, GLint r)
-{
-    d_1_0_Deprecated->f.TexCoord3i(s, t, r);
-}
-
-inline void QOpenGLFunctions_1_1::glTexCoord3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord3fv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
-{
-    d_1_0_Deprecated->f.TexCoord3f(s, t, r);
-}
-
-inline void QOpenGLFunctions_1_1::glTexCoord3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord3dv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
-{
-    d_1_0_Deprecated->f.TexCoord3d(s, t, r);
-}
-
-inline void QOpenGLFunctions_1_1::glTexCoord2sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord2sv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glTexCoord2s(GLshort s, GLshort t)
-{
-    d_1_0_Deprecated->f.TexCoord2s(s, t);
-}
-
-inline void QOpenGLFunctions_1_1::glTexCoord2iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord2iv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glTexCoord2i(GLint s, GLint t)
-{
-    d_1_0_Deprecated->f.TexCoord2i(s, t);
-}
-
-inline void QOpenGLFunctions_1_1::glTexCoord2fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord2fv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glTexCoord2f(GLfloat s, GLfloat t)
-{
-    d_1_0_Deprecated->f.TexCoord2f(s, t);
-}
-
-inline void QOpenGLFunctions_1_1::glTexCoord2dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord2dv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glTexCoord2d(GLdouble s, GLdouble t)
-{
-    d_1_0_Deprecated->f.TexCoord2d(s, t);
-}
-
-inline void QOpenGLFunctions_1_1::glTexCoord1sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord1sv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glTexCoord1s(GLshort s)
-{
-    d_1_0_Deprecated->f.TexCoord1s(s);
-}
-
-inline void QOpenGLFunctions_1_1::glTexCoord1iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord1iv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glTexCoord1i(GLint s)
-{
-    d_1_0_Deprecated->f.TexCoord1i(s);
-}
-
-inline void QOpenGLFunctions_1_1::glTexCoord1fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord1fv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glTexCoord1f(GLfloat s)
-{
-    d_1_0_Deprecated->f.TexCoord1f(s);
-}
-
-inline void QOpenGLFunctions_1_1::glTexCoord1dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord1dv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glTexCoord1d(GLdouble s)
-{
-    d_1_0_Deprecated->f.TexCoord1d(s);
-}
-
-inline void QOpenGLFunctions_1_1::glRectsv(const GLshort *v1, const GLshort *v2)
-{
-    d_1_0_Deprecated->f.Rectsv(v1, v2);
-}
-
-inline void QOpenGLFunctions_1_1::glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
-{
-    d_1_0_Deprecated->f.Rects(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_1_1::glRectiv(const GLint *v1, const GLint *v2)
-{
-    d_1_0_Deprecated->f.Rectiv(v1, v2);
-}
-
-inline void QOpenGLFunctions_1_1::glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
-{
-    d_1_0_Deprecated->f.Recti(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_1_1::glRectfv(const GLfloat *v1, const GLfloat *v2)
-{
-    d_1_0_Deprecated->f.Rectfv(v1, v2);
-}
-
-inline void QOpenGLFunctions_1_1::glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
-{
-    d_1_0_Deprecated->f.Rectf(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_1_1::glRectdv(const GLdouble *v1, const GLdouble *v2)
-{
-    d_1_0_Deprecated->f.Rectdv(v1, v2);
-}
-
-inline void QOpenGLFunctions_1_1::glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
-{
-    d_1_0_Deprecated->f.Rectd(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_1_1::glRasterPos4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.RasterPos4sv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
-{
-    d_1_0_Deprecated->f.RasterPos4s(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_1_1::glRasterPos4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.RasterPos4iv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
-{
-    d_1_0_Deprecated->f.RasterPos4i(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_1_1::glRasterPos4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.RasterPos4fv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    d_1_0_Deprecated->f.RasterPos4f(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_1_1::glRasterPos4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.RasterPos4dv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_1_0_Deprecated->f.RasterPos4d(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_1_1::glRasterPos3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.RasterPos3sv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glRasterPos3s(GLshort x, GLshort y, GLshort z)
-{
-    d_1_0_Deprecated->f.RasterPos3s(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_1::glRasterPos3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.RasterPos3iv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glRasterPos3i(GLint x, GLint y, GLint z)
-{
-    d_1_0_Deprecated->f.RasterPos3i(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_1::glRasterPos3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.RasterPos3fv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.RasterPos3f(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_1::glRasterPos3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.RasterPos3dv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.RasterPos3d(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_1::glRasterPos2sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.RasterPos2sv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glRasterPos2s(GLshort x, GLshort y)
-{
-    d_1_0_Deprecated->f.RasterPos2s(x, y);
-}
-
-inline void QOpenGLFunctions_1_1::glRasterPos2iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.RasterPos2iv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glRasterPos2i(GLint x, GLint y)
-{
-    d_1_0_Deprecated->f.RasterPos2i(x, y);
-}
-
-inline void QOpenGLFunctions_1_1::glRasterPos2fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.RasterPos2fv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glRasterPos2f(GLfloat x, GLfloat y)
-{
-    d_1_0_Deprecated->f.RasterPos2f(x, y);
-}
-
-inline void QOpenGLFunctions_1_1::glRasterPos2dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.RasterPos2dv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glRasterPos2d(GLdouble x, GLdouble y)
-{
-    d_1_0_Deprecated->f.RasterPos2d(x, y);
-}
-
-inline void QOpenGLFunctions_1_1::glNormal3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Normal3sv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glNormal3s(GLshort nx, GLshort ny, GLshort nz)
-{
-    d_1_0_Deprecated->f.Normal3s(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_1_1::glNormal3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Normal3iv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glNormal3i(GLint nx, GLint ny, GLint nz)
-{
-    d_1_0_Deprecated->f.Normal3i(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_1_1::glNormal3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Normal3fv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
-{
-    d_1_0_Deprecated->f.Normal3f(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_1_1::glNormal3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Normal3dv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
-{
-    d_1_0_Deprecated->f.Normal3d(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_1_1::glNormal3bv(const GLbyte *v)
-{
-    d_1_0_Deprecated->f.Normal3bv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
-{
-    d_1_0_Deprecated->f.Normal3b(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_1_1::glIndexsv(const GLshort *c)
-{
-    d_1_0_Deprecated->f.Indexsv(c);
-}
-
-inline void QOpenGLFunctions_1_1::glIndexs(GLshort c)
-{
-    d_1_0_Deprecated->f.Indexs(c);
-}
-
-inline void QOpenGLFunctions_1_1::glIndexiv(const GLint *c)
-{
-    d_1_0_Deprecated->f.Indexiv(c);
-}
-
-inline void QOpenGLFunctions_1_1::glIndexi(GLint c)
-{
-    d_1_0_Deprecated->f.Indexi(c);
-}
-
-inline void QOpenGLFunctions_1_1::glIndexfv(const GLfloat *c)
-{
-    d_1_0_Deprecated->f.Indexfv(c);
-}
-
-inline void QOpenGLFunctions_1_1::glIndexf(GLfloat c)
-{
-    d_1_0_Deprecated->f.Indexf(c);
-}
-
-inline void QOpenGLFunctions_1_1::glIndexdv(const GLdouble *c)
-{
-    d_1_0_Deprecated->f.Indexdv(c);
-}
-
-inline void QOpenGLFunctions_1_1::glIndexd(GLdouble c)
-{
-    d_1_0_Deprecated->f.Indexd(c);
-}
-
-inline void QOpenGLFunctions_1_1::glEnd()
-{
-    d_1_0_Deprecated->f.End();
-}
-
-inline void QOpenGLFunctions_1_1::glEdgeFlagv(const GLboolean *flag)
-{
-    d_1_0_Deprecated->f.EdgeFlagv(flag);
-}
-
-inline void QOpenGLFunctions_1_1::glEdgeFlag(GLboolean flag)
-{
-    d_1_0_Deprecated->f.EdgeFlag(flag);
-}
-
-inline void QOpenGLFunctions_1_1::glColor4usv(const GLushort *v)
-{
-    d_1_0_Deprecated->f.Color4usv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
-{
-    d_1_0_Deprecated->f.Color4us(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_1::glColor4uiv(const GLuint *v)
-{
-    d_1_0_Deprecated->f.Color4uiv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
-{
-    d_1_0_Deprecated->f.Color4ui(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_1::glColor4ubv(const GLubyte *v)
-{
-    d_1_0_Deprecated->f.Color4ubv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
-{
-    d_1_0_Deprecated->f.Color4ub(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_1::glColor4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Color4sv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
-{
-    d_1_0_Deprecated->f.Color4s(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_1::glColor4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Color4iv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
-{
-    d_1_0_Deprecated->f.Color4i(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_1::glColor4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Color4fv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Deprecated->f.Color4f(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_1::glColor4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Color4dv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
-{
-    d_1_0_Deprecated->f.Color4d(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_1::glColor4bv(const GLbyte *v)
-{
-    d_1_0_Deprecated->f.Color4bv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
-{
-    d_1_0_Deprecated->f.Color4b(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_1::glColor3usv(const GLushort *v)
-{
-    d_1_0_Deprecated->f.Color3usv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glColor3us(GLushort red, GLushort green, GLushort blue)
-{
-    d_1_0_Deprecated->f.Color3us(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_1::glColor3uiv(const GLuint *v)
-{
-    d_1_0_Deprecated->f.Color3uiv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glColor3ui(GLuint red, GLuint green, GLuint blue)
-{
-    d_1_0_Deprecated->f.Color3ui(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_1::glColor3ubv(const GLubyte *v)
-{
-    d_1_0_Deprecated->f.Color3ubv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
-{
-    d_1_0_Deprecated->f.Color3ub(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_1::glColor3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Color3sv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glColor3s(GLshort red, GLshort green, GLshort blue)
-{
-    d_1_0_Deprecated->f.Color3s(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_1::glColor3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Color3iv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glColor3i(GLint red, GLint green, GLint blue)
-{
-    d_1_0_Deprecated->f.Color3i(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_1::glColor3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Color3fv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glColor3f(GLfloat red, GLfloat green, GLfloat blue)
-{
-    d_1_0_Deprecated->f.Color3f(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_1::glColor3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Color3dv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glColor3d(GLdouble red, GLdouble green, GLdouble blue)
-{
-    d_1_0_Deprecated->f.Color3d(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_1::glColor3bv(const GLbyte *v)
-{
-    d_1_0_Deprecated->f.Color3bv(v);
-}
-
-inline void QOpenGLFunctions_1_1::glColor3b(GLbyte red, GLbyte green, GLbyte blue)
-{
-    d_1_0_Deprecated->f.Color3b(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_1::glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
-{
-    d_1_0_Deprecated->f.Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
-}
-
-inline void QOpenGLFunctions_1_1::glBegin(GLenum mode)
-{
-    d_1_0_Deprecated->f.Begin(mode);
-}
-
-inline void QOpenGLFunctions_1_1::glListBase(GLuint base)
-{
-    d_1_0_Deprecated->f.ListBase(base);
-}
-
-inline GLuint QOpenGLFunctions_1_1::glGenLists(GLsizei range)
-{
-    return d_1_0_Deprecated->f.GenLists(range);
-}
-
-inline void QOpenGLFunctions_1_1::glDeleteLists(GLuint list, GLsizei range)
-{
-    d_1_0_Deprecated->f.DeleteLists(list, range);
-}
-
-inline void QOpenGLFunctions_1_1::glCallLists(GLsizei n, GLenum type, const GLvoid *lists)
-{
-    d_1_0_Deprecated->f.CallLists(n, type, lists);
-}
-
-inline void QOpenGLFunctions_1_1::glCallList(GLuint list)
-{
-    d_1_0_Deprecated->f.CallList(list);
-}
-
-inline void QOpenGLFunctions_1_1::glEndList()
-{
-    d_1_0_Deprecated->f.EndList();
-}
-
-inline void QOpenGLFunctions_1_1::glNewList(GLuint list, GLenum mode)
-{
-    d_1_0_Deprecated->f.NewList(list, mode);
-}
-
-
-// OpenGL 1.1 deprecated functions
-inline void QOpenGLFunctions_1_1::glPushClientAttrib(GLbitfield mask)
-{
-    d_1_1_Deprecated->f.PushClientAttrib(mask);
-}
-
-inline void QOpenGLFunctions_1_1::glPopClientAttrib()
-{
-    d_1_1_Deprecated->f.PopClientAttrib();
-}
-
-inline void QOpenGLFunctions_1_1::glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities)
-{
-    d_1_1_Deprecated->f.PrioritizeTextures(n, textures, priorities);
-}
-
-inline GLboolean QOpenGLFunctions_1_1::glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
-{
-    return d_1_1_Deprecated->f.AreTexturesResident(n, textures, residences);
-}
-
-inline void QOpenGLFunctions_1_1::glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.VertexPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_1_1::glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.TexCoordPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_1_1::glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.NormalPointer(type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_1_1::glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.InterleavedArrays(format, stride, pointer);
-}
-
-inline void QOpenGLFunctions_1_1::glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.IndexPointer(type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_1_1::glEnableClientState(GLenum array)
-{
-    d_1_1_Deprecated->f.EnableClientState(array);
-}
-
-inline void QOpenGLFunctions_1_1::glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.EdgeFlagPointer(stride, pointer);
-}
-
-inline void QOpenGLFunctions_1_1::glDisableClientState(GLenum array)
-{
-    d_1_1_Deprecated->f.DisableClientState(array);
-}
-
-inline void QOpenGLFunctions_1_1::glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.ColorPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_1_1::glArrayElement(GLint i)
-{
-    d_1_1_Deprecated->f.ArrayElement(i);
-}
-
-
-
-QT_END_NAMESPACE
-
-#endif // QT_NO_OPENGL && !QT_OPENGL_ES_2
-
-#endif
diff --git a/src/gui/opengl/qopenglfunctions_1_2.cpp b/src/gui/opengl/qopenglfunctions_1_2.cpp
deleted file mode 100644
index 5f137b0237..0000000000
--- a/src/gui/opengl/qopenglfunctions_1_2.cpp
+++ /dev/null
@@ -1,172 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#include "qopenglfunctions_1_2.h"
-#include "qopenglcontext.h"
-
-QT_BEGIN_NAMESPACE
-
-/*!
-    \class QOpenGLFunctions_1_2
-    \inmodule QtGui
-    \since 5.1
-    \wrapper
-    \brief The QOpenGLFunctions_1_2 class provides all functions for OpenGL 1.2 specification.
-
-    This class is a wrapper for functions from OpenGL 1.2 specification.
-    See reference pages on \l {http://www.opengl.org/sdk/docs/}{opengl.org}
-    for function documentation.
-
-    \sa QAbstractOpenGLFunctions
-*/
-
-QOpenGLFunctions_1_2::QOpenGLFunctions_1_2()
- : QAbstractOpenGLFunctions()
- , d_1_0_Core(nullptr)
- , d_1_1_Core(nullptr)
- , d_1_2_Core(nullptr)
- , d_1_0_Deprecated(nullptr)
- , d_1_1_Deprecated(nullptr)
- , d_1_2_Deprecated(nullptr)
-{
-}
-
-QOpenGLFunctions_1_2::~QOpenGLFunctions_1_2()
-{
-    if (d_1_0_Core) {
-        d_1_0_Core->refs.deref();
-        Q_ASSERT(d_1_0_Core->refs.loadRelaxed());
-    }
-    if (d_1_1_Core) {
-        d_1_1_Core->refs.deref();
-        Q_ASSERT(d_1_1_Core->refs.loadRelaxed());
-    }
-    if (d_1_2_Core) {
-        d_1_2_Core->refs.deref();
-        Q_ASSERT(d_1_2_Core->refs.loadRelaxed());
-    }
-    if (d_1_0_Deprecated) {
-        d_1_0_Deprecated->refs.deref();
-        Q_ASSERT(d_1_0_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_1_Deprecated) {
-        d_1_1_Deprecated->refs.deref();
-        Q_ASSERT(d_1_1_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_2_Deprecated) {
-        d_1_2_Deprecated->refs.deref();
-        Q_ASSERT(d_1_2_Deprecated->refs.loadRelaxed());
-    }
-}
-
-bool QOpenGLFunctions_1_2::initializeOpenGLFunctions()
-{
-    if ( isInitialized() )
-        return true;
-
-    QOpenGLContext* context = QOpenGLContext::currentContext();
-
-    // If owned by a context object make sure it is current.
-    // Also check that current context is capable of resolving all needed functions
-    if (((owningContext() && owningContext() == context) || !owningContext())
-        && QOpenGLFunctions_1_2::isContextCompatible(context))
-    {
-        // Associate with private implementation, creating if necessary
-        // Function pointers in the backends are resolved at creation time
-        QOpenGLVersionFunctionsBackend* d = nullptr;
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
-        d_1_0_Deprecated = static_cast<QOpenGLFunctions_1_0_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
-        d_1_1_Deprecated = static_cast<QOpenGLFunctions_1_1_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus());
-        d_1_2_Deprecated = static_cast<QOpenGLFunctions_1_2_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        QAbstractOpenGLFunctions::initializeOpenGLFunctions();
-    }
-    return isInitialized();
-}
-
-bool QOpenGLFunctions_1_2::isContextCompatible(QOpenGLContext *context)
-{
-    Q_ASSERT(context);
-    QSurfaceFormat f = context->format();
-    const QPair<int, int> v = qMakePair(f.majorVersion(), f.minorVersion());
-    if (v < qMakePair(1, 2))
-        return false;
-
-    if (f.profile() == QSurfaceFormat::CoreProfile)
-        return false;
-
-    return true;
-}
-
-QOpenGLVersionProfile QOpenGLFunctions_1_2::versionProfile()
-{
-    QOpenGLVersionProfile v;
-    v.setVersion(1, 2);
-    return v;
-}
-
-QT_END_NAMESPACE
diff --git a/src/gui/opengl/qopenglfunctions_1_2.h b/src/gui/opengl/qopenglfunctions_1_2.h
deleted file mode 100644
index 7daca0923d..0000000000
--- a/src/gui/opengl/qopenglfunctions_1_2.h
+++ /dev/null
@@ -1,2357 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#ifndef QOPENGLVERSIONFUNCTIONS_1_2_H
-#define QOPENGLVERSIONFUNCTIONS_1_2_H
-
-#include <QtGui/qtguiglobal.h>
-
-#if !defined(QT_NO_OPENGL) && !defined(QT_OPENGL_ES_2)
-
-#include <QtGui/QOpenGLVersionFunctions>
-#include <QtGui/qopenglcontext.h>
-
-QT_BEGIN_NAMESPACE
-
-class Q_GUI_EXPORT QOpenGLFunctions_1_2 : public QAbstractOpenGLFunctions
-{
-public:
-    QOpenGLFunctions_1_2();
-    ~QOpenGLFunctions_1_2();
-
-    bool initializeOpenGLFunctions() override;
-
-    // OpenGL 1.0 core functions
-    void glViewport(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glDepthRange(GLdouble nearVal, GLdouble farVal);
-    GLboolean glIsEnabled(GLenum cap);
-    void glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params);
-    void glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params);
-    void glGetTexParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
-    const GLubyte * glGetString(GLenum name);
-    void glGetIntegerv(GLenum pname, GLint *params);
-    void glGetFloatv(GLenum pname, GLfloat *params);
-    GLenum glGetError();
-    void glGetDoublev(GLenum pname, GLdouble *params);
-    void glGetBooleanv(GLenum pname, GLboolean *params);
-    void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
-    void glReadBuffer(GLenum mode);
-    void glPixelStorei(GLenum pname, GLint param);
-    void glPixelStoref(GLenum pname, GLfloat param);
-    void glDepthFunc(GLenum func);
-    void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass);
-    void glStencilFunc(GLenum func, GLint ref, GLuint mask);
-    void glLogicOp(GLenum opcode);
-    void glBlendFunc(GLenum sfactor, GLenum dfactor);
-    void glFlush();
-    void glFinish();
-    void glEnable(GLenum cap);
-    void glDisable(GLenum cap);
-    void glDepthMask(GLboolean flag);
-    void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
-    void glStencilMask(GLuint mask);
-    void glClearDepth(GLdouble depth);
-    void glClearStencil(GLint s);
-    void glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glClear(GLbitfield mask);
-    void glDrawBuffer(GLenum mode);
-    void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glTexParameteri(GLenum target, GLenum pname, GLint param);
-    void glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glTexParameterf(GLenum target, GLenum pname, GLfloat param);
-    void glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glPolygonMode(GLenum face, GLenum mode);
-    void glPointSize(GLfloat size);
-    void glLineWidth(GLfloat width);
-    void glHint(GLenum target, GLenum mode);
-    void glFrontFace(GLenum mode);
-    void glCullFace(GLenum mode);
-
-    // OpenGL 1.1 core functions
-    void glIndexubv(const GLubyte *c);
-    void glIndexub(GLubyte c);
-    GLboolean glIsTexture(GLuint texture);
-    void glGenTextures(GLsizei n, GLuint *textures);
-    void glDeleteTextures(GLsizei n, const GLuint *textures);
-    void glBindTexture(GLenum target, GLuint texture);
-    void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
-    void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
-    void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
-    void glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
-    void glPolygonOffset(GLfloat factor, GLfloat units);
-    void glGetPointerv(GLenum pname, GLvoid* *params);
-    void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
-    void glDrawArrays(GLenum mode, GLint first, GLsizei count);
-
-    // OpenGL 1.2 core functions
-    void glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices);
-    void glBlendEquation(GLenum mode);
-    void glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-
-    // OpenGL 1.0 deprecated functions
-    void glTranslatef(GLfloat x, GLfloat y, GLfloat z);
-    void glTranslated(GLdouble x, GLdouble y, GLdouble z);
-    void glScalef(GLfloat x, GLfloat y, GLfloat z);
-    void glScaled(GLdouble x, GLdouble y, GLdouble z);
-    void glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
-    void glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
-    void glPushMatrix();
-    void glPopMatrix();
-    void glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
-    void glMultMatrixd(const GLdouble *m);
-    void glMultMatrixf(const GLfloat *m);
-    void glMatrixMode(GLenum mode);
-    void glLoadMatrixd(const GLdouble *m);
-    void glLoadMatrixf(const GLfloat *m);
-    void glLoadIdentity();
-    void glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
-    GLboolean glIsList(GLuint list);
-    void glGetTexGeniv(GLenum coord, GLenum pname, GLint *params);
-    void glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params);
-    void glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params);
-    void glGetTexEnviv(GLenum target, GLenum pname, GLint *params);
-    void glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetPolygonStipple(GLubyte *mask);
-    void glGetPixelMapusv(GLenum map, GLushort *values);
-    void glGetPixelMapuiv(GLenum map, GLuint *values);
-    void glGetPixelMapfv(GLenum map, GLfloat *values);
-    void glGetMaterialiv(GLenum face, GLenum pname, GLint *params);
-    void glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params);
-    void glGetMapiv(GLenum target, GLenum query, GLint *v);
-    void glGetMapfv(GLenum target, GLenum query, GLfloat *v);
-    void glGetMapdv(GLenum target, GLenum query, GLdouble *v);
-    void glGetLightiv(GLenum light, GLenum pname, GLint *params);
-    void glGetLightfv(GLenum light, GLenum pname, GLfloat *params);
-    void glGetClipPlane(GLenum plane, GLdouble *equation);
-    void glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
-    void glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
-    void glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values);
-    void glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values);
-    void glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values);
-    void glPixelTransferi(GLenum pname, GLint param);
-    void glPixelTransferf(GLenum pname, GLfloat param);
-    void glPixelZoom(GLfloat xfactor, GLfloat yfactor);
-    void glAlphaFunc(GLenum func, GLfloat ref);
-    void glEvalPoint2(GLint i, GLint j);
-    void glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
-    void glEvalPoint1(GLint i);
-    void glEvalMesh1(GLenum mode, GLint i1, GLint i2);
-    void glEvalCoord2fv(const GLfloat *u);
-    void glEvalCoord2f(GLfloat u, GLfloat v);
-    void glEvalCoord2dv(const GLdouble *u);
-    void glEvalCoord2d(GLdouble u, GLdouble v);
-    void glEvalCoord1fv(const GLfloat *u);
-    void glEvalCoord1f(GLfloat u);
-    void glEvalCoord1dv(const GLdouble *u);
-    void glEvalCoord1d(GLdouble u);
-    void glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
-    void glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
-    void glMapGrid1f(GLint un, GLfloat u1, GLfloat u2);
-    void glMapGrid1d(GLint un, GLdouble u1, GLdouble u2);
-    void glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);
-    void glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);
-    void glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);
-    void glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);
-    void glPushAttrib(GLbitfield mask);
-    void glPopAttrib();
-    void glAccum(GLenum op, GLfloat value);
-    void glIndexMask(GLuint mask);
-    void glClearIndex(GLfloat c);
-    void glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glPushName(GLuint name);
-    void glPopName();
-    void glPassThrough(GLfloat token);
-    void glLoadName(GLuint name);
-    void glInitNames();
-    GLint glRenderMode(GLenum mode);
-    void glSelectBuffer(GLsizei size, GLuint *buffer);
-    void glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer);
-    void glTexGeniv(GLenum coord, GLenum pname, const GLint *params);
-    void glTexGeni(GLenum coord, GLenum pname, GLint param);
-    void glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params);
-    void glTexGenf(GLenum coord, GLenum pname, GLfloat param);
-    void glTexGendv(GLenum coord, GLenum pname, const GLdouble *params);
-    void glTexGend(GLenum coord, GLenum pname, GLdouble param);
-    void glTexEnviv(GLenum target, GLenum pname, const GLint *params);
-    void glTexEnvi(GLenum target, GLenum pname, GLint param);
-    void glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glTexEnvf(GLenum target, GLenum pname, GLfloat param);
-    void glShadeModel(GLenum mode);
-    void glPolygonStipple(const GLubyte *mask);
-    void glMaterialiv(GLenum face, GLenum pname, const GLint *params);
-    void glMateriali(GLenum face, GLenum pname, GLint param);
-    void glMaterialfv(GLenum face, GLenum pname, const GLfloat *params);
-    void glMaterialf(GLenum face, GLenum pname, GLfloat param);
-    void glLineStipple(GLint factor, GLushort pattern);
-    void glLightModeliv(GLenum pname, const GLint *params);
-    void glLightModeli(GLenum pname, GLint param);
-    void glLightModelfv(GLenum pname, const GLfloat *params);
-    void glLightModelf(GLenum pname, GLfloat param);
-    void glLightiv(GLenum light, GLenum pname, const GLint *params);
-    void glLighti(GLenum light, GLenum pname, GLint param);
-    void glLightfv(GLenum light, GLenum pname, const GLfloat *params);
-    void glLightf(GLenum light, GLenum pname, GLfloat param);
-    void glFogiv(GLenum pname, const GLint *params);
-    void glFogi(GLenum pname, GLint param);
-    void glFogfv(GLenum pname, const GLfloat *params);
-    void glFogf(GLenum pname, GLfloat param);
-    void glColorMaterial(GLenum face, GLenum mode);
-    void glClipPlane(GLenum plane, const GLdouble *equation);
-    void glVertex4sv(const GLshort *v);
-    void glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w);
-    void glVertex4iv(const GLint *v);
-    void glVertex4i(GLint x, GLint y, GLint z, GLint w);
-    void glVertex4fv(const GLfloat *v);
-    void glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void glVertex4dv(const GLdouble *v);
-    void glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glVertex3sv(const GLshort *v);
-    void glVertex3s(GLshort x, GLshort y, GLshort z);
-    void glVertex3iv(const GLint *v);
-    void glVertex3i(GLint x, GLint y, GLint z);
-    void glVertex3fv(const GLfloat *v);
-    void glVertex3f(GLfloat x, GLfloat y, GLfloat z);
-    void glVertex3dv(const GLdouble *v);
-    void glVertex3d(GLdouble x, GLdouble y, GLdouble z);
-    void glVertex2sv(const GLshort *v);
-    void glVertex2s(GLshort x, GLshort y);
-    void glVertex2iv(const GLint *v);
-    void glVertex2i(GLint x, GLint y);
-    void glVertex2fv(const GLfloat *v);
-    void glVertex2f(GLfloat x, GLfloat y);
-    void glVertex2dv(const GLdouble *v);
-    void glVertex2d(GLdouble x, GLdouble y);
-    void glTexCoord4sv(const GLshort *v);
-    void glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q);
-    void glTexCoord4iv(const GLint *v);
-    void glTexCoord4i(GLint s, GLint t, GLint r, GLint q);
-    void glTexCoord4fv(const GLfloat *v);
-    void glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
-    void glTexCoord4dv(const GLdouble *v);
-    void glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q);
-    void glTexCoord3sv(const GLshort *v);
-    void glTexCoord3s(GLshort s, GLshort t, GLshort r);
-    void glTexCoord3iv(const GLint *v);
-    void glTexCoord3i(GLint s, GLint t, GLint r);
-    void glTexCoord3fv(const GLfloat *v);
-    void glTexCoord3f(GLfloat s, GLfloat t, GLfloat r);
-    void glTexCoord3dv(const GLdouble *v);
-    void glTexCoord3d(GLdouble s, GLdouble t, GLdouble r);
-    void glTexCoord2sv(const GLshort *v);
-    void glTexCoord2s(GLshort s, GLshort t);
-    void glTexCoord2iv(const GLint *v);
-    void glTexCoord2i(GLint s, GLint t);
-    void glTexCoord2fv(const GLfloat *v);
-    void glTexCoord2f(GLfloat s, GLfloat t);
-    void glTexCoord2dv(const GLdouble *v);
-    void glTexCoord2d(GLdouble s, GLdouble t);
-    void glTexCoord1sv(const GLshort *v);
-    void glTexCoord1s(GLshort s);
-    void glTexCoord1iv(const GLint *v);
-    void glTexCoord1i(GLint s);
-    void glTexCoord1fv(const GLfloat *v);
-    void glTexCoord1f(GLfloat s);
-    void glTexCoord1dv(const GLdouble *v);
-    void glTexCoord1d(GLdouble s);
-    void glRectsv(const GLshort *v1, const GLshort *v2);
-    void glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
-    void glRectiv(const GLint *v1, const GLint *v2);
-    void glRecti(GLint x1, GLint y1, GLint x2, GLint y2);
-    void glRectfv(const GLfloat *v1, const GLfloat *v2);
-    void glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
-    void glRectdv(const GLdouble *v1, const GLdouble *v2);
-    void glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
-    void glRasterPos4sv(const GLshort *v);
-    void glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w);
-    void glRasterPos4iv(const GLint *v);
-    void glRasterPos4i(GLint x, GLint y, GLint z, GLint w);
-    void glRasterPos4fv(const GLfloat *v);
-    void glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void glRasterPos4dv(const GLdouble *v);
-    void glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glRasterPos3sv(const GLshort *v);
-    void glRasterPos3s(GLshort x, GLshort y, GLshort z);
-    void glRasterPos3iv(const GLint *v);
-    void glRasterPos3i(GLint x, GLint y, GLint z);
-    void glRasterPos3fv(const GLfloat *v);
-    void glRasterPos3f(GLfloat x, GLfloat y, GLfloat z);
-    void glRasterPos3dv(const GLdouble *v);
-    void glRasterPos3d(GLdouble x, GLdouble y, GLdouble z);
-    void glRasterPos2sv(const GLshort *v);
-    void glRasterPos2s(GLshort x, GLshort y);
-    void glRasterPos2iv(const GLint *v);
-    void glRasterPos2i(GLint x, GLint y);
-    void glRasterPos2fv(const GLfloat *v);
-    void glRasterPos2f(GLfloat x, GLfloat y);
-    void glRasterPos2dv(const GLdouble *v);
-    void glRasterPos2d(GLdouble x, GLdouble y);
-    void glNormal3sv(const GLshort *v);
-    void glNormal3s(GLshort nx, GLshort ny, GLshort nz);
-    void glNormal3iv(const GLint *v);
-    void glNormal3i(GLint nx, GLint ny, GLint nz);
-    void glNormal3fv(const GLfloat *v);
-    void glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz);
-    void glNormal3dv(const GLdouble *v);
-    void glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz);
-    void glNormal3bv(const GLbyte *v);
-    void glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz);
-    void glIndexsv(const GLshort *c);
-    void glIndexs(GLshort c);
-    void glIndexiv(const GLint *c);
-    void glIndexi(GLint c);
-    void glIndexfv(const GLfloat *c);
-    void glIndexf(GLfloat c);
-    void glIndexdv(const GLdouble *c);
-    void glIndexd(GLdouble c);
-    void glEnd();
-    void glEdgeFlagv(const GLboolean *flag);
-    void glEdgeFlag(GLboolean flag);
-    void glColor4usv(const GLushort *v);
-    void glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha);
-    void glColor4uiv(const GLuint *v);
-    void glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha);
-    void glColor4ubv(const GLubyte *v);
-    void glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
-    void glColor4sv(const GLshort *v);
-    void glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha);
-    void glColor4iv(const GLint *v);
-    void glColor4i(GLint red, GLint green, GLint blue, GLint alpha);
-    void glColor4fv(const GLfloat *v);
-    void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glColor4dv(const GLdouble *v);
-    void glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
-    void glColor4bv(const GLbyte *v);
-    void glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
-    void glColor3usv(const GLushort *v);
-    void glColor3us(GLushort red, GLushort green, GLushort blue);
-    void glColor3uiv(const GLuint *v);
-    void glColor3ui(GLuint red, GLuint green, GLuint blue);
-    void glColor3ubv(const GLubyte *v);
-    void glColor3ub(GLubyte red, GLubyte green, GLubyte blue);
-    void glColor3sv(const GLshort *v);
-    void glColor3s(GLshort red, GLshort green, GLshort blue);
-    void glColor3iv(const GLint *v);
-    void glColor3i(GLint red, GLint green, GLint blue);
-    void glColor3fv(const GLfloat *v);
-    void glColor3f(GLfloat red, GLfloat green, GLfloat blue);
-    void glColor3dv(const GLdouble *v);
-    void glColor3d(GLdouble red, GLdouble green, GLdouble blue);
-    void glColor3bv(const GLbyte *v);
-    void glColor3b(GLbyte red, GLbyte green, GLbyte blue);
-    void glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap);
-    void glBegin(GLenum mode);
-    void glListBase(GLuint base);
-    GLuint glGenLists(GLsizei range);
-    void glDeleteLists(GLuint list, GLsizei range);
-    void glCallLists(GLsizei n, GLenum type, const GLvoid *lists);
-    void glCallList(GLuint list);
-    void glEndList();
-    void glNewList(GLuint list, GLenum mode);
-
-    // OpenGL 1.1 deprecated functions
-    void glPushClientAttrib(GLbitfield mask);
-    void glPopClientAttrib();
-    void glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities);
-    GLboolean glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences);
-    void glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer);
-    void glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glEnableClientState(GLenum array);
-    void glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer);
-    void glDisableClientState(GLenum array);
-    void glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glArrayElement(GLint i);
-
-    // OpenGL 1.2 deprecated functions
-    void glResetMinmax(GLenum target);
-    void glResetHistogram(GLenum target);
-    void glMinmax(GLenum target, GLenum internalformat, GLboolean sink);
-    void glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink);
-    void glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
-    void glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
-    void glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column);
-    void glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span);
-    void glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image);
-    void glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
-    void glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glConvolutionParameteri(GLenum target, GLenum pname, GLint params);
-    void glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params);
-    void glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image);
-    void glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image);
-    void glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width);
-    void glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data);
-    void glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table);
-    void glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
-    void glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table);
-
-private:
-    friend class QOpenGLContext;
-
-    static bool isContextCompatible(QOpenGLContext *context);
-    static QOpenGLVersionProfile versionProfile();
-
-    QOpenGLFunctions_1_0_CoreBackend* d_1_0_Core;
-    QOpenGLFunctions_1_1_CoreBackend* d_1_1_Core;
-    QOpenGLFunctions_1_2_CoreBackend* d_1_2_Core;
-    QOpenGLFunctions_1_0_DeprecatedBackend* d_1_0_Deprecated;
-    QOpenGLFunctions_1_1_DeprecatedBackend* d_1_1_Deprecated;
-    QOpenGLFunctions_1_2_DeprecatedBackend* d_1_2_Deprecated;
-};
-
-// OpenGL 1.0 core functions
-inline void QOpenGLFunctions_1_2::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_0_Core->f.Viewport(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_1_2::glDepthRange(GLdouble nearVal, GLdouble farVal)
-{
-    d_1_0_Core->f.DepthRange(nearVal, farVal);
-}
-
-inline GLboolean QOpenGLFunctions_1_2::glIsEnabled(GLenum cap)
-{
-    return d_1_0_Core->f.IsEnabled(cap);
-}
-
-inline void QOpenGLFunctions_1_2::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
-}
-
-inline void QOpenGLFunctions_1_2::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
-}
-
-inline void QOpenGLFunctions_1_2::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetTexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_2::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetTexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_2::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
-{
-    d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
-}
-
-inline const GLubyte * QOpenGLFunctions_1_2::glGetString(GLenum name)
-{
-    return d_1_0_Core->f.GetString(name);
-}
-
-inline void QOpenGLFunctions_1_2::glGetIntegerv(GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetIntegerv(pname, params);
-}
-
-inline void QOpenGLFunctions_1_2::glGetFloatv(GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetFloatv(pname, params);
-}
-
-inline GLenum QOpenGLFunctions_1_2::glGetError()
-{
-    return d_1_0_Core->f.GetError();
-}
-
-inline void QOpenGLFunctions_1_2::glGetDoublev(GLenum pname, GLdouble *params)
-{
-    d_1_0_Core->f.GetDoublev(pname, params);
-}
-
-inline void QOpenGLFunctions_1_2::glGetBooleanv(GLenum pname, GLboolean *params)
-{
-    d_1_0_Core->f.GetBooleanv(pname, params);
-}
-
-inline void QOpenGLFunctions_1_2::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
-{
-    d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_1_2::glReadBuffer(GLenum mode)
-{
-    d_1_0_Core->f.ReadBuffer(mode);
-}
-
-inline void QOpenGLFunctions_1_2::glPixelStorei(GLenum pname, GLint param)
-{
-    d_1_0_Core->f.PixelStorei(pname, param);
-}
-
-inline void QOpenGLFunctions_1_2::glPixelStoref(GLenum pname, GLfloat param)
-{
-    d_1_0_Core->f.PixelStoref(pname, param);
-}
-
-inline void QOpenGLFunctions_1_2::glDepthFunc(GLenum func)
-{
-    d_1_0_Core->f.DepthFunc(func);
-}
-
-inline void QOpenGLFunctions_1_2::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
-{
-    d_1_0_Core->f.StencilOp(fail, zfail, zpass);
-}
-
-inline void QOpenGLFunctions_1_2::glStencilFunc(GLenum func, GLint ref, GLuint mask)
-{
-    d_1_0_Core->f.StencilFunc(func, ref, mask);
-}
-
-inline void QOpenGLFunctions_1_2::glLogicOp(GLenum opcode)
-{
-    d_1_0_Core->f.LogicOp(opcode);
-}
-
-inline void QOpenGLFunctions_1_2::glBlendFunc(GLenum sfactor, GLenum dfactor)
-{
-    d_1_0_Core->f.BlendFunc(sfactor, dfactor);
-}
-
-inline void QOpenGLFunctions_1_2::glFlush()
-{
-    d_1_0_Core->f.Flush();
-}
-
-inline void QOpenGLFunctions_1_2::glFinish()
-{
-    d_1_0_Core->f.Finish();
-}
-
-inline void QOpenGLFunctions_1_2::glEnable(GLenum cap)
-{
-    d_1_0_Core->f.Enable(cap);
-}
-
-inline void QOpenGLFunctions_1_2::glDisable(GLenum cap)
-{
-    d_1_0_Core->f.Disable(cap);
-}
-
-inline void QOpenGLFunctions_1_2::glDepthMask(GLboolean flag)
-{
-    d_1_0_Core->f.DepthMask(flag);
-}
-
-inline void QOpenGLFunctions_1_2::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
-{
-    d_1_0_Core->f.ColorMask(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_2::glStencilMask(GLuint mask)
-{
-    d_1_0_Core->f.StencilMask(mask);
-}
-
-inline void QOpenGLFunctions_1_2::glClearDepth(GLdouble depth)
-{
-    d_1_0_Core->f.ClearDepth(depth);
-}
-
-inline void QOpenGLFunctions_1_2::glClearStencil(GLint s)
-{
-    d_1_0_Core->f.ClearStencil(s);
-}
-
-inline void QOpenGLFunctions_1_2::glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Core->f.ClearColor(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_2::glClear(GLbitfield mask)
-{
-    d_1_0_Core->f.Clear(mask);
-}
-
-inline void QOpenGLFunctions_1_2::glDrawBuffer(GLenum mode)
-{
-    d_1_0_Core->f.DrawBuffer(mode);
-}
-
-inline void QOpenGLFunctions_1_2::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Core->f.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_1_2::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Core->f.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_1_2::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_0_Core->f.TexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_2::glTexParameteri(GLenum target, GLenum pname, GLint param)
-{
-    d_1_0_Core->f.TexParameteri(target, pname, param);
-}
-
-inline void QOpenGLFunctions_1_2::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Core->f.TexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_2::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
-{
-    d_1_0_Core->f.TexParameterf(target, pname, param);
-}
-
-inline void QOpenGLFunctions_1_2::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_0_Core->f.Scissor(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_1_2::glPolygonMode(GLenum face, GLenum mode)
-{
-    d_1_0_Core->f.PolygonMode(face, mode);
-}
-
-inline void QOpenGLFunctions_1_2::glPointSize(GLfloat size)
-{
-    d_1_0_Core->f.PointSize(size);
-}
-
-inline void QOpenGLFunctions_1_2::glLineWidth(GLfloat width)
-{
-    d_1_0_Core->f.LineWidth(width);
-}
-
-inline void QOpenGLFunctions_1_2::glHint(GLenum target, GLenum mode)
-{
-    d_1_0_Core->f.Hint(target, mode);
-}
-
-inline void QOpenGLFunctions_1_2::glFrontFace(GLenum mode)
-{
-    d_1_0_Core->f.FrontFace(mode);
-}
-
-inline void QOpenGLFunctions_1_2::glCullFace(GLenum mode)
-{
-    d_1_0_Core->f.CullFace(mode);
-}
-
-
-// OpenGL 1.1 core functions
-inline void QOpenGLFunctions_1_2::glIndexubv(const GLubyte *c)
-{
-    d_1_1_Deprecated->f.Indexubv(c);
-}
-
-inline void QOpenGLFunctions_1_2::glIndexub(GLubyte c)
-{
-    d_1_1_Deprecated->f.Indexub(c);
-}
-
-inline GLboolean QOpenGLFunctions_1_2::glIsTexture(GLuint texture)
-{
-    return d_1_1_Core->f.IsTexture(texture);
-}
-
-inline void QOpenGLFunctions_1_2::glGenTextures(GLsizei n, GLuint *textures)
-{
-    d_1_1_Core->f.GenTextures(n, textures);
-}
-
-inline void QOpenGLFunctions_1_2::glDeleteTextures(GLsizei n, const GLuint *textures)
-{
-    d_1_1_Core->f.DeleteTextures(n, textures);
-}
-
-inline void QOpenGLFunctions_1_2::glBindTexture(GLenum target, GLuint texture)
-{
-    d_1_1_Core->f.BindTexture(target, texture);
-}
-
-inline void QOpenGLFunctions_1_2::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_1_Core->f.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_1_2::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_1_Core->f.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_1_2::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_1_Core->f.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_1_2::glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
-{
-    d_1_1_Core->f.CopyTexSubImage1D(target, level, xoffset, x, y, width);
-}
-
-inline void QOpenGLFunctions_1_2::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
-{
-    d_1_1_Core->f.CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
-}
-
-inline void QOpenGLFunctions_1_2::glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
-{
-    d_1_1_Core->f.CopyTexImage1D(target, level, internalformat, x, y, width, border);
-}
-
-inline void QOpenGLFunctions_1_2::glPolygonOffset(GLfloat factor, GLfloat units)
-{
-    d_1_1_Core->f.PolygonOffset(factor, units);
-}
-
-inline void QOpenGLFunctions_1_2::glGetPointerv(GLenum pname, GLvoid* *params)
-{
-    d_1_1_Deprecated->f.GetPointerv(pname, params);
-}
-
-inline void QOpenGLFunctions_1_2::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
-{
-    d_1_1_Core->f.DrawElements(mode, count, type, indices);
-}
-
-inline void QOpenGLFunctions_1_2::glDrawArrays(GLenum mode, GLint first, GLsizei count)
-{
-    d_1_1_Core->f.DrawArrays(mode, first, count);
-}
-
-
-// OpenGL 1.2 core functions
-inline void QOpenGLFunctions_1_2::glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_2_Core->f.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_1_2::glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_2_Core->f.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_1_2::glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_2_Core->f.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_1_2::glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
-{
-    d_1_2_Core->f.DrawRangeElements(mode, start, end, count, type, indices);
-}
-
-inline void QOpenGLFunctions_1_2::glBlendEquation(GLenum mode)
-{
-    d_1_2_Core->f.BlendEquation(mode);
-}
-
-inline void QOpenGLFunctions_1_2::glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_2_Core->f.BlendColor(red, green, blue, alpha);
-}
-
-
-// OpenGL 1.0 deprecated functions
-inline void QOpenGLFunctions_1_2::glTranslatef(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Translatef(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_2::glTranslated(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Translated(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_2::glScalef(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Scalef(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_2::glScaled(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Scaled(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_2::glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Rotatef(angle, x, y, z);
-}
-
-inline void QOpenGLFunctions_1_2::glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Rotated(angle, x, y, z);
-}
-
-inline void QOpenGLFunctions_1_2::glPushMatrix()
-{
-    d_1_0_Deprecated->f.PushMatrix();
-}
-
-inline void QOpenGLFunctions_1_2::glPopMatrix()
-{
-    d_1_0_Deprecated->f.PopMatrix();
-}
-
-inline void QOpenGLFunctions_1_2::glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
-{
-    d_1_0_Deprecated->f.Ortho(left, right, bottom, top, zNear, zFar);
-}
-
-inline void QOpenGLFunctions_1_2::glMultMatrixd(const GLdouble *m)
-{
-    d_1_0_Deprecated->f.MultMatrixd(m);
-}
-
-inline void QOpenGLFunctions_1_2::glMultMatrixf(const GLfloat *m)
-{
-    d_1_0_Deprecated->f.MultMatrixf(m);
-}
-
-inline void QOpenGLFunctions_1_2::glMatrixMode(GLenum mode)
-{
-    d_1_0_Deprecated->f.MatrixMode(mode);
-}
-
-inline void QOpenGLFunctions_1_2::glLoadMatrixd(const GLdouble *m)
-{
-    d_1_0_Deprecated->f.LoadMatrixd(m);
-}
-
-inline void QOpenGLFunctions_1_2::glLoadMatrixf(const GLfloat *m)
-{
-    d_1_0_Deprecated->f.LoadMatrixf(m);
-}
-
-inline void QOpenGLFunctions_1_2::glLoadIdentity()
-{
-    d_1_0_Deprecated->f.LoadIdentity();
-}
-
-inline void QOpenGLFunctions_1_2::glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
-{
-    d_1_0_Deprecated->f.Frustum(left, right, bottom, top, zNear, zFar);
-}
-
-inline GLboolean QOpenGLFunctions_1_2::glIsList(GLuint list)
-{
-    return d_1_0_Deprecated->f.IsList(list);
-}
-
-inline void QOpenGLFunctions_1_2::glGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetTexGeniv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_1_2::glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetTexGenfv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_1_2::glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
-{
-    d_1_0_Deprecated->f.GetTexGendv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_1_2::glGetTexEnviv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetTexEnviv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_2::glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetTexEnvfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_2::glGetPolygonStipple(GLubyte *mask)
-{
-    d_1_0_Deprecated->f.GetPolygonStipple(mask);
-}
-
-inline void QOpenGLFunctions_1_2::glGetPixelMapusv(GLenum map, GLushort *values)
-{
-    d_1_0_Deprecated->f.GetPixelMapusv(map, values);
-}
-
-inline void QOpenGLFunctions_1_2::glGetPixelMapuiv(GLenum map, GLuint *values)
-{
-    d_1_0_Deprecated->f.GetPixelMapuiv(map, values);
-}
-
-inline void QOpenGLFunctions_1_2::glGetPixelMapfv(GLenum map, GLfloat *values)
-{
-    d_1_0_Deprecated->f.GetPixelMapfv(map, values);
-}
-
-inline void QOpenGLFunctions_1_2::glGetMaterialiv(GLenum face, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetMaterialiv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_1_2::glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetMaterialfv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_1_2::glGetMapiv(GLenum target, GLenum query, GLint *v)
-{
-    d_1_0_Deprecated->f.GetMapiv(target, query, v);
-}
-
-inline void QOpenGLFunctions_1_2::glGetMapfv(GLenum target, GLenum query, GLfloat *v)
-{
-    d_1_0_Deprecated->f.GetMapfv(target, query, v);
-}
-
-inline void QOpenGLFunctions_1_2::glGetMapdv(GLenum target, GLenum query, GLdouble *v)
-{
-    d_1_0_Deprecated->f.GetMapdv(target, query, v);
-}
-
-inline void QOpenGLFunctions_1_2::glGetLightiv(GLenum light, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetLightiv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_1_2::glGetLightfv(GLenum light, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetLightfv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_1_2::glGetClipPlane(GLenum plane, GLdouble *equation)
-{
-    d_1_0_Deprecated->f.GetClipPlane(plane, equation);
-}
-
-inline void QOpenGLFunctions_1_2::glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Deprecated->f.DrawPixels(width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_1_2::glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
-{
-    d_1_0_Deprecated->f.CopyPixels(x, y, width, height, type);
-}
-
-inline void QOpenGLFunctions_1_2::glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values)
-{
-    d_1_0_Deprecated->f.PixelMapusv(map, mapsize, values);
-}
-
-inline void QOpenGLFunctions_1_2::glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values)
-{
-    d_1_0_Deprecated->f.PixelMapuiv(map, mapsize, values);
-}
-
-inline void QOpenGLFunctions_1_2::glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values)
-{
-    d_1_0_Deprecated->f.PixelMapfv(map, mapsize, values);
-}
-
-inline void QOpenGLFunctions_1_2::glPixelTransferi(GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.PixelTransferi(pname, param);
-}
-
-inline void QOpenGLFunctions_1_2::glPixelTransferf(GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.PixelTransferf(pname, param);
-}
-
-inline void QOpenGLFunctions_1_2::glPixelZoom(GLfloat xfactor, GLfloat yfactor)
-{
-    d_1_0_Deprecated->f.PixelZoom(xfactor, yfactor);
-}
-
-inline void QOpenGLFunctions_1_2::glAlphaFunc(GLenum func, GLfloat ref)
-{
-    d_1_0_Deprecated->f.AlphaFunc(func, ref);
-}
-
-inline void QOpenGLFunctions_1_2::glEvalPoint2(GLint i, GLint j)
-{
-    d_1_0_Deprecated->f.EvalPoint2(i, j);
-}
-
-inline void QOpenGLFunctions_1_2::glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
-{
-    d_1_0_Deprecated->f.EvalMesh2(mode, i1, i2, j1, j2);
-}
-
-inline void QOpenGLFunctions_1_2::glEvalPoint1(GLint i)
-{
-    d_1_0_Deprecated->f.EvalPoint1(i);
-}
-
-inline void QOpenGLFunctions_1_2::glEvalMesh1(GLenum mode, GLint i1, GLint i2)
-{
-    d_1_0_Deprecated->f.EvalMesh1(mode, i1, i2);
-}
-
-inline void QOpenGLFunctions_1_2::glEvalCoord2fv(const GLfloat *u)
-{
-    d_1_0_Deprecated->f.EvalCoord2fv(u);
-}
-
-inline void QOpenGLFunctions_1_2::glEvalCoord2f(GLfloat u, GLfloat v)
-{
-    d_1_0_Deprecated->f.EvalCoord2f(u, v);
-}
-
-inline void QOpenGLFunctions_1_2::glEvalCoord2dv(const GLdouble *u)
-{
-    d_1_0_Deprecated->f.EvalCoord2dv(u);
-}
-
-inline void QOpenGLFunctions_1_2::glEvalCoord2d(GLdouble u, GLdouble v)
-{
-    d_1_0_Deprecated->f.EvalCoord2d(u, v);
-}
-
-inline void QOpenGLFunctions_1_2::glEvalCoord1fv(const GLfloat *u)
-{
-    d_1_0_Deprecated->f.EvalCoord1fv(u);
-}
-
-inline void QOpenGLFunctions_1_2::glEvalCoord1f(GLfloat u)
-{
-    d_1_0_Deprecated->f.EvalCoord1f(u);
-}
-
-inline void QOpenGLFunctions_1_2::glEvalCoord1dv(const GLdouble *u)
-{
-    d_1_0_Deprecated->f.EvalCoord1dv(u);
-}
-
-inline void QOpenGLFunctions_1_2::glEvalCoord1d(GLdouble u)
-{
-    d_1_0_Deprecated->f.EvalCoord1d(u);
-}
-
-inline void QOpenGLFunctions_1_2::glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
-{
-    d_1_0_Deprecated->f.MapGrid2f(un, u1, u2, vn, v1, v2);
-}
-
-inline void QOpenGLFunctions_1_2::glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
-{
-    d_1_0_Deprecated->f.MapGrid2d(un, u1, u2, vn, v1, v2);
-}
-
-inline void QOpenGLFunctions_1_2::glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
-{
-    d_1_0_Deprecated->f.MapGrid1f(un, u1, u2);
-}
-
-inline void QOpenGLFunctions_1_2::glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
-{
-    d_1_0_Deprecated->f.MapGrid1d(un, u1, u2);
-}
-
-inline void QOpenGLFunctions_1_2::glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
-{
-    d_1_0_Deprecated->f.Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
-}
-
-inline void QOpenGLFunctions_1_2::glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
-{
-    d_1_0_Deprecated->f.Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
-}
-
-inline void QOpenGLFunctions_1_2::glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
-{
-    d_1_0_Deprecated->f.Map1f(target, u1, u2, stride, order, points);
-}
-
-inline void QOpenGLFunctions_1_2::glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
-{
-    d_1_0_Deprecated->f.Map1d(target, u1, u2, stride, order, points);
-}
-
-inline void QOpenGLFunctions_1_2::glPushAttrib(GLbitfield mask)
-{
-    d_1_0_Deprecated->f.PushAttrib(mask);
-}
-
-inline void QOpenGLFunctions_1_2::glPopAttrib()
-{
-    d_1_0_Deprecated->f.PopAttrib();
-}
-
-inline void QOpenGLFunctions_1_2::glAccum(GLenum op, GLfloat value)
-{
-    d_1_0_Deprecated->f.Accum(op, value);
-}
-
-inline void QOpenGLFunctions_1_2::glIndexMask(GLuint mask)
-{
-    d_1_0_Deprecated->f.IndexMask(mask);
-}
-
-inline void QOpenGLFunctions_1_2::glClearIndex(GLfloat c)
-{
-    d_1_0_Deprecated->f.ClearIndex(c);
-}
-
-inline void QOpenGLFunctions_1_2::glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Deprecated->f.ClearAccum(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_2::glPushName(GLuint name)
-{
-    d_1_0_Deprecated->f.PushName(name);
-}
-
-inline void QOpenGLFunctions_1_2::glPopName()
-{
-    d_1_0_Deprecated->f.PopName();
-}
-
-inline void QOpenGLFunctions_1_2::glPassThrough(GLfloat token)
-{
-    d_1_0_Deprecated->f.PassThrough(token);
-}
-
-inline void QOpenGLFunctions_1_2::glLoadName(GLuint name)
-{
-    d_1_0_Deprecated->f.LoadName(name);
-}
-
-inline void QOpenGLFunctions_1_2::glInitNames()
-{
-    d_1_0_Deprecated->f.InitNames();
-}
-
-inline GLint QOpenGLFunctions_1_2::glRenderMode(GLenum mode)
-{
-    return d_1_0_Deprecated->f.RenderMode(mode);
-}
-
-inline void QOpenGLFunctions_1_2::glSelectBuffer(GLsizei size, GLuint *buffer)
-{
-    d_1_0_Deprecated->f.SelectBuffer(size, buffer);
-}
-
-inline void QOpenGLFunctions_1_2::glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
-{
-    d_1_0_Deprecated->f.FeedbackBuffer(size, type, buffer);
-}
-
-inline void QOpenGLFunctions_1_2::glTexGeniv(GLenum coord, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.TexGeniv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_1_2::glTexGeni(GLenum coord, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.TexGeni(coord, pname, param);
-}
-
-inline void QOpenGLFunctions_1_2::glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.TexGenfv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_1_2::glTexGenf(GLenum coord, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.TexGenf(coord, pname, param);
-}
-
-inline void QOpenGLFunctions_1_2::glTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
-{
-    d_1_0_Deprecated->f.TexGendv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_1_2::glTexGend(GLenum coord, GLenum pname, GLdouble param)
-{
-    d_1_0_Deprecated->f.TexGend(coord, pname, param);
-}
-
-inline void QOpenGLFunctions_1_2::glTexEnviv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.TexEnviv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_2::glTexEnvi(GLenum target, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.TexEnvi(target, pname, param);
-}
-
-inline void QOpenGLFunctions_1_2::glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.TexEnvfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_2::glTexEnvf(GLenum target, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.TexEnvf(target, pname, param);
-}
-
-inline void QOpenGLFunctions_1_2::glShadeModel(GLenum mode)
-{
-    d_1_0_Deprecated->f.ShadeModel(mode);
-}
-
-inline void QOpenGLFunctions_1_2::glPolygonStipple(const GLubyte *mask)
-{
-    d_1_0_Deprecated->f.PolygonStipple(mask);
-}
-
-inline void QOpenGLFunctions_1_2::glMaterialiv(GLenum face, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.Materialiv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_1_2::glMateriali(GLenum face, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.Materiali(face, pname, param);
-}
-
-inline void QOpenGLFunctions_1_2::glMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.Materialfv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_1_2::glMaterialf(GLenum face, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.Materialf(face, pname, param);
-}
-
-inline void QOpenGLFunctions_1_2::glLineStipple(GLint factor, GLushort pattern)
-{
-    d_1_0_Deprecated->f.LineStipple(factor, pattern);
-}
-
-inline void QOpenGLFunctions_1_2::glLightModeliv(GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.LightModeliv(pname, params);
-}
-
-inline void QOpenGLFunctions_1_2::glLightModeli(GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.LightModeli(pname, param);
-}
-
-inline void QOpenGLFunctions_1_2::glLightModelfv(GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.LightModelfv(pname, params);
-}
-
-inline void QOpenGLFunctions_1_2::glLightModelf(GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.LightModelf(pname, param);
-}
-
-inline void QOpenGLFunctions_1_2::glLightiv(GLenum light, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.Lightiv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_1_2::glLighti(GLenum light, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.Lighti(light, pname, param);
-}
-
-inline void QOpenGLFunctions_1_2::glLightfv(GLenum light, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.Lightfv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_1_2::glLightf(GLenum light, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.Lightf(light, pname, param);
-}
-
-inline void QOpenGLFunctions_1_2::glFogiv(GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.Fogiv(pname, params);
-}
-
-inline void QOpenGLFunctions_1_2::glFogi(GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.Fogi(pname, param);
-}
-
-inline void QOpenGLFunctions_1_2::glFogfv(GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.Fogfv(pname, params);
-}
-
-inline void QOpenGLFunctions_1_2::glFogf(GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.Fogf(pname, param);
-}
-
-inline void QOpenGLFunctions_1_2::glColorMaterial(GLenum face, GLenum mode)
-{
-    d_1_0_Deprecated->f.ColorMaterial(face, mode);
-}
-
-inline void QOpenGLFunctions_1_2::glClipPlane(GLenum plane, const GLdouble *equation)
-{
-    d_1_0_Deprecated->f.ClipPlane(plane, equation);
-}
-
-inline void QOpenGLFunctions_1_2::glVertex4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Vertex4sv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
-{
-    d_1_0_Deprecated->f.Vertex4s(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_1_2::glVertex4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Vertex4iv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glVertex4i(GLint x, GLint y, GLint z, GLint w)
-{
-    d_1_0_Deprecated->f.Vertex4i(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_1_2::glVertex4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Vertex4fv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    d_1_0_Deprecated->f.Vertex4f(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_1_2::glVertex4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Vertex4dv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_1_0_Deprecated->f.Vertex4d(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_1_2::glVertex3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Vertex3sv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glVertex3s(GLshort x, GLshort y, GLshort z)
-{
-    d_1_0_Deprecated->f.Vertex3s(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_2::glVertex3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Vertex3iv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glVertex3i(GLint x, GLint y, GLint z)
-{
-    d_1_0_Deprecated->f.Vertex3i(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_2::glVertex3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Vertex3fv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glVertex3f(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Vertex3f(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_2::glVertex3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Vertex3dv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glVertex3d(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Vertex3d(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_2::glVertex2sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Vertex2sv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glVertex2s(GLshort x, GLshort y)
-{
-    d_1_0_Deprecated->f.Vertex2s(x, y);
-}
-
-inline void QOpenGLFunctions_1_2::glVertex2iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Vertex2iv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glVertex2i(GLint x, GLint y)
-{
-    d_1_0_Deprecated->f.Vertex2i(x, y);
-}
-
-inline void QOpenGLFunctions_1_2::glVertex2fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Vertex2fv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glVertex2f(GLfloat x, GLfloat y)
-{
-    d_1_0_Deprecated->f.Vertex2f(x, y);
-}
-
-inline void QOpenGLFunctions_1_2::glVertex2dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Vertex2dv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glVertex2d(GLdouble x, GLdouble y)
-{
-    d_1_0_Deprecated->f.Vertex2d(x, y);
-}
-
-inline void QOpenGLFunctions_1_2::glTexCoord4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord4sv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
-{
-    d_1_0_Deprecated->f.TexCoord4s(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_1_2::glTexCoord4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord4iv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
-{
-    d_1_0_Deprecated->f.TexCoord4i(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_1_2::glTexCoord4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord4fv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
-{
-    d_1_0_Deprecated->f.TexCoord4f(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_1_2::glTexCoord4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord4dv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
-{
-    d_1_0_Deprecated->f.TexCoord4d(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_1_2::glTexCoord3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord3sv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glTexCoord3s(GLshort s, GLshort t, GLshort r)
-{
-    d_1_0_Deprecated->f.TexCoord3s(s, t, r);
-}
-
-inline void QOpenGLFunctions_1_2::glTexCoord3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord3iv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glTexCoord3i(GLint s, GLint t, GLint r)
-{
-    d_1_0_Deprecated->f.TexCoord3i(s, t, r);
-}
-
-inline void QOpenGLFunctions_1_2::glTexCoord3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord3fv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
-{
-    d_1_0_Deprecated->f.TexCoord3f(s, t, r);
-}
-
-inline void QOpenGLFunctions_1_2::glTexCoord3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord3dv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
-{
-    d_1_0_Deprecated->f.TexCoord3d(s, t, r);
-}
-
-inline void QOpenGLFunctions_1_2::glTexCoord2sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord2sv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glTexCoord2s(GLshort s, GLshort t)
-{
-    d_1_0_Deprecated->f.TexCoord2s(s, t);
-}
-
-inline void QOpenGLFunctions_1_2::glTexCoord2iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord2iv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glTexCoord2i(GLint s, GLint t)
-{
-    d_1_0_Deprecated->f.TexCoord2i(s, t);
-}
-
-inline void QOpenGLFunctions_1_2::glTexCoord2fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord2fv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glTexCoord2f(GLfloat s, GLfloat t)
-{
-    d_1_0_Deprecated->f.TexCoord2f(s, t);
-}
-
-inline void QOpenGLFunctions_1_2::glTexCoord2dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord2dv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glTexCoord2d(GLdouble s, GLdouble t)
-{
-    d_1_0_Deprecated->f.TexCoord2d(s, t);
-}
-
-inline void QOpenGLFunctions_1_2::glTexCoord1sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord1sv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glTexCoord1s(GLshort s)
-{
-    d_1_0_Deprecated->f.TexCoord1s(s);
-}
-
-inline void QOpenGLFunctions_1_2::glTexCoord1iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord1iv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glTexCoord1i(GLint s)
-{
-    d_1_0_Deprecated->f.TexCoord1i(s);
-}
-
-inline void QOpenGLFunctions_1_2::glTexCoord1fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord1fv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glTexCoord1f(GLfloat s)
-{
-    d_1_0_Deprecated->f.TexCoord1f(s);
-}
-
-inline void QOpenGLFunctions_1_2::glTexCoord1dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord1dv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glTexCoord1d(GLdouble s)
-{
-    d_1_0_Deprecated->f.TexCoord1d(s);
-}
-
-inline void QOpenGLFunctions_1_2::glRectsv(const GLshort *v1, const GLshort *v2)
-{
-    d_1_0_Deprecated->f.Rectsv(v1, v2);
-}
-
-inline void QOpenGLFunctions_1_2::glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
-{
-    d_1_0_Deprecated->f.Rects(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_1_2::glRectiv(const GLint *v1, const GLint *v2)
-{
-    d_1_0_Deprecated->f.Rectiv(v1, v2);
-}
-
-inline void QOpenGLFunctions_1_2::glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
-{
-    d_1_0_Deprecated->f.Recti(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_1_2::glRectfv(const GLfloat *v1, const GLfloat *v2)
-{
-    d_1_0_Deprecated->f.Rectfv(v1, v2);
-}
-
-inline void QOpenGLFunctions_1_2::glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
-{
-    d_1_0_Deprecated->f.Rectf(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_1_2::glRectdv(const GLdouble *v1, const GLdouble *v2)
-{
-    d_1_0_Deprecated->f.Rectdv(v1, v2);
-}
-
-inline void QOpenGLFunctions_1_2::glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
-{
-    d_1_0_Deprecated->f.Rectd(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_1_2::glRasterPos4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.RasterPos4sv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
-{
-    d_1_0_Deprecated->f.RasterPos4s(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_1_2::glRasterPos4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.RasterPos4iv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
-{
-    d_1_0_Deprecated->f.RasterPos4i(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_1_2::glRasterPos4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.RasterPos4fv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    d_1_0_Deprecated->f.RasterPos4f(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_1_2::glRasterPos4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.RasterPos4dv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_1_0_Deprecated->f.RasterPos4d(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_1_2::glRasterPos3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.RasterPos3sv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glRasterPos3s(GLshort x, GLshort y, GLshort z)
-{
-    d_1_0_Deprecated->f.RasterPos3s(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_2::glRasterPos3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.RasterPos3iv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glRasterPos3i(GLint x, GLint y, GLint z)
-{
-    d_1_0_Deprecated->f.RasterPos3i(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_2::glRasterPos3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.RasterPos3fv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.RasterPos3f(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_2::glRasterPos3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.RasterPos3dv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.RasterPos3d(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_2::glRasterPos2sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.RasterPos2sv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glRasterPos2s(GLshort x, GLshort y)
-{
-    d_1_0_Deprecated->f.RasterPos2s(x, y);
-}
-
-inline void QOpenGLFunctions_1_2::glRasterPos2iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.RasterPos2iv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glRasterPos2i(GLint x, GLint y)
-{
-    d_1_0_Deprecated->f.RasterPos2i(x, y);
-}
-
-inline void QOpenGLFunctions_1_2::glRasterPos2fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.RasterPos2fv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glRasterPos2f(GLfloat x, GLfloat y)
-{
-    d_1_0_Deprecated->f.RasterPos2f(x, y);
-}
-
-inline void QOpenGLFunctions_1_2::glRasterPos2dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.RasterPos2dv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glRasterPos2d(GLdouble x, GLdouble y)
-{
-    d_1_0_Deprecated->f.RasterPos2d(x, y);
-}
-
-inline void QOpenGLFunctions_1_2::glNormal3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Normal3sv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glNormal3s(GLshort nx, GLshort ny, GLshort nz)
-{
-    d_1_0_Deprecated->f.Normal3s(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_1_2::glNormal3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Normal3iv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glNormal3i(GLint nx, GLint ny, GLint nz)
-{
-    d_1_0_Deprecated->f.Normal3i(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_1_2::glNormal3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Normal3fv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
-{
-    d_1_0_Deprecated->f.Normal3f(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_1_2::glNormal3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Normal3dv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
-{
-    d_1_0_Deprecated->f.Normal3d(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_1_2::glNormal3bv(const GLbyte *v)
-{
-    d_1_0_Deprecated->f.Normal3bv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
-{
-    d_1_0_Deprecated->f.Normal3b(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_1_2::glIndexsv(const GLshort *c)
-{
-    d_1_0_Deprecated->f.Indexsv(c);
-}
-
-inline void QOpenGLFunctions_1_2::glIndexs(GLshort c)
-{
-    d_1_0_Deprecated->f.Indexs(c);
-}
-
-inline void QOpenGLFunctions_1_2::glIndexiv(const GLint *c)
-{
-    d_1_0_Deprecated->f.Indexiv(c);
-}
-
-inline void QOpenGLFunctions_1_2::glIndexi(GLint c)
-{
-    d_1_0_Deprecated->f.Indexi(c);
-}
-
-inline void QOpenGLFunctions_1_2::glIndexfv(const GLfloat *c)
-{
-    d_1_0_Deprecated->f.Indexfv(c);
-}
-
-inline void QOpenGLFunctions_1_2::glIndexf(GLfloat c)
-{
-    d_1_0_Deprecated->f.Indexf(c);
-}
-
-inline void QOpenGLFunctions_1_2::glIndexdv(const GLdouble *c)
-{
-    d_1_0_Deprecated->f.Indexdv(c);
-}
-
-inline void QOpenGLFunctions_1_2::glIndexd(GLdouble c)
-{
-    d_1_0_Deprecated->f.Indexd(c);
-}
-
-inline void QOpenGLFunctions_1_2::glEnd()
-{
-    d_1_0_Deprecated->f.End();
-}
-
-inline void QOpenGLFunctions_1_2::glEdgeFlagv(const GLboolean *flag)
-{
-    d_1_0_Deprecated->f.EdgeFlagv(flag);
-}
-
-inline void QOpenGLFunctions_1_2::glEdgeFlag(GLboolean flag)
-{
-    d_1_0_Deprecated->f.EdgeFlag(flag);
-}
-
-inline void QOpenGLFunctions_1_2::glColor4usv(const GLushort *v)
-{
-    d_1_0_Deprecated->f.Color4usv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
-{
-    d_1_0_Deprecated->f.Color4us(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_2::glColor4uiv(const GLuint *v)
-{
-    d_1_0_Deprecated->f.Color4uiv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
-{
-    d_1_0_Deprecated->f.Color4ui(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_2::glColor4ubv(const GLubyte *v)
-{
-    d_1_0_Deprecated->f.Color4ubv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
-{
-    d_1_0_Deprecated->f.Color4ub(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_2::glColor4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Color4sv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
-{
-    d_1_0_Deprecated->f.Color4s(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_2::glColor4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Color4iv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
-{
-    d_1_0_Deprecated->f.Color4i(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_2::glColor4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Color4fv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Deprecated->f.Color4f(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_2::glColor4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Color4dv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
-{
-    d_1_0_Deprecated->f.Color4d(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_2::glColor4bv(const GLbyte *v)
-{
-    d_1_0_Deprecated->f.Color4bv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
-{
-    d_1_0_Deprecated->f.Color4b(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_2::glColor3usv(const GLushort *v)
-{
-    d_1_0_Deprecated->f.Color3usv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glColor3us(GLushort red, GLushort green, GLushort blue)
-{
-    d_1_0_Deprecated->f.Color3us(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_2::glColor3uiv(const GLuint *v)
-{
-    d_1_0_Deprecated->f.Color3uiv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glColor3ui(GLuint red, GLuint green, GLuint blue)
-{
-    d_1_0_Deprecated->f.Color3ui(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_2::glColor3ubv(const GLubyte *v)
-{
-    d_1_0_Deprecated->f.Color3ubv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
-{
-    d_1_0_Deprecated->f.Color3ub(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_2::glColor3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Color3sv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glColor3s(GLshort red, GLshort green, GLshort blue)
-{
-    d_1_0_Deprecated->f.Color3s(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_2::glColor3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Color3iv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glColor3i(GLint red, GLint green, GLint blue)
-{
-    d_1_0_Deprecated->f.Color3i(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_2::glColor3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Color3fv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glColor3f(GLfloat red, GLfloat green, GLfloat blue)
-{
-    d_1_0_Deprecated->f.Color3f(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_2::glColor3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Color3dv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glColor3d(GLdouble red, GLdouble green, GLdouble blue)
-{
-    d_1_0_Deprecated->f.Color3d(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_2::glColor3bv(const GLbyte *v)
-{
-    d_1_0_Deprecated->f.Color3bv(v);
-}
-
-inline void QOpenGLFunctions_1_2::glColor3b(GLbyte red, GLbyte green, GLbyte blue)
-{
-    d_1_0_Deprecated->f.Color3b(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_2::glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
-{
-    d_1_0_Deprecated->f.Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
-}
-
-inline void QOpenGLFunctions_1_2::glBegin(GLenum mode)
-{
-    d_1_0_Deprecated->f.Begin(mode);
-}
-
-inline void QOpenGLFunctions_1_2::glListBase(GLuint base)
-{
-    d_1_0_Deprecated->f.ListBase(base);
-}
-
-inline GLuint QOpenGLFunctions_1_2::glGenLists(GLsizei range)
-{
-    return d_1_0_Deprecated->f.GenLists(range);
-}
-
-inline void QOpenGLFunctions_1_2::glDeleteLists(GLuint list, GLsizei range)
-{
-    d_1_0_Deprecated->f.DeleteLists(list, range);
-}
-
-inline void QOpenGLFunctions_1_2::glCallLists(GLsizei n, GLenum type, const GLvoid *lists)
-{
-    d_1_0_Deprecated->f.CallLists(n, type, lists);
-}
-
-inline void QOpenGLFunctions_1_2::glCallList(GLuint list)
-{
-    d_1_0_Deprecated->f.CallList(list);
-}
-
-inline void QOpenGLFunctions_1_2::glEndList()
-{
-    d_1_0_Deprecated->f.EndList();
-}
-
-inline void QOpenGLFunctions_1_2::glNewList(GLuint list, GLenum mode)
-{
-    d_1_0_Deprecated->f.NewList(list, mode);
-}
-
-
-// OpenGL 1.1 deprecated functions
-inline void QOpenGLFunctions_1_2::glPushClientAttrib(GLbitfield mask)
-{
-    d_1_1_Deprecated->f.PushClientAttrib(mask);
-}
-
-inline void QOpenGLFunctions_1_2::glPopClientAttrib()
-{
-    d_1_1_Deprecated->f.PopClientAttrib();
-}
-
-inline void QOpenGLFunctions_1_2::glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities)
-{
-    d_1_1_Deprecated->f.PrioritizeTextures(n, textures, priorities);
-}
-
-inline GLboolean QOpenGLFunctions_1_2::glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
-{
-    return d_1_1_Deprecated->f.AreTexturesResident(n, textures, residences);
-}
-
-inline void QOpenGLFunctions_1_2::glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.VertexPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_1_2::glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.TexCoordPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_1_2::glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.NormalPointer(type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_1_2::glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.InterleavedArrays(format, stride, pointer);
-}
-
-inline void QOpenGLFunctions_1_2::glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.IndexPointer(type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_1_2::glEnableClientState(GLenum array)
-{
-    d_1_1_Deprecated->f.EnableClientState(array);
-}
-
-inline void QOpenGLFunctions_1_2::glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.EdgeFlagPointer(stride, pointer);
-}
-
-inline void QOpenGLFunctions_1_2::glDisableClientState(GLenum array)
-{
-    d_1_1_Deprecated->f.DisableClientState(array);
-}
-
-inline void QOpenGLFunctions_1_2::glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.ColorPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_1_2::glArrayElement(GLint i)
-{
-    d_1_1_Deprecated->f.ArrayElement(i);
-}
-
-
-// OpenGL 1.2 deprecated functions
-inline void QOpenGLFunctions_1_2::glResetMinmax(GLenum target)
-{
-    d_1_2_Deprecated->f.ResetMinmax(target);
-}
-
-inline void QOpenGLFunctions_1_2::glResetHistogram(GLenum target)
-{
-    d_1_2_Deprecated->f.ResetHistogram(target);
-}
-
-inline void QOpenGLFunctions_1_2::glMinmax(GLenum target, GLenum internalformat, GLboolean sink)
-{
-    d_1_2_Deprecated->f.Minmax(target, internalformat, sink);
-}
-
-inline void QOpenGLFunctions_1_2::glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
-{
-    d_1_2_Deprecated->f.Histogram(target, width, internalformat, sink);
-}
-
-inline void QOpenGLFunctions_1_2::glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetMinmaxParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_2::glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetMinmaxParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_2::glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
-{
-    d_1_2_Deprecated->f.GetMinmax(target, reset, format, type, values);
-}
-
-inline void QOpenGLFunctions_1_2::glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetHistogramParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_2::glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetHistogramParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_2::glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
-{
-    d_1_2_Deprecated->f.GetHistogram(target, reset, format, type, values);
-}
-
-inline void QOpenGLFunctions_1_2::glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column)
-{
-    d_1_2_Deprecated->f.SeparableFilter2D(target, internalformat, width, height, format, type, row, column);
-}
-
-inline void QOpenGLFunctions_1_2::glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span)
-{
-    d_1_2_Deprecated->f.GetSeparableFilter(target, format, type, row, column, span);
-}
-
-inline void QOpenGLFunctions_1_2::glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetConvolutionParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_2::glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetConvolutionParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_2::glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image)
-{
-    d_1_2_Deprecated->f.GetConvolutionFilter(target, format, type, image);
-}
-
-inline void QOpenGLFunctions_1_2::glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_2_Deprecated->f.CopyConvolutionFilter2D(target, internalformat, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_1_2::glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
-{
-    d_1_2_Deprecated->f.CopyConvolutionFilter1D(target, internalformat, x, y, width);
-}
-
-inline void QOpenGLFunctions_1_2::glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_2::glConvolutionParameteri(GLenum target, GLenum pname, GLint params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameteri(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_2::glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_2::glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameterf(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_2::glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image)
-{
-    d_1_2_Deprecated->f.ConvolutionFilter2D(target, internalformat, width, height, format, type, image);
-}
-
-inline void QOpenGLFunctions_1_2::glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image)
-{
-    d_1_2_Deprecated->f.ConvolutionFilter1D(target, internalformat, width, format, type, image);
-}
-
-inline void QOpenGLFunctions_1_2::glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
-{
-    d_1_2_Deprecated->f.CopyColorSubTable(target, start, x, y, width);
-}
-
-inline void QOpenGLFunctions_1_2::glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data)
-{
-    d_1_2_Deprecated->f.ColorSubTable(target, start, count, format, type, data);
-}
-
-inline void QOpenGLFunctions_1_2::glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetColorTableParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_2::glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetColorTableParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_2::glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table)
-{
-    d_1_2_Deprecated->f.GetColorTable(target, format, type, table);
-}
-
-inline void QOpenGLFunctions_1_2::glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
-{
-    d_1_2_Deprecated->f.CopyColorTable(target, internalformat, x, y, width);
-}
-
-inline void QOpenGLFunctions_1_2::glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_2_Deprecated->f.ColorTableParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_2::glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_2_Deprecated->f.ColorTableParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_2::glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table)
-{
-    d_1_2_Deprecated->f.ColorTable(target, internalformat, width, format, type, table);
-}
-
-
-
-QT_END_NAMESPACE
-
-#endif // QT_NO_OPENGL && !QT_OPENGL_ES_2
-
-#endif
diff --git a/src/gui/opengl/qopenglfunctions_1_3.cpp b/src/gui/opengl/qopenglfunctions_1_3.cpp
deleted file mode 100644
index 0b5ff2fee5..0000000000
--- a/src/gui/opengl/qopenglfunctions_1_3.cpp
+++ /dev/null
@@ -1,190 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#include "qopenglfunctions_1_3.h"
-#include "qopenglcontext.h"
-
-QT_BEGIN_NAMESPACE
-
-/*!
-    \class QOpenGLFunctions_1_3
-    \inmodule QtGui
-    \since 5.1
-    \wrapper
-    \brief The QOpenGLFunctions_1_3 class provides all functions for OpenGL 1.3 specification.
-
-    This class is a wrapper for functions from OpenGL 1.3 specification.
-    See reference pages on \l {http://www.opengl.org/sdk/docs/}{opengl.org}
-    for function documentation.
-
-    \sa QAbstractOpenGLFunctions
-*/
-
-QOpenGLFunctions_1_3::QOpenGLFunctions_1_3()
- : QAbstractOpenGLFunctions()
- , d_1_0_Core(nullptr)
- , d_1_1_Core(nullptr)
- , d_1_2_Core(nullptr)
- , d_1_3_Core(nullptr)
- , d_1_0_Deprecated(nullptr)
- , d_1_1_Deprecated(nullptr)
- , d_1_2_Deprecated(nullptr)
- , d_1_3_Deprecated(nullptr)
-{
-}
-
-QOpenGLFunctions_1_3::~QOpenGLFunctions_1_3()
-{
-    if (d_1_0_Core) {
-        d_1_0_Core->refs.deref();
-        Q_ASSERT(d_1_0_Core->refs.loadRelaxed());
-    }
-    if (d_1_1_Core) {
-        d_1_1_Core->refs.deref();
-        Q_ASSERT(d_1_1_Core->refs.loadRelaxed());
-    }
-    if (d_1_2_Core) {
-        d_1_2_Core->refs.deref();
-        Q_ASSERT(d_1_2_Core->refs.loadRelaxed());
-    }
-    if (d_1_3_Core) {
-        d_1_3_Core->refs.deref();
-        Q_ASSERT(d_1_3_Core->refs.loadRelaxed());
-    }
-    if (d_1_0_Deprecated) {
-        d_1_0_Deprecated->refs.deref();
-        Q_ASSERT(d_1_0_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_1_Deprecated) {
-        d_1_1_Deprecated->refs.deref();
-        Q_ASSERT(d_1_1_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_2_Deprecated) {
-        d_1_2_Deprecated->refs.deref();
-        Q_ASSERT(d_1_2_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_3_Deprecated) {
-        d_1_3_Deprecated->refs.deref();
-        Q_ASSERT(d_1_3_Deprecated->refs.loadRelaxed());
-    }
-}
-
-bool QOpenGLFunctions_1_3::initializeOpenGLFunctions()
-{
-    if ( isInitialized() )
-        return true;
-
-    QOpenGLContext* context = QOpenGLContext::currentContext();
-
-    // If owned by a context object make sure it is current.
-    // Also check that current context is capable of resolving all needed functions
-    if (((owningContext() && owningContext() == context) || !owningContext())
-        && QOpenGLFunctions_1_3::isContextCompatible(context))
-    {
-        // Associate with private implementation, creating if necessary
-        // Function pointers in the backends are resolved at creation time
-        QOpenGLVersionFunctionsBackend* d = nullptr;
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        d_1_3_Core = static_cast<QOpenGLFunctions_1_3_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
-        d_1_0_Deprecated = static_cast<QOpenGLFunctions_1_0_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
-        d_1_1_Deprecated = static_cast<QOpenGLFunctions_1_1_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus());
-        d_1_2_Deprecated = static_cast<QOpenGLFunctions_1_2_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus());
-        d_1_3_Deprecated = static_cast<QOpenGLFunctions_1_3_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        QAbstractOpenGLFunctions::initializeOpenGLFunctions();
-    }
-    return isInitialized();
-}
-
-bool QOpenGLFunctions_1_3::isContextCompatible(QOpenGLContext *context)
-{
-    Q_ASSERT(context);
-    QSurfaceFormat f = context->format();
-    const QPair<int, int> v = qMakePair(f.majorVersion(), f.minorVersion());
-    if (v < qMakePair(1, 3))
-        return false;
-
-    if (f.profile() == QSurfaceFormat::CoreProfile)
-        return false;
-
-    return true;
-}
-
-QOpenGLVersionProfile QOpenGLFunctions_1_3::versionProfile()
-{
-    QOpenGLVersionProfile v;
-    v.setVersion(1, 3);
-    return v;
-}
-
-QT_END_NAMESPACE
diff --git a/src/gui/opengl/qopenglfunctions_1_3.h b/src/gui/opengl/qopenglfunctions_1_3.h
deleted file mode 100644
index b527b57946..0000000000
--- a/src/gui/opengl/qopenglfunctions_1_3.h
+++ /dev/null
@@ -1,2643 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#ifndef QOPENGLVERSIONFUNCTIONS_1_3_H
-#define QOPENGLVERSIONFUNCTIONS_1_3_H
-
-#include <QtGui/qtguiglobal.h>
-
-#if !defined(QT_NO_OPENGL) && !defined(QT_OPENGL_ES_2)
-
-#include <QtGui/QOpenGLVersionFunctions>
-#include <QtGui/qopenglcontext.h>
-
-QT_BEGIN_NAMESPACE
-
-class Q_GUI_EXPORT QOpenGLFunctions_1_3 : public QAbstractOpenGLFunctions
-{
-public:
-    QOpenGLFunctions_1_3();
-    ~QOpenGLFunctions_1_3();
-
-    bool initializeOpenGLFunctions() override;
-
-    // OpenGL 1.0 core functions
-    void glViewport(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glDepthRange(GLdouble nearVal, GLdouble farVal);
-    GLboolean glIsEnabled(GLenum cap);
-    void glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params);
-    void glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params);
-    void glGetTexParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
-    const GLubyte * glGetString(GLenum name);
-    void glGetIntegerv(GLenum pname, GLint *params);
-    void glGetFloatv(GLenum pname, GLfloat *params);
-    GLenum glGetError();
-    void glGetDoublev(GLenum pname, GLdouble *params);
-    void glGetBooleanv(GLenum pname, GLboolean *params);
-    void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
-    void glReadBuffer(GLenum mode);
-    void glPixelStorei(GLenum pname, GLint param);
-    void glPixelStoref(GLenum pname, GLfloat param);
-    void glDepthFunc(GLenum func);
-    void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass);
-    void glStencilFunc(GLenum func, GLint ref, GLuint mask);
-    void glLogicOp(GLenum opcode);
-    void glBlendFunc(GLenum sfactor, GLenum dfactor);
-    void glFlush();
-    void glFinish();
-    void glEnable(GLenum cap);
-    void glDisable(GLenum cap);
-    void glDepthMask(GLboolean flag);
-    void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
-    void glStencilMask(GLuint mask);
-    void glClearDepth(GLdouble depth);
-    void glClearStencil(GLint s);
-    void glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glClear(GLbitfield mask);
-    void glDrawBuffer(GLenum mode);
-    void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glTexParameteri(GLenum target, GLenum pname, GLint param);
-    void glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glTexParameterf(GLenum target, GLenum pname, GLfloat param);
-    void glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glPolygonMode(GLenum face, GLenum mode);
-    void glPointSize(GLfloat size);
-    void glLineWidth(GLfloat width);
-    void glHint(GLenum target, GLenum mode);
-    void glFrontFace(GLenum mode);
-    void glCullFace(GLenum mode);
-
-    // OpenGL 1.1 core functions
-    void glIndexubv(const GLubyte *c);
-    void glIndexub(GLubyte c);
-    GLboolean glIsTexture(GLuint texture);
-    void glGenTextures(GLsizei n, GLuint *textures);
-    void glDeleteTextures(GLsizei n, const GLuint *textures);
-    void glBindTexture(GLenum target, GLuint texture);
-    void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
-    void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
-    void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
-    void glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
-    void glPolygonOffset(GLfloat factor, GLfloat units);
-    void glGetPointerv(GLenum pname, GLvoid* *params);
-    void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
-    void glDrawArrays(GLenum mode, GLint first, GLsizei count);
-
-    // OpenGL 1.2 core functions
-    void glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices);
-    void glBlendEquation(GLenum mode);
-    void glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-
-    // OpenGL 1.3 core functions
-    void glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img);
-    void glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glSampleCoverage(GLfloat value, GLboolean invert);
-    void glActiveTexture(GLenum texture);
-
-    // OpenGL 1.0 deprecated functions
-    void glTranslatef(GLfloat x, GLfloat y, GLfloat z);
-    void glTranslated(GLdouble x, GLdouble y, GLdouble z);
-    void glScalef(GLfloat x, GLfloat y, GLfloat z);
-    void glScaled(GLdouble x, GLdouble y, GLdouble z);
-    void glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
-    void glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
-    void glPushMatrix();
-    void glPopMatrix();
-    void glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
-    void glMultMatrixd(const GLdouble *m);
-    void glMultMatrixf(const GLfloat *m);
-    void glMatrixMode(GLenum mode);
-    void glLoadMatrixd(const GLdouble *m);
-    void glLoadMatrixf(const GLfloat *m);
-    void glLoadIdentity();
-    void glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
-    GLboolean glIsList(GLuint list);
-    void glGetTexGeniv(GLenum coord, GLenum pname, GLint *params);
-    void glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params);
-    void glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params);
-    void glGetTexEnviv(GLenum target, GLenum pname, GLint *params);
-    void glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetPolygonStipple(GLubyte *mask);
-    void glGetPixelMapusv(GLenum map, GLushort *values);
-    void glGetPixelMapuiv(GLenum map, GLuint *values);
-    void glGetPixelMapfv(GLenum map, GLfloat *values);
-    void glGetMaterialiv(GLenum face, GLenum pname, GLint *params);
-    void glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params);
-    void glGetMapiv(GLenum target, GLenum query, GLint *v);
-    void glGetMapfv(GLenum target, GLenum query, GLfloat *v);
-    void glGetMapdv(GLenum target, GLenum query, GLdouble *v);
-    void glGetLightiv(GLenum light, GLenum pname, GLint *params);
-    void glGetLightfv(GLenum light, GLenum pname, GLfloat *params);
-    void glGetClipPlane(GLenum plane, GLdouble *equation);
-    void glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
-    void glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
-    void glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values);
-    void glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values);
-    void glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values);
-    void glPixelTransferi(GLenum pname, GLint param);
-    void glPixelTransferf(GLenum pname, GLfloat param);
-    void glPixelZoom(GLfloat xfactor, GLfloat yfactor);
-    void glAlphaFunc(GLenum func, GLfloat ref);
-    void glEvalPoint2(GLint i, GLint j);
-    void glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
-    void glEvalPoint1(GLint i);
-    void glEvalMesh1(GLenum mode, GLint i1, GLint i2);
-    void glEvalCoord2fv(const GLfloat *u);
-    void glEvalCoord2f(GLfloat u, GLfloat v);
-    void glEvalCoord2dv(const GLdouble *u);
-    void glEvalCoord2d(GLdouble u, GLdouble v);
-    void glEvalCoord1fv(const GLfloat *u);
-    void glEvalCoord1f(GLfloat u);
-    void glEvalCoord1dv(const GLdouble *u);
-    void glEvalCoord1d(GLdouble u);
-    void glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
-    void glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
-    void glMapGrid1f(GLint un, GLfloat u1, GLfloat u2);
-    void glMapGrid1d(GLint un, GLdouble u1, GLdouble u2);
-    void glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);
-    void glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);
-    void glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);
-    void glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);
-    void glPushAttrib(GLbitfield mask);
-    void glPopAttrib();
-    void glAccum(GLenum op, GLfloat value);
-    void glIndexMask(GLuint mask);
-    void glClearIndex(GLfloat c);
-    void glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glPushName(GLuint name);
-    void glPopName();
-    void glPassThrough(GLfloat token);
-    void glLoadName(GLuint name);
-    void glInitNames();
-    GLint glRenderMode(GLenum mode);
-    void glSelectBuffer(GLsizei size, GLuint *buffer);
-    void glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer);
-    void glTexGeniv(GLenum coord, GLenum pname, const GLint *params);
-    void glTexGeni(GLenum coord, GLenum pname, GLint param);
-    void glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params);
-    void glTexGenf(GLenum coord, GLenum pname, GLfloat param);
-    void glTexGendv(GLenum coord, GLenum pname, const GLdouble *params);
-    void glTexGend(GLenum coord, GLenum pname, GLdouble param);
-    void glTexEnviv(GLenum target, GLenum pname, const GLint *params);
-    void glTexEnvi(GLenum target, GLenum pname, GLint param);
-    void glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glTexEnvf(GLenum target, GLenum pname, GLfloat param);
-    void glShadeModel(GLenum mode);
-    void glPolygonStipple(const GLubyte *mask);
-    void glMaterialiv(GLenum face, GLenum pname, const GLint *params);
-    void glMateriali(GLenum face, GLenum pname, GLint param);
-    void glMaterialfv(GLenum face, GLenum pname, const GLfloat *params);
-    void glMaterialf(GLenum face, GLenum pname, GLfloat param);
-    void glLineStipple(GLint factor, GLushort pattern);
-    void glLightModeliv(GLenum pname, const GLint *params);
-    void glLightModeli(GLenum pname, GLint param);
-    void glLightModelfv(GLenum pname, const GLfloat *params);
-    void glLightModelf(GLenum pname, GLfloat param);
-    void glLightiv(GLenum light, GLenum pname, const GLint *params);
-    void glLighti(GLenum light, GLenum pname, GLint param);
-    void glLightfv(GLenum light, GLenum pname, const GLfloat *params);
-    void glLightf(GLenum light, GLenum pname, GLfloat param);
-    void glFogiv(GLenum pname, const GLint *params);
-    void glFogi(GLenum pname, GLint param);
-    void glFogfv(GLenum pname, const GLfloat *params);
-    void glFogf(GLenum pname, GLfloat param);
-    void glColorMaterial(GLenum face, GLenum mode);
-    void glClipPlane(GLenum plane, const GLdouble *equation);
-    void glVertex4sv(const GLshort *v);
-    void glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w);
-    void glVertex4iv(const GLint *v);
-    void glVertex4i(GLint x, GLint y, GLint z, GLint w);
-    void glVertex4fv(const GLfloat *v);
-    void glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void glVertex4dv(const GLdouble *v);
-    void glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glVertex3sv(const GLshort *v);
-    void glVertex3s(GLshort x, GLshort y, GLshort z);
-    void glVertex3iv(const GLint *v);
-    void glVertex3i(GLint x, GLint y, GLint z);
-    void glVertex3fv(const GLfloat *v);
-    void glVertex3f(GLfloat x, GLfloat y, GLfloat z);
-    void glVertex3dv(const GLdouble *v);
-    void glVertex3d(GLdouble x, GLdouble y, GLdouble z);
-    void glVertex2sv(const GLshort *v);
-    void glVertex2s(GLshort x, GLshort y);
-    void glVertex2iv(const GLint *v);
-    void glVertex2i(GLint x, GLint y);
-    void glVertex2fv(const GLfloat *v);
-    void glVertex2f(GLfloat x, GLfloat y);
-    void glVertex2dv(const GLdouble *v);
-    void glVertex2d(GLdouble x, GLdouble y);
-    void glTexCoord4sv(const GLshort *v);
-    void glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q);
-    void glTexCoord4iv(const GLint *v);
-    void glTexCoord4i(GLint s, GLint t, GLint r, GLint q);
-    void glTexCoord4fv(const GLfloat *v);
-    void glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
-    void glTexCoord4dv(const GLdouble *v);
-    void glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q);
-    void glTexCoord3sv(const GLshort *v);
-    void glTexCoord3s(GLshort s, GLshort t, GLshort r);
-    void glTexCoord3iv(const GLint *v);
-    void glTexCoord3i(GLint s, GLint t, GLint r);
-    void glTexCoord3fv(const GLfloat *v);
-    void glTexCoord3f(GLfloat s, GLfloat t, GLfloat r);
-    void glTexCoord3dv(const GLdouble *v);
-    void glTexCoord3d(GLdouble s, GLdouble t, GLdouble r);
-    void glTexCoord2sv(const GLshort *v);
-    void glTexCoord2s(GLshort s, GLshort t);
-    void glTexCoord2iv(const GLint *v);
-    void glTexCoord2i(GLint s, GLint t);
-    void glTexCoord2fv(const GLfloat *v);
-    void glTexCoord2f(GLfloat s, GLfloat t);
-    void glTexCoord2dv(const GLdouble *v);
-    void glTexCoord2d(GLdouble s, GLdouble t);
-    void glTexCoord1sv(const GLshort *v);
-    void glTexCoord1s(GLshort s);
-    void glTexCoord1iv(const GLint *v);
-    void glTexCoord1i(GLint s);
-    void glTexCoord1fv(const GLfloat *v);
-    void glTexCoord1f(GLfloat s);
-    void glTexCoord1dv(const GLdouble *v);
-    void glTexCoord1d(GLdouble s);
-    void glRectsv(const GLshort *v1, const GLshort *v2);
-    void glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
-    void glRectiv(const GLint *v1, const GLint *v2);
-    void glRecti(GLint x1, GLint y1, GLint x2, GLint y2);
-    void glRectfv(const GLfloat *v1, const GLfloat *v2);
-    void glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
-    void glRectdv(const GLdouble *v1, const GLdouble *v2);
-    void glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
-    void glRasterPos4sv(const GLshort *v);
-    void glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w);
-    void glRasterPos4iv(const GLint *v);
-    void glRasterPos4i(GLint x, GLint y, GLint z, GLint w);
-    void glRasterPos4fv(const GLfloat *v);
-    void glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void glRasterPos4dv(const GLdouble *v);
-    void glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glRasterPos3sv(const GLshort *v);
-    void glRasterPos3s(GLshort x, GLshort y, GLshort z);
-    void glRasterPos3iv(const GLint *v);
-    void glRasterPos3i(GLint x, GLint y, GLint z);
-    void glRasterPos3fv(const GLfloat *v);
-    void glRasterPos3f(GLfloat x, GLfloat y, GLfloat z);
-    void glRasterPos3dv(const GLdouble *v);
-    void glRasterPos3d(GLdouble x, GLdouble y, GLdouble z);
-    void glRasterPos2sv(const GLshort *v);
-    void glRasterPos2s(GLshort x, GLshort y);
-    void glRasterPos2iv(const GLint *v);
-    void glRasterPos2i(GLint x, GLint y);
-    void glRasterPos2fv(const GLfloat *v);
-    void glRasterPos2f(GLfloat x, GLfloat y);
-    void glRasterPos2dv(const GLdouble *v);
-    void glRasterPos2d(GLdouble x, GLdouble y);
-    void glNormal3sv(const GLshort *v);
-    void glNormal3s(GLshort nx, GLshort ny, GLshort nz);
-    void glNormal3iv(const GLint *v);
-    void glNormal3i(GLint nx, GLint ny, GLint nz);
-    void glNormal3fv(const GLfloat *v);
-    void glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz);
-    void glNormal3dv(const GLdouble *v);
-    void glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz);
-    void glNormal3bv(const GLbyte *v);
-    void glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz);
-    void glIndexsv(const GLshort *c);
-    void glIndexs(GLshort c);
-    void glIndexiv(const GLint *c);
-    void glIndexi(GLint c);
-    void glIndexfv(const GLfloat *c);
-    void glIndexf(GLfloat c);
-    void glIndexdv(const GLdouble *c);
-    void glIndexd(GLdouble c);
-    void glEnd();
-    void glEdgeFlagv(const GLboolean *flag);
-    void glEdgeFlag(GLboolean flag);
-    void glColor4usv(const GLushort *v);
-    void glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha);
-    void glColor4uiv(const GLuint *v);
-    void glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha);
-    void glColor4ubv(const GLubyte *v);
-    void glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
-    void glColor4sv(const GLshort *v);
-    void glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha);
-    void glColor4iv(const GLint *v);
-    void glColor4i(GLint red, GLint green, GLint blue, GLint alpha);
-    void glColor4fv(const GLfloat *v);
-    void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glColor4dv(const GLdouble *v);
-    void glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
-    void glColor4bv(const GLbyte *v);
-    void glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
-    void glColor3usv(const GLushort *v);
-    void glColor3us(GLushort red, GLushort green, GLushort blue);
-    void glColor3uiv(const GLuint *v);
-    void glColor3ui(GLuint red, GLuint green, GLuint blue);
-    void glColor3ubv(const GLubyte *v);
-    void glColor3ub(GLubyte red, GLubyte green, GLubyte blue);
-    void glColor3sv(const GLshort *v);
-    void glColor3s(GLshort red, GLshort green, GLshort blue);
-    void glColor3iv(const GLint *v);
-    void glColor3i(GLint red, GLint green, GLint blue);
-    void glColor3fv(const GLfloat *v);
-    void glColor3f(GLfloat red, GLfloat green, GLfloat blue);
-    void glColor3dv(const GLdouble *v);
-    void glColor3d(GLdouble red, GLdouble green, GLdouble blue);
-    void glColor3bv(const GLbyte *v);
-    void glColor3b(GLbyte red, GLbyte green, GLbyte blue);
-    void glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap);
-    void glBegin(GLenum mode);
-    void glListBase(GLuint base);
-    GLuint glGenLists(GLsizei range);
-    void glDeleteLists(GLuint list, GLsizei range);
-    void glCallLists(GLsizei n, GLenum type, const GLvoid *lists);
-    void glCallList(GLuint list);
-    void glEndList();
-    void glNewList(GLuint list, GLenum mode);
-
-    // OpenGL 1.1 deprecated functions
-    void glPushClientAttrib(GLbitfield mask);
-    void glPopClientAttrib();
-    void glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities);
-    GLboolean glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences);
-    void glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer);
-    void glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glEnableClientState(GLenum array);
-    void glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer);
-    void glDisableClientState(GLenum array);
-    void glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glArrayElement(GLint i);
-
-    // OpenGL 1.2 deprecated functions
-    void glResetMinmax(GLenum target);
-    void glResetHistogram(GLenum target);
-    void glMinmax(GLenum target, GLenum internalformat, GLboolean sink);
-    void glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink);
-    void glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
-    void glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
-    void glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column);
-    void glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span);
-    void glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image);
-    void glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
-    void glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glConvolutionParameteri(GLenum target, GLenum pname, GLint params);
-    void glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params);
-    void glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image);
-    void glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image);
-    void glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width);
-    void glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data);
-    void glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table);
-    void glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
-    void glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table);
-
-    // OpenGL 1.3 deprecated functions
-    void glMultTransposeMatrixd(const GLdouble *m);
-    void glMultTransposeMatrixf(const GLfloat *m);
-    void glLoadTransposeMatrixd(const GLdouble *m);
-    void glLoadTransposeMatrixf(const GLfloat *m);
-    void glMultiTexCoord4sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);
-    void glMultiTexCoord4iv(GLenum target, const GLint *v);
-    void glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q);
-    void glMultiTexCoord4fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
-    void glMultiTexCoord4dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
-    void glMultiTexCoord3sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r);
-    void glMultiTexCoord3iv(GLenum target, const GLint *v);
-    void glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r);
-    void glMultiTexCoord3fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r);
-    void glMultiTexCoord3dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r);
-    void glMultiTexCoord2sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord2s(GLenum target, GLshort s, GLshort t);
-    void glMultiTexCoord2iv(GLenum target, const GLint *v);
-    void glMultiTexCoord2i(GLenum target, GLint s, GLint t);
-    void glMultiTexCoord2fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t);
-    void glMultiTexCoord2dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t);
-    void glMultiTexCoord1sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord1s(GLenum target, GLshort s);
-    void glMultiTexCoord1iv(GLenum target, const GLint *v);
-    void glMultiTexCoord1i(GLenum target, GLint s);
-    void glMultiTexCoord1fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord1f(GLenum target, GLfloat s);
-    void glMultiTexCoord1dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord1d(GLenum target, GLdouble s);
-    void glClientActiveTexture(GLenum texture);
-
-private:
-    friend class QOpenGLContext;
-
-    static bool isContextCompatible(QOpenGLContext *context);
-    static QOpenGLVersionProfile versionProfile();
-
-    QOpenGLFunctions_1_0_CoreBackend* d_1_0_Core;
-    QOpenGLFunctions_1_1_CoreBackend* d_1_1_Core;
-    QOpenGLFunctions_1_2_CoreBackend* d_1_2_Core;
-    QOpenGLFunctions_1_3_CoreBackend* d_1_3_Core;
-    QOpenGLFunctions_1_0_DeprecatedBackend* d_1_0_Deprecated;
-    QOpenGLFunctions_1_1_DeprecatedBackend* d_1_1_Deprecated;
-    QOpenGLFunctions_1_2_DeprecatedBackend* d_1_2_Deprecated;
-    QOpenGLFunctions_1_3_DeprecatedBackend* d_1_3_Deprecated;
-};
-
-// OpenGL 1.0 core functions
-inline void QOpenGLFunctions_1_3::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_0_Core->f.Viewport(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_1_3::glDepthRange(GLdouble nearVal, GLdouble farVal)
-{
-    d_1_0_Core->f.DepthRange(nearVal, farVal);
-}
-
-inline GLboolean QOpenGLFunctions_1_3::glIsEnabled(GLenum cap)
-{
-    return d_1_0_Core->f.IsEnabled(cap);
-}
-
-inline void QOpenGLFunctions_1_3::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
-}
-
-inline void QOpenGLFunctions_1_3::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
-}
-
-inline void QOpenGLFunctions_1_3::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetTexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_3::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetTexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_3::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
-{
-    d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
-}
-
-inline const GLubyte * QOpenGLFunctions_1_3::glGetString(GLenum name)
-{
-    return d_1_0_Core->f.GetString(name);
-}
-
-inline void QOpenGLFunctions_1_3::glGetIntegerv(GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetIntegerv(pname, params);
-}
-
-inline void QOpenGLFunctions_1_3::glGetFloatv(GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetFloatv(pname, params);
-}
-
-inline GLenum QOpenGLFunctions_1_3::glGetError()
-{
-    return d_1_0_Core->f.GetError();
-}
-
-inline void QOpenGLFunctions_1_3::glGetDoublev(GLenum pname, GLdouble *params)
-{
-    d_1_0_Core->f.GetDoublev(pname, params);
-}
-
-inline void QOpenGLFunctions_1_3::glGetBooleanv(GLenum pname, GLboolean *params)
-{
-    d_1_0_Core->f.GetBooleanv(pname, params);
-}
-
-inline void QOpenGLFunctions_1_3::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
-{
-    d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_1_3::glReadBuffer(GLenum mode)
-{
-    d_1_0_Core->f.ReadBuffer(mode);
-}
-
-inline void QOpenGLFunctions_1_3::glPixelStorei(GLenum pname, GLint param)
-{
-    d_1_0_Core->f.PixelStorei(pname, param);
-}
-
-inline void QOpenGLFunctions_1_3::glPixelStoref(GLenum pname, GLfloat param)
-{
-    d_1_0_Core->f.PixelStoref(pname, param);
-}
-
-inline void QOpenGLFunctions_1_3::glDepthFunc(GLenum func)
-{
-    d_1_0_Core->f.DepthFunc(func);
-}
-
-inline void QOpenGLFunctions_1_3::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
-{
-    d_1_0_Core->f.StencilOp(fail, zfail, zpass);
-}
-
-inline void QOpenGLFunctions_1_3::glStencilFunc(GLenum func, GLint ref, GLuint mask)
-{
-    d_1_0_Core->f.StencilFunc(func, ref, mask);
-}
-
-inline void QOpenGLFunctions_1_3::glLogicOp(GLenum opcode)
-{
-    d_1_0_Core->f.LogicOp(opcode);
-}
-
-inline void QOpenGLFunctions_1_3::glBlendFunc(GLenum sfactor, GLenum dfactor)
-{
-    d_1_0_Core->f.BlendFunc(sfactor, dfactor);
-}
-
-inline void QOpenGLFunctions_1_3::glFlush()
-{
-    d_1_0_Core->f.Flush();
-}
-
-inline void QOpenGLFunctions_1_3::glFinish()
-{
-    d_1_0_Core->f.Finish();
-}
-
-inline void QOpenGLFunctions_1_3::glEnable(GLenum cap)
-{
-    d_1_0_Core->f.Enable(cap);
-}
-
-inline void QOpenGLFunctions_1_3::glDisable(GLenum cap)
-{
-    d_1_0_Core->f.Disable(cap);
-}
-
-inline void QOpenGLFunctions_1_3::glDepthMask(GLboolean flag)
-{
-    d_1_0_Core->f.DepthMask(flag);
-}
-
-inline void QOpenGLFunctions_1_3::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
-{
-    d_1_0_Core->f.ColorMask(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_3::glStencilMask(GLuint mask)
-{
-    d_1_0_Core->f.StencilMask(mask);
-}
-
-inline void QOpenGLFunctions_1_3::glClearDepth(GLdouble depth)
-{
-    d_1_0_Core->f.ClearDepth(depth);
-}
-
-inline void QOpenGLFunctions_1_3::glClearStencil(GLint s)
-{
-    d_1_0_Core->f.ClearStencil(s);
-}
-
-inline void QOpenGLFunctions_1_3::glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Core->f.ClearColor(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_3::glClear(GLbitfield mask)
-{
-    d_1_0_Core->f.Clear(mask);
-}
-
-inline void QOpenGLFunctions_1_3::glDrawBuffer(GLenum mode)
-{
-    d_1_0_Core->f.DrawBuffer(mode);
-}
-
-inline void QOpenGLFunctions_1_3::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Core->f.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_1_3::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Core->f.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_1_3::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_0_Core->f.TexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_3::glTexParameteri(GLenum target, GLenum pname, GLint param)
-{
-    d_1_0_Core->f.TexParameteri(target, pname, param);
-}
-
-inline void QOpenGLFunctions_1_3::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Core->f.TexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_3::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
-{
-    d_1_0_Core->f.TexParameterf(target, pname, param);
-}
-
-inline void QOpenGLFunctions_1_3::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_0_Core->f.Scissor(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_1_3::glPolygonMode(GLenum face, GLenum mode)
-{
-    d_1_0_Core->f.PolygonMode(face, mode);
-}
-
-inline void QOpenGLFunctions_1_3::glPointSize(GLfloat size)
-{
-    d_1_0_Core->f.PointSize(size);
-}
-
-inline void QOpenGLFunctions_1_3::glLineWidth(GLfloat width)
-{
-    d_1_0_Core->f.LineWidth(width);
-}
-
-inline void QOpenGLFunctions_1_3::glHint(GLenum target, GLenum mode)
-{
-    d_1_0_Core->f.Hint(target, mode);
-}
-
-inline void QOpenGLFunctions_1_3::glFrontFace(GLenum mode)
-{
-    d_1_0_Core->f.FrontFace(mode);
-}
-
-inline void QOpenGLFunctions_1_3::glCullFace(GLenum mode)
-{
-    d_1_0_Core->f.CullFace(mode);
-}
-
-
-// OpenGL 1.1 core functions
-inline void QOpenGLFunctions_1_3::glIndexubv(const GLubyte *c)
-{
-    d_1_1_Deprecated->f.Indexubv(c);
-}
-
-inline void QOpenGLFunctions_1_3::glIndexub(GLubyte c)
-{
-    d_1_1_Deprecated->f.Indexub(c);
-}
-
-inline GLboolean QOpenGLFunctions_1_3::glIsTexture(GLuint texture)
-{
-    return d_1_1_Core->f.IsTexture(texture);
-}
-
-inline void QOpenGLFunctions_1_3::glGenTextures(GLsizei n, GLuint *textures)
-{
-    d_1_1_Core->f.GenTextures(n, textures);
-}
-
-inline void QOpenGLFunctions_1_3::glDeleteTextures(GLsizei n, const GLuint *textures)
-{
-    d_1_1_Core->f.DeleteTextures(n, textures);
-}
-
-inline void QOpenGLFunctions_1_3::glBindTexture(GLenum target, GLuint texture)
-{
-    d_1_1_Core->f.BindTexture(target, texture);
-}
-
-inline void QOpenGLFunctions_1_3::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_1_Core->f.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_1_3::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_1_Core->f.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_1_3::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_1_Core->f.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_1_3::glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
-{
-    d_1_1_Core->f.CopyTexSubImage1D(target, level, xoffset, x, y, width);
-}
-
-inline void QOpenGLFunctions_1_3::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
-{
-    d_1_1_Core->f.CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
-}
-
-inline void QOpenGLFunctions_1_3::glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
-{
-    d_1_1_Core->f.CopyTexImage1D(target, level, internalformat, x, y, width, border);
-}
-
-inline void QOpenGLFunctions_1_3::glPolygonOffset(GLfloat factor, GLfloat units)
-{
-    d_1_1_Core->f.PolygonOffset(factor, units);
-}
-
-inline void QOpenGLFunctions_1_3::glGetPointerv(GLenum pname, GLvoid* *params)
-{
-    d_1_1_Deprecated->f.GetPointerv(pname, params);
-}
-
-inline void QOpenGLFunctions_1_3::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
-{
-    d_1_1_Core->f.DrawElements(mode, count, type, indices);
-}
-
-inline void QOpenGLFunctions_1_3::glDrawArrays(GLenum mode, GLint first, GLsizei count)
-{
-    d_1_1_Core->f.DrawArrays(mode, first, count);
-}
-
-
-// OpenGL 1.2 core functions
-inline void QOpenGLFunctions_1_3::glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_2_Core->f.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_1_3::glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_2_Core->f.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_1_3::glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_2_Core->f.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_1_3::glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
-{
-    d_1_2_Core->f.DrawRangeElements(mode, start, end, count, type, indices);
-}
-
-inline void QOpenGLFunctions_1_3::glBlendEquation(GLenum mode)
-{
-    d_1_2_Core->f.BlendEquation(mode);
-}
-
-inline void QOpenGLFunctions_1_3::glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_2_Core->f.BlendColor(red, green, blue, alpha);
-}
-
-
-// OpenGL 1.3 core functions
-inline void QOpenGLFunctions_1_3::glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img)
-{
-    d_1_3_Core->f.GetCompressedTexImage(target, level, img);
-}
-
-inline void QOpenGLFunctions_1_3::glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_1_3::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_1_3::glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_1_3::glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_1_3::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_1_3::glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_1_3::glSampleCoverage(GLfloat value, GLboolean invert)
-{
-    d_1_3_Core->f.SampleCoverage(value, invert);
-}
-
-inline void QOpenGLFunctions_1_3::glActiveTexture(GLenum texture)
-{
-    d_1_3_Core->f.ActiveTexture(texture);
-}
-
-
-// OpenGL 1.0 deprecated functions
-inline void QOpenGLFunctions_1_3::glTranslatef(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Translatef(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_3::glTranslated(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Translated(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_3::glScalef(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Scalef(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_3::glScaled(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Scaled(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_3::glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Rotatef(angle, x, y, z);
-}
-
-inline void QOpenGLFunctions_1_3::glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Rotated(angle, x, y, z);
-}
-
-inline void QOpenGLFunctions_1_3::glPushMatrix()
-{
-    d_1_0_Deprecated->f.PushMatrix();
-}
-
-inline void QOpenGLFunctions_1_3::glPopMatrix()
-{
-    d_1_0_Deprecated->f.PopMatrix();
-}
-
-inline void QOpenGLFunctions_1_3::glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
-{
-    d_1_0_Deprecated->f.Ortho(left, right, bottom, top, zNear, zFar);
-}
-
-inline void QOpenGLFunctions_1_3::glMultMatrixd(const GLdouble *m)
-{
-    d_1_0_Deprecated->f.MultMatrixd(m);
-}
-
-inline void QOpenGLFunctions_1_3::glMultMatrixf(const GLfloat *m)
-{
-    d_1_0_Deprecated->f.MultMatrixf(m);
-}
-
-inline void QOpenGLFunctions_1_3::glMatrixMode(GLenum mode)
-{
-    d_1_0_Deprecated->f.MatrixMode(mode);
-}
-
-inline void QOpenGLFunctions_1_3::glLoadMatrixd(const GLdouble *m)
-{
-    d_1_0_Deprecated->f.LoadMatrixd(m);
-}
-
-inline void QOpenGLFunctions_1_3::glLoadMatrixf(const GLfloat *m)
-{
-    d_1_0_Deprecated->f.LoadMatrixf(m);
-}
-
-inline void QOpenGLFunctions_1_3::glLoadIdentity()
-{
-    d_1_0_Deprecated->f.LoadIdentity();
-}
-
-inline void QOpenGLFunctions_1_3::glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
-{
-    d_1_0_Deprecated->f.Frustum(left, right, bottom, top, zNear, zFar);
-}
-
-inline GLboolean QOpenGLFunctions_1_3::glIsList(GLuint list)
-{
-    return d_1_0_Deprecated->f.IsList(list);
-}
-
-inline void QOpenGLFunctions_1_3::glGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetTexGeniv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_1_3::glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetTexGenfv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_1_3::glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
-{
-    d_1_0_Deprecated->f.GetTexGendv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_1_3::glGetTexEnviv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetTexEnviv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_3::glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetTexEnvfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_3::glGetPolygonStipple(GLubyte *mask)
-{
-    d_1_0_Deprecated->f.GetPolygonStipple(mask);
-}
-
-inline void QOpenGLFunctions_1_3::glGetPixelMapusv(GLenum map, GLushort *values)
-{
-    d_1_0_Deprecated->f.GetPixelMapusv(map, values);
-}
-
-inline void QOpenGLFunctions_1_3::glGetPixelMapuiv(GLenum map, GLuint *values)
-{
-    d_1_0_Deprecated->f.GetPixelMapuiv(map, values);
-}
-
-inline void QOpenGLFunctions_1_3::glGetPixelMapfv(GLenum map, GLfloat *values)
-{
-    d_1_0_Deprecated->f.GetPixelMapfv(map, values);
-}
-
-inline void QOpenGLFunctions_1_3::glGetMaterialiv(GLenum face, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetMaterialiv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_1_3::glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetMaterialfv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_1_3::glGetMapiv(GLenum target, GLenum query, GLint *v)
-{
-    d_1_0_Deprecated->f.GetMapiv(target, query, v);
-}
-
-inline void QOpenGLFunctions_1_3::glGetMapfv(GLenum target, GLenum query, GLfloat *v)
-{
-    d_1_0_Deprecated->f.GetMapfv(target, query, v);
-}
-
-inline void QOpenGLFunctions_1_3::glGetMapdv(GLenum target, GLenum query, GLdouble *v)
-{
-    d_1_0_Deprecated->f.GetMapdv(target, query, v);
-}
-
-inline void QOpenGLFunctions_1_3::glGetLightiv(GLenum light, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetLightiv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_1_3::glGetLightfv(GLenum light, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetLightfv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_1_3::glGetClipPlane(GLenum plane, GLdouble *equation)
-{
-    d_1_0_Deprecated->f.GetClipPlane(plane, equation);
-}
-
-inline void QOpenGLFunctions_1_3::glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Deprecated->f.DrawPixels(width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_1_3::glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
-{
-    d_1_0_Deprecated->f.CopyPixels(x, y, width, height, type);
-}
-
-inline void QOpenGLFunctions_1_3::glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values)
-{
-    d_1_0_Deprecated->f.PixelMapusv(map, mapsize, values);
-}
-
-inline void QOpenGLFunctions_1_3::glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values)
-{
-    d_1_0_Deprecated->f.PixelMapuiv(map, mapsize, values);
-}
-
-inline void QOpenGLFunctions_1_3::glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values)
-{
-    d_1_0_Deprecated->f.PixelMapfv(map, mapsize, values);
-}
-
-inline void QOpenGLFunctions_1_3::glPixelTransferi(GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.PixelTransferi(pname, param);
-}
-
-inline void QOpenGLFunctions_1_3::glPixelTransferf(GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.PixelTransferf(pname, param);
-}
-
-inline void QOpenGLFunctions_1_3::glPixelZoom(GLfloat xfactor, GLfloat yfactor)
-{
-    d_1_0_Deprecated->f.PixelZoom(xfactor, yfactor);
-}
-
-inline void QOpenGLFunctions_1_3::glAlphaFunc(GLenum func, GLfloat ref)
-{
-    d_1_0_Deprecated->f.AlphaFunc(func, ref);
-}
-
-inline void QOpenGLFunctions_1_3::glEvalPoint2(GLint i, GLint j)
-{
-    d_1_0_Deprecated->f.EvalPoint2(i, j);
-}
-
-inline void QOpenGLFunctions_1_3::glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
-{
-    d_1_0_Deprecated->f.EvalMesh2(mode, i1, i2, j1, j2);
-}
-
-inline void QOpenGLFunctions_1_3::glEvalPoint1(GLint i)
-{
-    d_1_0_Deprecated->f.EvalPoint1(i);
-}
-
-inline void QOpenGLFunctions_1_3::glEvalMesh1(GLenum mode, GLint i1, GLint i2)
-{
-    d_1_0_Deprecated->f.EvalMesh1(mode, i1, i2);
-}
-
-inline void QOpenGLFunctions_1_3::glEvalCoord2fv(const GLfloat *u)
-{
-    d_1_0_Deprecated->f.EvalCoord2fv(u);
-}
-
-inline void QOpenGLFunctions_1_3::glEvalCoord2f(GLfloat u, GLfloat v)
-{
-    d_1_0_Deprecated->f.EvalCoord2f(u, v);
-}
-
-inline void QOpenGLFunctions_1_3::glEvalCoord2dv(const GLdouble *u)
-{
-    d_1_0_Deprecated->f.EvalCoord2dv(u);
-}
-
-inline void QOpenGLFunctions_1_3::glEvalCoord2d(GLdouble u, GLdouble v)
-{
-    d_1_0_Deprecated->f.EvalCoord2d(u, v);
-}
-
-inline void QOpenGLFunctions_1_3::glEvalCoord1fv(const GLfloat *u)
-{
-    d_1_0_Deprecated->f.EvalCoord1fv(u);
-}
-
-inline void QOpenGLFunctions_1_3::glEvalCoord1f(GLfloat u)
-{
-    d_1_0_Deprecated->f.EvalCoord1f(u);
-}
-
-inline void QOpenGLFunctions_1_3::glEvalCoord1dv(const GLdouble *u)
-{
-    d_1_0_Deprecated->f.EvalCoord1dv(u);
-}
-
-inline void QOpenGLFunctions_1_3::glEvalCoord1d(GLdouble u)
-{
-    d_1_0_Deprecated->f.EvalCoord1d(u);
-}
-
-inline void QOpenGLFunctions_1_3::glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
-{
-    d_1_0_Deprecated->f.MapGrid2f(un, u1, u2, vn, v1, v2);
-}
-
-inline void QOpenGLFunctions_1_3::glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
-{
-    d_1_0_Deprecated->f.MapGrid2d(un, u1, u2, vn, v1, v2);
-}
-
-inline void QOpenGLFunctions_1_3::glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
-{
-    d_1_0_Deprecated->f.MapGrid1f(un, u1, u2);
-}
-
-inline void QOpenGLFunctions_1_3::glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
-{
-    d_1_0_Deprecated->f.MapGrid1d(un, u1, u2);
-}
-
-inline void QOpenGLFunctions_1_3::glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
-{
-    d_1_0_Deprecated->f.Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
-}
-
-inline void QOpenGLFunctions_1_3::glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
-{
-    d_1_0_Deprecated->f.Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
-}
-
-inline void QOpenGLFunctions_1_3::glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
-{
-    d_1_0_Deprecated->f.Map1f(target, u1, u2, stride, order, points);
-}
-
-inline void QOpenGLFunctions_1_3::glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
-{
-    d_1_0_Deprecated->f.Map1d(target, u1, u2, stride, order, points);
-}
-
-inline void QOpenGLFunctions_1_3::glPushAttrib(GLbitfield mask)
-{
-    d_1_0_Deprecated->f.PushAttrib(mask);
-}
-
-inline void QOpenGLFunctions_1_3::glPopAttrib()
-{
-    d_1_0_Deprecated->f.PopAttrib();
-}
-
-inline void QOpenGLFunctions_1_3::glAccum(GLenum op, GLfloat value)
-{
-    d_1_0_Deprecated->f.Accum(op, value);
-}
-
-inline void QOpenGLFunctions_1_3::glIndexMask(GLuint mask)
-{
-    d_1_0_Deprecated->f.IndexMask(mask);
-}
-
-inline void QOpenGLFunctions_1_3::glClearIndex(GLfloat c)
-{
-    d_1_0_Deprecated->f.ClearIndex(c);
-}
-
-inline void QOpenGLFunctions_1_3::glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Deprecated->f.ClearAccum(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_3::glPushName(GLuint name)
-{
-    d_1_0_Deprecated->f.PushName(name);
-}
-
-inline void QOpenGLFunctions_1_3::glPopName()
-{
-    d_1_0_Deprecated->f.PopName();
-}
-
-inline void QOpenGLFunctions_1_3::glPassThrough(GLfloat token)
-{
-    d_1_0_Deprecated->f.PassThrough(token);
-}
-
-inline void QOpenGLFunctions_1_3::glLoadName(GLuint name)
-{
-    d_1_0_Deprecated->f.LoadName(name);
-}
-
-inline void QOpenGLFunctions_1_3::glInitNames()
-{
-    d_1_0_Deprecated->f.InitNames();
-}
-
-inline GLint QOpenGLFunctions_1_3::glRenderMode(GLenum mode)
-{
-    return d_1_0_Deprecated->f.RenderMode(mode);
-}
-
-inline void QOpenGLFunctions_1_3::glSelectBuffer(GLsizei size, GLuint *buffer)
-{
-    d_1_0_Deprecated->f.SelectBuffer(size, buffer);
-}
-
-inline void QOpenGLFunctions_1_3::glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
-{
-    d_1_0_Deprecated->f.FeedbackBuffer(size, type, buffer);
-}
-
-inline void QOpenGLFunctions_1_3::glTexGeniv(GLenum coord, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.TexGeniv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_1_3::glTexGeni(GLenum coord, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.TexGeni(coord, pname, param);
-}
-
-inline void QOpenGLFunctions_1_3::glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.TexGenfv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_1_3::glTexGenf(GLenum coord, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.TexGenf(coord, pname, param);
-}
-
-inline void QOpenGLFunctions_1_3::glTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
-{
-    d_1_0_Deprecated->f.TexGendv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_1_3::glTexGend(GLenum coord, GLenum pname, GLdouble param)
-{
-    d_1_0_Deprecated->f.TexGend(coord, pname, param);
-}
-
-inline void QOpenGLFunctions_1_3::glTexEnviv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.TexEnviv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_3::glTexEnvi(GLenum target, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.TexEnvi(target, pname, param);
-}
-
-inline void QOpenGLFunctions_1_3::glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.TexEnvfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_3::glTexEnvf(GLenum target, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.TexEnvf(target, pname, param);
-}
-
-inline void QOpenGLFunctions_1_3::glShadeModel(GLenum mode)
-{
-    d_1_0_Deprecated->f.ShadeModel(mode);
-}
-
-inline void QOpenGLFunctions_1_3::glPolygonStipple(const GLubyte *mask)
-{
-    d_1_0_Deprecated->f.PolygonStipple(mask);
-}
-
-inline void QOpenGLFunctions_1_3::glMaterialiv(GLenum face, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.Materialiv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_1_3::glMateriali(GLenum face, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.Materiali(face, pname, param);
-}
-
-inline void QOpenGLFunctions_1_3::glMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.Materialfv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_1_3::glMaterialf(GLenum face, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.Materialf(face, pname, param);
-}
-
-inline void QOpenGLFunctions_1_3::glLineStipple(GLint factor, GLushort pattern)
-{
-    d_1_0_Deprecated->f.LineStipple(factor, pattern);
-}
-
-inline void QOpenGLFunctions_1_3::glLightModeliv(GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.LightModeliv(pname, params);
-}
-
-inline void QOpenGLFunctions_1_3::glLightModeli(GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.LightModeli(pname, param);
-}
-
-inline void QOpenGLFunctions_1_3::glLightModelfv(GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.LightModelfv(pname, params);
-}
-
-inline void QOpenGLFunctions_1_3::glLightModelf(GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.LightModelf(pname, param);
-}
-
-inline void QOpenGLFunctions_1_3::glLightiv(GLenum light, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.Lightiv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_1_3::glLighti(GLenum light, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.Lighti(light, pname, param);
-}
-
-inline void QOpenGLFunctions_1_3::glLightfv(GLenum light, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.Lightfv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_1_3::glLightf(GLenum light, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.Lightf(light, pname, param);
-}
-
-inline void QOpenGLFunctions_1_3::glFogiv(GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.Fogiv(pname, params);
-}
-
-inline void QOpenGLFunctions_1_3::glFogi(GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.Fogi(pname, param);
-}
-
-inline void QOpenGLFunctions_1_3::glFogfv(GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.Fogfv(pname, params);
-}
-
-inline void QOpenGLFunctions_1_3::glFogf(GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.Fogf(pname, param);
-}
-
-inline void QOpenGLFunctions_1_3::glColorMaterial(GLenum face, GLenum mode)
-{
-    d_1_0_Deprecated->f.ColorMaterial(face, mode);
-}
-
-inline void QOpenGLFunctions_1_3::glClipPlane(GLenum plane, const GLdouble *equation)
-{
-    d_1_0_Deprecated->f.ClipPlane(plane, equation);
-}
-
-inline void QOpenGLFunctions_1_3::glVertex4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Vertex4sv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
-{
-    d_1_0_Deprecated->f.Vertex4s(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_1_3::glVertex4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Vertex4iv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glVertex4i(GLint x, GLint y, GLint z, GLint w)
-{
-    d_1_0_Deprecated->f.Vertex4i(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_1_3::glVertex4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Vertex4fv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    d_1_0_Deprecated->f.Vertex4f(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_1_3::glVertex4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Vertex4dv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_1_0_Deprecated->f.Vertex4d(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_1_3::glVertex3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Vertex3sv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glVertex3s(GLshort x, GLshort y, GLshort z)
-{
-    d_1_0_Deprecated->f.Vertex3s(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_3::glVertex3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Vertex3iv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glVertex3i(GLint x, GLint y, GLint z)
-{
-    d_1_0_Deprecated->f.Vertex3i(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_3::glVertex3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Vertex3fv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glVertex3f(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Vertex3f(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_3::glVertex3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Vertex3dv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glVertex3d(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Vertex3d(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_3::glVertex2sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Vertex2sv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glVertex2s(GLshort x, GLshort y)
-{
-    d_1_0_Deprecated->f.Vertex2s(x, y);
-}
-
-inline void QOpenGLFunctions_1_3::glVertex2iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Vertex2iv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glVertex2i(GLint x, GLint y)
-{
-    d_1_0_Deprecated->f.Vertex2i(x, y);
-}
-
-inline void QOpenGLFunctions_1_3::glVertex2fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Vertex2fv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glVertex2f(GLfloat x, GLfloat y)
-{
-    d_1_0_Deprecated->f.Vertex2f(x, y);
-}
-
-inline void QOpenGLFunctions_1_3::glVertex2dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Vertex2dv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glVertex2d(GLdouble x, GLdouble y)
-{
-    d_1_0_Deprecated->f.Vertex2d(x, y);
-}
-
-inline void QOpenGLFunctions_1_3::glTexCoord4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord4sv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
-{
-    d_1_0_Deprecated->f.TexCoord4s(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_1_3::glTexCoord4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord4iv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
-{
-    d_1_0_Deprecated->f.TexCoord4i(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_1_3::glTexCoord4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord4fv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
-{
-    d_1_0_Deprecated->f.TexCoord4f(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_1_3::glTexCoord4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord4dv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
-{
-    d_1_0_Deprecated->f.TexCoord4d(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_1_3::glTexCoord3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord3sv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glTexCoord3s(GLshort s, GLshort t, GLshort r)
-{
-    d_1_0_Deprecated->f.TexCoord3s(s, t, r);
-}
-
-inline void QOpenGLFunctions_1_3::glTexCoord3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord3iv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glTexCoord3i(GLint s, GLint t, GLint r)
-{
-    d_1_0_Deprecated->f.TexCoord3i(s, t, r);
-}
-
-inline void QOpenGLFunctions_1_3::glTexCoord3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord3fv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
-{
-    d_1_0_Deprecated->f.TexCoord3f(s, t, r);
-}
-
-inline void QOpenGLFunctions_1_3::glTexCoord3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord3dv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
-{
-    d_1_0_Deprecated->f.TexCoord3d(s, t, r);
-}
-
-inline void QOpenGLFunctions_1_3::glTexCoord2sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord2sv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glTexCoord2s(GLshort s, GLshort t)
-{
-    d_1_0_Deprecated->f.TexCoord2s(s, t);
-}
-
-inline void QOpenGLFunctions_1_3::glTexCoord2iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord2iv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glTexCoord2i(GLint s, GLint t)
-{
-    d_1_0_Deprecated->f.TexCoord2i(s, t);
-}
-
-inline void QOpenGLFunctions_1_3::glTexCoord2fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord2fv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glTexCoord2f(GLfloat s, GLfloat t)
-{
-    d_1_0_Deprecated->f.TexCoord2f(s, t);
-}
-
-inline void QOpenGLFunctions_1_3::glTexCoord2dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord2dv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glTexCoord2d(GLdouble s, GLdouble t)
-{
-    d_1_0_Deprecated->f.TexCoord2d(s, t);
-}
-
-inline void QOpenGLFunctions_1_3::glTexCoord1sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord1sv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glTexCoord1s(GLshort s)
-{
-    d_1_0_Deprecated->f.TexCoord1s(s);
-}
-
-inline void QOpenGLFunctions_1_3::glTexCoord1iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord1iv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glTexCoord1i(GLint s)
-{
-    d_1_0_Deprecated->f.TexCoord1i(s);
-}
-
-inline void QOpenGLFunctions_1_3::glTexCoord1fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord1fv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glTexCoord1f(GLfloat s)
-{
-    d_1_0_Deprecated->f.TexCoord1f(s);
-}
-
-inline void QOpenGLFunctions_1_3::glTexCoord1dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord1dv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glTexCoord1d(GLdouble s)
-{
-    d_1_0_Deprecated->f.TexCoord1d(s);
-}
-
-inline void QOpenGLFunctions_1_3::glRectsv(const GLshort *v1, const GLshort *v2)
-{
-    d_1_0_Deprecated->f.Rectsv(v1, v2);
-}
-
-inline void QOpenGLFunctions_1_3::glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
-{
-    d_1_0_Deprecated->f.Rects(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_1_3::glRectiv(const GLint *v1, const GLint *v2)
-{
-    d_1_0_Deprecated->f.Rectiv(v1, v2);
-}
-
-inline void QOpenGLFunctions_1_3::glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
-{
-    d_1_0_Deprecated->f.Recti(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_1_3::glRectfv(const GLfloat *v1, const GLfloat *v2)
-{
-    d_1_0_Deprecated->f.Rectfv(v1, v2);
-}
-
-inline void QOpenGLFunctions_1_3::glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
-{
-    d_1_0_Deprecated->f.Rectf(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_1_3::glRectdv(const GLdouble *v1, const GLdouble *v2)
-{
-    d_1_0_Deprecated->f.Rectdv(v1, v2);
-}
-
-inline void QOpenGLFunctions_1_3::glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
-{
-    d_1_0_Deprecated->f.Rectd(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_1_3::glRasterPos4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.RasterPos4sv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
-{
-    d_1_0_Deprecated->f.RasterPos4s(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_1_3::glRasterPos4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.RasterPos4iv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
-{
-    d_1_0_Deprecated->f.RasterPos4i(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_1_3::glRasterPos4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.RasterPos4fv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    d_1_0_Deprecated->f.RasterPos4f(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_1_3::glRasterPos4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.RasterPos4dv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_1_0_Deprecated->f.RasterPos4d(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_1_3::glRasterPos3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.RasterPos3sv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glRasterPos3s(GLshort x, GLshort y, GLshort z)
-{
-    d_1_0_Deprecated->f.RasterPos3s(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_3::glRasterPos3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.RasterPos3iv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glRasterPos3i(GLint x, GLint y, GLint z)
-{
-    d_1_0_Deprecated->f.RasterPos3i(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_3::glRasterPos3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.RasterPos3fv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.RasterPos3f(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_3::glRasterPos3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.RasterPos3dv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.RasterPos3d(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_3::glRasterPos2sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.RasterPos2sv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glRasterPos2s(GLshort x, GLshort y)
-{
-    d_1_0_Deprecated->f.RasterPos2s(x, y);
-}
-
-inline void QOpenGLFunctions_1_3::glRasterPos2iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.RasterPos2iv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glRasterPos2i(GLint x, GLint y)
-{
-    d_1_0_Deprecated->f.RasterPos2i(x, y);
-}
-
-inline void QOpenGLFunctions_1_3::glRasterPos2fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.RasterPos2fv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glRasterPos2f(GLfloat x, GLfloat y)
-{
-    d_1_0_Deprecated->f.RasterPos2f(x, y);
-}
-
-inline void QOpenGLFunctions_1_3::glRasterPos2dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.RasterPos2dv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glRasterPos2d(GLdouble x, GLdouble y)
-{
-    d_1_0_Deprecated->f.RasterPos2d(x, y);
-}
-
-inline void QOpenGLFunctions_1_3::glNormal3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Normal3sv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glNormal3s(GLshort nx, GLshort ny, GLshort nz)
-{
-    d_1_0_Deprecated->f.Normal3s(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_1_3::glNormal3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Normal3iv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glNormal3i(GLint nx, GLint ny, GLint nz)
-{
-    d_1_0_Deprecated->f.Normal3i(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_1_3::glNormal3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Normal3fv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
-{
-    d_1_0_Deprecated->f.Normal3f(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_1_3::glNormal3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Normal3dv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
-{
-    d_1_0_Deprecated->f.Normal3d(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_1_3::glNormal3bv(const GLbyte *v)
-{
-    d_1_0_Deprecated->f.Normal3bv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
-{
-    d_1_0_Deprecated->f.Normal3b(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_1_3::glIndexsv(const GLshort *c)
-{
-    d_1_0_Deprecated->f.Indexsv(c);
-}
-
-inline void QOpenGLFunctions_1_3::glIndexs(GLshort c)
-{
-    d_1_0_Deprecated->f.Indexs(c);
-}
-
-inline void QOpenGLFunctions_1_3::glIndexiv(const GLint *c)
-{
-    d_1_0_Deprecated->f.Indexiv(c);
-}
-
-inline void QOpenGLFunctions_1_3::glIndexi(GLint c)
-{
-    d_1_0_Deprecated->f.Indexi(c);
-}
-
-inline void QOpenGLFunctions_1_3::glIndexfv(const GLfloat *c)
-{
-    d_1_0_Deprecated->f.Indexfv(c);
-}
-
-inline void QOpenGLFunctions_1_3::glIndexf(GLfloat c)
-{
-    d_1_0_Deprecated->f.Indexf(c);
-}
-
-inline void QOpenGLFunctions_1_3::glIndexdv(const GLdouble *c)
-{
-    d_1_0_Deprecated->f.Indexdv(c);
-}
-
-inline void QOpenGLFunctions_1_3::glIndexd(GLdouble c)
-{
-    d_1_0_Deprecated->f.Indexd(c);
-}
-
-inline void QOpenGLFunctions_1_3::glEnd()
-{
-    d_1_0_Deprecated->f.End();
-}
-
-inline void QOpenGLFunctions_1_3::glEdgeFlagv(const GLboolean *flag)
-{
-    d_1_0_Deprecated->f.EdgeFlagv(flag);
-}
-
-inline void QOpenGLFunctions_1_3::glEdgeFlag(GLboolean flag)
-{
-    d_1_0_Deprecated->f.EdgeFlag(flag);
-}
-
-inline void QOpenGLFunctions_1_3::glColor4usv(const GLushort *v)
-{
-    d_1_0_Deprecated->f.Color4usv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
-{
-    d_1_0_Deprecated->f.Color4us(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_3::glColor4uiv(const GLuint *v)
-{
-    d_1_0_Deprecated->f.Color4uiv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
-{
-    d_1_0_Deprecated->f.Color4ui(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_3::glColor4ubv(const GLubyte *v)
-{
-    d_1_0_Deprecated->f.Color4ubv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
-{
-    d_1_0_Deprecated->f.Color4ub(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_3::glColor4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Color4sv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
-{
-    d_1_0_Deprecated->f.Color4s(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_3::glColor4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Color4iv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
-{
-    d_1_0_Deprecated->f.Color4i(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_3::glColor4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Color4fv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Deprecated->f.Color4f(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_3::glColor4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Color4dv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
-{
-    d_1_0_Deprecated->f.Color4d(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_3::glColor4bv(const GLbyte *v)
-{
-    d_1_0_Deprecated->f.Color4bv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
-{
-    d_1_0_Deprecated->f.Color4b(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_3::glColor3usv(const GLushort *v)
-{
-    d_1_0_Deprecated->f.Color3usv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glColor3us(GLushort red, GLushort green, GLushort blue)
-{
-    d_1_0_Deprecated->f.Color3us(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_3::glColor3uiv(const GLuint *v)
-{
-    d_1_0_Deprecated->f.Color3uiv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glColor3ui(GLuint red, GLuint green, GLuint blue)
-{
-    d_1_0_Deprecated->f.Color3ui(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_3::glColor3ubv(const GLubyte *v)
-{
-    d_1_0_Deprecated->f.Color3ubv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
-{
-    d_1_0_Deprecated->f.Color3ub(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_3::glColor3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Color3sv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glColor3s(GLshort red, GLshort green, GLshort blue)
-{
-    d_1_0_Deprecated->f.Color3s(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_3::glColor3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Color3iv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glColor3i(GLint red, GLint green, GLint blue)
-{
-    d_1_0_Deprecated->f.Color3i(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_3::glColor3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Color3fv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glColor3f(GLfloat red, GLfloat green, GLfloat blue)
-{
-    d_1_0_Deprecated->f.Color3f(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_3::glColor3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Color3dv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glColor3d(GLdouble red, GLdouble green, GLdouble blue)
-{
-    d_1_0_Deprecated->f.Color3d(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_3::glColor3bv(const GLbyte *v)
-{
-    d_1_0_Deprecated->f.Color3bv(v);
-}
-
-inline void QOpenGLFunctions_1_3::glColor3b(GLbyte red, GLbyte green, GLbyte blue)
-{
-    d_1_0_Deprecated->f.Color3b(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_3::glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
-{
-    d_1_0_Deprecated->f.Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
-}
-
-inline void QOpenGLFunctions_1_3::glBegin(GLenum mode)
-{
-    d_1_0_Deprecated->f.Begin(mode);
-}
-
-inline void QOpenGLFunctions_1_3::glListBase(GLuint base)
-{
-    d_1_0_Deprecated->f.ListBase(base);
-}
-
-inline GLuint QOpenGLFunctions_1_3::glGenLists(GLsizei range)
-{
-    return d_1_0_Deprecated->f.GenLists(range);
-}
-
-inline void QOpenGLFunctions_1_3::glDeleteLists(GLuint list, GLsizei range)
-{
-    d_1_0_Deprecated->f.DeleteLists(list, range);
-}
-
-inline void QOpenGLFunctions_1_3::glCallLists(GLsizei n, GLenum type, const GLvoid *lists)
-{
-    d_1_0_Deprecated->f.CallLists(n, type, lists);
-}
-
-inline void QOpenGLFunctions_1_3::glCallList(GLuint list)
-{
-    d_1_0_Deprecated->f.CallList(list);
-}
-
-inline void QOpenGLFunctions_1_3::glEndList()
-{
-    d_1_0_Deprecated->f.EndList();
-}
-
-inline void QOpenGLFunctions_1_3::glNewList(GLuint list, GLenum mode)
-{
-    d_1_0_Deprecated->f.NewList(list, mode);
-}
-
-
-// OpenGL 1.1 deprecated functions
-inline void QOpenGLFunctions_1_3::glPushClientAttrib(GLbitfield mask)
-{
-    d_1_1_Deprecated->f.PushClientAttrib(mask);
-}
-
-inline void QOpenGLFunctions_1_3::glPopClientAttrib()
-{
-    d_1_1_Deprecated->f.PopClientAttrib();
-}
-
-inline void QOpenGLFunctions_1_3::glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities)
-{
-    d_1_1_Deprecated->f.PrioritizeTextures(n, textures, priorities);
-}
-
-inline GLboolean QOpenGLFunctions_1_3::glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
-{
-    return d_1_1_Deprecated->f.AreTexturesResident(n, textures, residences);
-}
-
-inline void QOpenGLFunctions_1_3::glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.VertexPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_1_3::glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.TexCoordPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_1_3::glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.NormalPointer(type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_1_3::glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.InterleavedArrays(format, stride, pointer);
-}
-
-inline void QOpenGLFunctions_1_3::glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.IndexPointer(type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_1_3::glEnableClientState(GLenum array)
-{
-    d_1_1_Deprecated->f.EnableClientState(array);
-}
-
-inline void QOpenGLFunctions_1_3::glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.EdgeFlagPointer(stride, pointer);
-}
-
-inline void QOpenGLFunctions_1_3::glDisableClientState(GLenum array)
-{
-    d_1_1_Deprecated->f.DisableClientState(array);
-}
-
-inline void QOpenGLFunctions_1_3::glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.ColorPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_1_3::glArrayElement(GLint i)
-{
-    d_1_1_Deprecated->f.ArrayElement(i);
-}
-
-
-// OpenGL 1.2 deprecated functions
-inline void QOpenGLFunctions_1_3::glResetMinmax(GLenum target)
-{
-    d_1_2_Deprecated->f.ResetMinmax(target);
-}
-
-inline void QOpenGLFunctions_1_3::glResetHistogram(GLenum target)
-{
-    d_1_2_Deprecated->f.ResetHistogram(target);
-}
-
-inline void QOpenGLFunctions_1_3::glMinmax(GLenum target, GLenum internalformat, GLboolean sink)
-{
-    d_1_2_Deprecated->f.Minmax(target, internalformat, sink);
-}
-
-inline void QOpenGLFunctions_1_3::glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
-{
-    d_1_2_Deprecated->f.Histogram(target, width, internalformat, sink);
-}
-
-inline void QOpenGLFunctions_1_3::glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetMinmaxParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_3::glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetMinmaxParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_3::glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
-{
-    d_1_2_Deprecated->f.GetMinmax(target, reset, format, type, values);
-}
-
-inline void QOpenGLFunctions_1_3::glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetHistogramParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_3::glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetHistogramParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_3::glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
-{
-    d_1_2_Deprecated->f.GetHistogram(target, reset, format, type, values);
-}
-
-inline void QOpenGLFunctions_1_3::glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column)
-{
-    d_1_2_Deprecated->f.SeparableFilter2D(target, internalformat, width, height, format, type, row, column);
-}
-
-inline void QOpenGLFunctions_1_3::glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span)
-{
-    d_1_2_Deprecated->f.GetSeparableFilter(target, format, type, row, column, span);
-}
-
-inline void QOpenGLFunctions_1_3::glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetConvolutionParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_3::glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetConvolutionParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_3::glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image)
-{
-    d_1_2_Deprecated->f.GetConvolutionFilter(target, format, type, image);
-}
-
-inline void QOpenGLFunctions_1_3::glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_2_Deprecated->f.CopyConvolutionFilter2D(target, internalformat, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_1_3::glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
-{
-    d_1_2_Deprecated->f.CopyConvolutionFilter1D(target, internalformat, x, y, width);
-}
-
-inline void QOpenGLFunctions_1_3::glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_3::glConvolutionParameteri(GLenum target, GLenum pname, GLint params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameteri(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_3::glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_3::glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameterf(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_3::glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image)
-{
-    d_1_2_Deprecated->f.ConvolutionFilter2D(target, internalformat, width, height, format, type, image);
-}
-
-inline void QOpenGLFunctions_1_3::glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image)
-{
-    d_1_2_Deprecated->f.ConvolutionFilter1D(target, internalformat, width, format, type, image);
-}
-
-inline void QOpenGLFunctions_1_3::glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
-{
-    d_1_2_Deprecated->f.CopyColorSubTable(target, start, x, y, width);
-}
-
-inline void QOpenGLFunctions_1_3::glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data)
-{
-    d_1_2_Deprecated->f.ColorSubTable(target, start, count, format, type, data);
-}
-
-inline void QOpenGLFunctions_1_3::glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetColorTableParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_3::glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetColorTableParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_3::glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table)
-{
-    d_1_2_Deprecated->f.GetColorTable(target, format, type, table);
-}
-
-inline void QOpenGLFunctions_1_3::glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
-{
-    d_1_2_Deprecated->f.CopyColorTable(target, internalformat, x, y, width);
-}
-
-inline void QOpenGLFunctions_1_3::glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_2_Deprecated->f.ColorTableParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_3::glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_2_Deprecated->f.ColorTableParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_3::glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table)
-{
-    d_1_2_Deprecated->f.ColorTable(target, internalformat, width, format, type, table);
-}
-
-
-// OpenGL 1.3 deprecated functions
-inline void QOpenGLFunctions_1_3::glMultTransposeMatrixd(const GLdouble *m)
-{
-    d_1_3_Deprecated->f.MultTransposeMatrixd(m);
-}
-
-inline void QOpenGLFunctions_1_3::glMultTransposeMatrixf(const GLfloat *m)
-{
-    d_1_3_Deprecated->f.MultTransposeMatrixf(m);
-}
-
-inline void QOpenGLFunctions_1_3::glLoadTransposeMatrixd(const GLdouble *m)
-{
-    d_1_3_Deprecated->f.LoadTransposeMatrixd(m);
-}
-
-inline void QOpenGLFunctions_1_3::glLoadTransposeMatrixf(const GLfloat *m)
-{
-    d_1_3_Deprecated->f.LoadTransposeMatrixf(m);
-}
-
-inline void QOpenGLFunctions_1_3::glMultiTexCoord4sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4sv(target, v);
-}
-
-inline void QOpenGLFunctions_1_3::glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4s(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_1_3::glMultiTexCoord4iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4iv(target, v);
-}
-
-inline void QOpenGLFunctions_1_3::glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4i(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_1_3::glMultiTexCoord4fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4fv(target, v);
-}
-
-inline void QOpenGLFunctions_1_3::glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4f(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_1_3::glMultiTexCoord4dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4dv(target, v);
-}
-
-inline void QOpenGLFunctions_1_3::glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4d(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_1_3::glMultiTexCoord3sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3sv(target, v);
-}
-
-inline void QOpenGLFunctions_1_3::glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3s(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_1_3::glMultiTexCoord3iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3iv(target, v);
-}
-
-inline void QOpenGLFunctions_1_3::glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3i(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_1_3::glMultiTexCoord3fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3fv(target, v);
-}
-
-inline void QOpenGLFunctions_1_3::glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3f(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_1_3::glMultiTexCoord3dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3dv(target, v);
-}
-
-inline void QOpenGLFunctions_1_3::glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3d(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_1_3::glMultiTexCoord2sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2sv(target, v);
-}
-
-inline void QOpenGLFunctions_1_3::glMultiTexCoord2s(GLenum target, GLshort s, GLshort t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2s(target, s, t);
-}
-
-inline void QOpenGLFunctions_1_3::glMultiTexCoord2iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2iv(target, v);
-}
-
-inline void QOpenGLFunctions_1_3::glMultiTexCoord2i(GLenum target, GLint s, GLint t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2i(target, s, t);
-}
-
-inline void QOpenGLFunctions_1_3::glMultiTexCoord2fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2fv(target, v);
-}
-
-inline void QOpenGLFunctions_1_3::glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2f(target, s, t);
-}
-
-inline void QOpenGLFunctions_1_3::glMultiTexCoord2dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2dv(target, v);
-}
-
-inline void QOpenGLFunctions_1_3::glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2d(target, s, t);
-}
-
-inline void QOpenGLFunctions_1_3::glMultiTexCoord1sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1sv(target, v);
-}
-
-inline void QOpenGLFunctions_1_3::glMultiTexCoord1s(GLenum target, GLshort s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1s(target, s);
-}
-
-inline void QOpenGLFunctions_1_3::glMultiTexCoord1iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1iv(target, v);
-}
-
-inline void QOpenGLFunctions_1_3::glMultiTexCoord1i(GLenum target, GLint s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1i(target, s);
-}
-
-inline void QOpenGLFunctions_1_3::glMultiTexCoord1fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1fv(target, v);
-}
-
-inline void QOpenGLFunctions_1_3::glMultiTexCoord1f(GLenum target, GLfloat s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1f(target, s);
-}
-
-inline void QOpenGLFunctions_1_3::glMultiTexCoord1dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1dv(target, v);
-}
-
-inline void QOpenGLFunctions_1_3::glMultiTexCoord1d(GLenum target, GLdouble s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1d(target, s);
-}
-
-inline void QOpenGLFunctions_1_3::glClientActiveTexture(GLenum texture)
-{
-    d_1_3_Deprecated->f.ClientActiveTexture(texture);
-}
-
-
-
-QT_END_NAMESPACE
-
-#endif // QT_NO_OPENGL && !QT_OPENGL_ES_2
-
-#endif
diff --git a/src/gui/opengl/qopenglfunctions_1_4.cpp b/src/gui/opengl/qopenglfunctions_1_4.cpp
deleted file mode 100644
index 9419c1aa85..0000000000
--- a/src/gui/opengl/qopenglfunctions_1_4.cpp
+++ /dev/null
@@ -1,208 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#include "qopenglfunctions_1_4.h"
-#include "qopenglcontext.h"
-
-QT_BEGIN_NAMESPACE
-
-/*!
-    \class QOpenGLFunctions_1_4
-    \inmodule QtGui
-    \since 5.1
-    \wrapper
-    \brief The QOpenGLFunctions_1_4 class provides all functions for OpenGL 1.4 specification.
-
-    This class is a wrapper for functions from OpenGL 1.4 specification.
-    See reference pages on \l {http://www.opengl.org/sdk/docs/}{opengl.org}
-    for function documentation.
-
-    \sa QAbstractOpenGLFunctions
-*/
-
-QOpenGLFunctions_1_4::QOpenGLFunctions_1_4()
- : QAbstractOpenGLFunctions()
- , d_1_0_Core(nullptr)
- , d_1_1_Core(nullptr)
- , d_1_2_Core(nullptr)
- , d_1_3_Core(nullptr)
- , d_1_4_Core(nullptr)
- , d_1_0_Deprecated(nullptr)
- , d_1_1_Deprecated(nullptr)
- , d_1_2_Deprecated(nullptr)
- , d_1_3_Deprecated(nullptr)
- , d_1_4_Deprecated(nullptr)
-{
-}
-
-QOpenGLFunctions_1_4::~QOpenGLFunctions_1_4()
-{
-    if (d_1_0_Core) {
-        d_1_0_Core->refs.deref();
-        Q_ASSERT(d_1_0_Core->refs.loadRelaxed());
-    }
-    if (d_1_1_Core) {
-        d_1_1_Core->refs.deref();
-        Q_ASSERT(d_1_1_Core->refs.loadRelaxed());
-    }
-    if (d_1_2_Core) {
-        d_1_2_Core->refs.deref();
-        Q_ASSERT(d_1_2_Core->refs.loadRelaxed());
-    }
-    if (d_1_3_Core) {
-        d_1_3_Core->refs.deref();
-        Q_ASSERT(d_1_3_Core->refs.loadRelaxed());
-    }
-    if (d_1_4_Core) {
-        d_1_4_Core->refs.deref();
-        Q_ASSERT(d_1_4_Core->refs.loadRelaxed());
-    }
-    if (d_1_0_Deprecated) {
-        d_1_0_Deprecated->refs.deref();
-        Q_ASSERT(d_1_0_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_1_Deprecated) {
-        d_1_1_Deprecated->refs.deref();
-        Q_ASSERT(d_1_1_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_2_Deprecated) {
-        d_1_2_Deprecated->refs.deref();
-        Q_ASSERT(d_1_2_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_3_Deprecated) {
-        d_1_3_Deprecated->refs.deref();
-        Q_ASSERT(d_1_3_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_4_Deprecated) {
-        d_1_4_Deprecated->refs.deref();
-        Q_ASSERT(d_1_4_Deprecated->refs.loadRelaxed());
-    }
-}
-
-bool QOpenGLFunctions_1_4::initializeOpenGLFunctions()
-{
-    if ( isInitialized() )
-        return true;
-
-    QOpenGLContext* context = QOpenGLContext::currentContext();
-
-    // If owned by a context object make sure it is current.
-    // Also check that current context is capable of resolving all needed functions
-    if (((owningContext() && owningContext() == context) || !owningContext())
-        && QOpenGLFunctions_1_4::isContextCompatible(context))
-    {
-        // Associate with private implementation, creating if necessary
-        // Function pointers in the backends are resolved at creation time
-        QOpenGLVersionFunctionsBackend* d = nullptr;
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        d_1_3_Core = static_cast<QOpenGLFunctions_1_3_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        d_1_4_Core = static_cast<QOpenGLFunctions_1_4_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
-        d_1_0_Deprecated = static_cast<QOpenGLFunctions_1_0_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
-        d_1_1_Deprecated = static_cast<QOpenGLFunctions_1_1_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus());
-        d_1_2_Deprecated = static_cast<QOpenGLFunctions_1_2_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus());
-        d_1_3_Deprecated = static_cast<QOpenGLFunctions_1_3_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
-        d_1_4_Deprecated = static_cast<QOpenGLFunctions_1_4_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        QAbstractOpenGLFunctions::initializeOpenGLFunctions();
-    }
-    return isInitialized();
-}
-
-bool QOpenGLFunctions_1_4::isContextCompatible(QOpenGLContext *context)
-{
-    Q_ASSERT(context);
-    QSurfaceFormat f = context->format();
-    const QPair<int, int> v = qMakePair(f.majorVersion(), f.minorVersion());
-    if (v < qMakePair(1, 4))
-        return false;
-
-    if (f.profile() == QSurfaceFormat::CoreProfile)
-        return false;
-
-    return true;
-}
-
-QOpenGLVersionProfile QOpenGLFunctions_1_4::versionProfile()
-{
-    QOpenGLVersionProfile v;
-    v.setVersion(1, 4);
-    return v;
-}
-
-QT_END_NAMESPACE
diff --git a/src/gui/opengl/qopenglfunctions_1_4.h b/src/gui/opengl/qopenglfunctions_1_4.h
deleted file mode 100644
index 1f3f5a9c0a..0000000000
--- a/src/gui/opengl/qopenglfunctions_1_4.h
+++ /dev/null
@@ -1,2923 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#ifndef QOPENGLVERSIONFUNCTIONS_1_4_H
-#define QOPENGLVERSIONFUNCTIONS_1_4_H
-
-#include <QtGui/qtguiglobal.h>
-
-#if !defined(QT_NO_OPENGL) && !defined(QT_OPENGL_ES_2)
-
-#include <QtGui/QOpenGLVersionFunctions>
-#include <QtGui/qopenglcontext.h>
-
-QT_BEGIN_NAMESPACE
-
-class Q_GUI_EXPORT QOpenGLFunctions_1_4 : public QAbstractOpenGLFunctions
-{
-public:
-    QOpenGLFunctions_1_4();
-    ~QOpenGLFunctions_1_4();
-
-    bool initializeOpenGLFunctions() override;
-
-    // OpenGL 1.0 core functions
-    void glViewport(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glDepthRange(GLdouble nearVal, GLdouble farVal);
-    GLboolean glIsEnabled(GLenum cap);
-    void glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params);
-    void glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params);
-    void glGetTexParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
-    const GLubyte * glGetString(GLenum name);
-    void glGetIntegerv(GLenum pname, GLint *params);
-    void glGetFloatv(GLenum pname, GLfloat *params);
-    GLenum glGetError();
-    void glGetDoublev(GLenum pname, GLdouble *params);
-    void glGetBooleanv(GLenum pname, GLboolean *params);
-    void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
-    void glReadBuffer(GLenum mode);
-    void glPixelStorei(GLenum pname, GLint param);
-    void glPixelStoref(GLenum pname, GLfloat param);
-    void glDepthFunc(GLenum func);
-    void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass);
-    void glStencilFunc(GLenum func, GLint ref, GLuint mask);
-    void glLogicOp(GLenum opcode);
-    void glBlendFunc(GLenum sfactor, GLenum dfactor);
-    void glFlush();
-    void glFinish();
-    void glEnable(GLenum cap);
-    void glDisable(GLenum cap);
-    void glDepthMask(GLboolean flag);
-    void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
-    void glStencilMask(GLuint mask);
-    void glClearDepth(GLdouble depth);
-    void glClearStencil(GLint s);
-    void glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glClear(GLbitfield mask);
-    void glDrawBuffer(GLenum mode);
-    void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glTexParameteri(GLenum target, GLenum pname, GLint param);
-    void glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glTexParameterf(GLenum target, GLenum pname, GLfloat param);
-    void glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glPolygonMode(GLenum face, GLenum mode);
-    void glPointSize(GLfloat size);
-    void glLineWidth(GLfloat width);
-    void glHint(GLenum target, GLenum mode);
-    void glFrontFace(GLenum mode);
-    void glCullFace(GLenum mode);
-
-    // OpenGL 1.1 core functions
-    void glIndexubv(const GLubyte *c);
-    void glIndexub(GLubyte c);
-    GLboolean glIsTexture(GLuint texture);
-    void glGenTextures(GLsizei n, GLuint *textures);
-    void glDeleteTextures(GLsizei n, const GLuint *textures);
-    void glBindTexture(GLenum target, GLuint texture);
-    void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
-    void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
-    void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
-    void glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
-    void glPolygonOffset(GLfloat factor, GLfloat units);
-    void glGetPointerv(GLenum pname, GLvoid* *params);
-    void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
-    void glDrawArrays(GLenum mode, GLint first, GLsizei count);
-
-    // OpenGL 1.2 core functions
-    void glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices);
-    void glBlendEquation(GLenum mode);
-    void glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-
-    // OpenGL 1.3 core functions
-    void glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img);
-    void glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glSampleCoverage(GLfloat value, GLboolean invert);
-    void glActiveTexture(GLenum texture);
-
-    // OpenGL 1.4 core functions
-    void glPointParameteriv(GLenum pname, const GLint *params);
-    void glPointParameteri(GLenum pname, GLint param);
-    void glPointParameterfv(GLenum pname, const GLfloat *params);
-    void glPointParameterf(GLenum pname, GLfloat param);
-    void glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount);
-    void glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount);
-    void glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
-
-    // OpenGL 1.0 deprecated functions
-    void glTranslatef(GLfloat x, GLfloat y, GLfloat z);
-    void glTranslated(GLdouble x, GLdouble y, GLdouble z);
-    void glScalef(GLfloat x, GLfloat y, GLfloat z);
-    void glScaled(GLdouble x, GLdouble y, GLdouble z);
-    void glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
-    void glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
-    void glPushMatrix();
-    void glPopMatrix();
-    void glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
-    void glMultMatrixd(const GLdouble *m);
-    void glMultMatrixf(const GLfloat *m);
-    void glMatrixMode(GLenum mode);
-    void glLoadMatrixd(const GLdouble *m);
-    void glLoadMatrixf(const GLfloat *m);
-    void glLoadIdentity();
-    void glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
-    GLboolean glIsList(GLuint list);
-    void glGetTexGeniv(GLenum coord, GLenum pname, GLint *params);
-    void glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params);
-    void glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params);
-    void glGetTexEnviv(GLenum target, GLenum pname, GLint *params);
-    void glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetPolygonStipple(GLubyte *mask);
-    void glGetPixelMapusv(GLenum map, GLushort *values);
-    void glGetPixelMapuiv(GLenum map, GLuint *values);
-    void glGetPixelMapfv(GLenum map, GLfloat *values);
-    void glGetMaterialiv(GLenum face, GLenum pname, GLint *params);
-    void glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params);
-    void glGetMapiv(GLenum target, GLenum query, GLint *v);
-    void glGetMapfv(GLenum target, GLenum query, GLfloat *v);
-    void glGetMapdv(GLenum target, GLenum query, GLdouble *v);
-    void glGetLightiv(GLenum light, GLenum pname, GLint *params);
-    void glGetLightfv(GLenum light, GLenum pname, GLfloat *params);
-    void glGetClipPlane(GLenum plane, GLdouble *equation);
-    void glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
-    void glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
-    void glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values);
-    void glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values);
-    void glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values);
-    void glPixelTransferi(GLenum pname, GLint param);
-    void glPixelTransferf(GLenum pname, GLfloat param);
-    void glPixelZoom(GLfloat xfactor, GLfloat yfactor);
-    void glAlphaFunc(GLenum func, GLfloat ref);
-    void glEvalPoint2(GLint i, GLint j);
-    void glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
-    void glEvalPoint1(GLint i);
-    void glEvalMesh1(GLenum mode, GLint i1, GLint i2);
-    void glEvalCoord2fv(const GLfloat *u);
-    void glEvalCoord2f(GLfloat u, GLfloat v);
-    void glEvalCoord2dv(const GLdouble *u);
-    void glEvalCoord2d(GLdouble u, GLdouble v);
-    void glEvalCoord1fv(const GLfloat *u);
-    void glEvalCoord1f(GLfloat u);
-    void glEvalCoord1dv(const GLdouble *u);
-    void glEvalCoord1d(GLdouble u);
-    void glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
-    void glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
-    void glMapGrid1f(GLint un, GLfloat u1, GLfloat u2);
-    void glMapGrid1d(GLint un, GLdouble u1, GLdouble u2);
-    void glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);
-    void glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);
-    void glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);
-    void glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);
-    void glPushAttrib(GLbitfield mask);
-    void glPopAttrib();
-    void glAccum(GLenum op, GLfloat value);
-    void glIndexMask(GLuint mask);
-    void glClearIndex(GLfloat c);
-    void glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glPushName(GLuint name);
-    void glPopName();
-    void glPassThrough(GLfloat token);
-    void glLoadName(GLuint name);
-    void glInitNames();
-    GLint glRenderMode(GLenum mode);
-    void glSelectBuffer(GLsizei size, GLuint *buffer);
-    void glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer);
-    void glTexGeniv(GLenum coord, GLenum pname, const GLint *params);
-    void glTexGeni(GLenum coord, GLenum pname, GLint param);
-    void glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params);
-    void glTexGenf(GLenum coord, GLenum pname, GLfloat param);
-    void glTexGendv(GLenum coord, GLenum pname, const GLdouble *params);
-    void glTexGend(GLenum coord, GLenum pname, GLdouble param);
-    void glTexEnviv(GLenum target, GLenum pname, const GLint *params);
-    void glTexEnvi(GLenum target, GLenum pname, GLint param);
-    void glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glTexEnvf(GLenum target, GLenum pname, GLfloat param);
-    void glShadeModel(GLenum mode);
-    void glPolygonStipple(const GLubyte *mask);
-    void glMaterialiv(GLenum face, GLenum pname, const GLint *params);
-    void glMateriali(GLenum face, GLenum pname, GLint param);
-    void glMaterialfv(GLenum face, GLenum pname, const GLfloat *params);
-    void glMaterialf(GLenum face, GLenum pname, GLfloat param);
-    void glLineStipple(GLint factor, GLushort pattern);
-    void glLightModeliv(GLenum pname, const GLint *params);
-    void glLightModeli(GLenum pname, GLint param);
-    void glLightModelfv(GLenum pname, const GLfloat *params);
-    void glLightModelf(GLenum pname, GLfloat param);
-    void glLightiv(GLenum light, GLenum pname, const GLint *params);
-    void glLighti(GLenum light, GLenum pname, GLint param);
-    void glLightfv(GLenum light, GLenum pname, const GLfloat *params);
-    void glLightf(GLenum light, GLenum pname, GLfloat param);
-    void glFogiv(GLenum pname, const GLint *params);
-    void glFogi(GLenum pname, GLint param);
-    void glFogfv(GLenum pname, const GLfloat *params);
-    void glFogf(GLenum pname, GLfloat param);
-    void glColorMaterial(GLenum face, GLenum mode);
-    void glClipPlane(GLenum plane, const GLdouble *equation);
-    void glVertex4sv(const GLshort *v);
-    void glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w);
-    void glVertex4iv(const GLint *v);
-    void glVertex4i(GLint x, GLint y, GLint z, GLint w);
-    void glVertex4fv(const GLfloat *v);
-    void glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void glVertex4dv(const GLdouble *v);
-    void glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glVertex3sv(const GLshort *v);
-    void glVertex3s(GLshort x, GLshort y, GLshort z);
-    void glVertex3iv(const GLint *v);
-    void glVertex3i(GLint x, GLint y, GLint z);
-    void glVertex3fv(const GLfloat *v);
-    void glVertex3f(GLfloat x, GLfloat y, GLfloat z);
-    void glVertex3dv(const GLdouble *v);
-    void glVertex3d(GLdouble x, GLdouble y, GLdouble z);
-    void glVertex2sv(const GLshort *v);
-    void glVertex2s(GLshort x, GLshort y);
-    void glVertex2iv(const GLint *v);
-    void glVertex2i(GLint x, GLint y);
-    void glVertex2fv(const GLfloat *v);
-    void glVertex2f(GLfloat x, GLfloat y);
-    void glVertex2dv(const GLdouble *v);
-    void glVertex2d(GLdouble x, GLdouble y);
-    void glTexCoord4sv(const GLshort *v);
-    void glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q);
-    void glTexCoord4iv(const GLint *v);
-    void glTexCoord4i(GLint s, GLint t, GLint r, GLint q);
-    void glTexCoord4fv(const GLfloat *v);
-    void glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
-    void glTexCoord4dv(const GLdouble *v);
-    void glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q);
-    void glTexCoord3sv(const GLshort *v);
-    void glTexCoord3s(GLshort s, GLshort t, GLshort r);
-    void glTexCoord3iv(const GLint *v);
-    void glTexCoord3i(GLint s, GLint t, GLint r);
-    void glTexCoord3fv(const GLfloat *v);
-    void glTexCoord3f(GLfloat s, GLfloat t, GLfloat r);
-    void glTexCoord3dv(const GLdouble *v);
-    void glTexCoord3d(GLdouble s, GLdouble t, GLdouble r);
-    void glTexCoord2sv(const GLshort *v);
-    void glTexCoord2s(GLshort s, GLshort t);
-    void glTexCoord2iv(const GLint *v);
-    void glTexCoord2i(GLint s, GLint t);
-    void glTexCoord2fv(const GLfloat *v);
-    void glTexCoord2f(GLfloat s, GLfloat t);
-    void glTexCoord2dv(const GLdouble *v);
-    void glTexCoord2d(GLdouble s, GLdouble t);
-    void glTexCoord1sv(const GLshort *v);
-    void glTexCoord1s(GLshort s);
-    void glTexCoord1iv(const GLint *v);
-    void glTexCoord1i(GLint s);
-    void glTexCoord1fv(const GLfloat *v);
-    void glTexCoord1f(GLfloat s);
-    void glTexCoord1dv(const GLdouble *v);
-    void glTexCoord1d(GLdouble s);
-    void glRectsv(const GLshort *v1, const GLshort *v2);
-    void glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
-    void glRectiv(const GLint *v1, const GLint *v2);
-    void glRecti(GLint x1, GLint y1, GLint x2, GLint y2);
-    void glRectfv(const GLfloat *v1, const GLfloat *v2);
-    void glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
-    void glRectdv(const GLdouble *v1, const GLdouble *v2);
-    void glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
-    void glRasterPos4sv(const GLshort *v);
-    void glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w);
-    void glRasterPos4iv(const GLint *v);
-    void glRasterPos4i(GLint x, GLint y, GLint z, GLint w);
-    void glRasterPos4fv(const GLfloat *v);
-    void glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void glRasterPos4dv(const GLdouble *v);
-    void glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glRasterPos3sv(const GLshort *v);
-    void glRasterPos3s(GLshort x, GLshort y, GLshort z);
-    void glRasterPos3iv(const GLint *v);
-    void glRasterPos3i(GLint x, GLint y, GLint z);
-    void glRasterPos3fv(const GLfloat *v);
-    void glRasterPos3f(GLfloat x, GLfloat y, GLfloat z);
-    void glRasterPos3dv(const GLdouble *v);
-    void glRasterPos3d(GLdouble x, GLdouble y, GLdouble z);
-    void glRasterPos2sv(const GLshort *v);
-    void glRasterPos2s(GLshort x, GLshort y);
-    void glRasterPos2iv(const GLint *v);
-    void glRasterPos2i(GLint x, GLint y);
-    void glRasterPos2fv(const GLfloat *v);
-    void glRasterPos2f(GLfloat x, GLfloat y);
-    void glRasterPos2dv(const GLdouble *v);
-    void glRasterPos2d(GLdouble x, GLdouble y);
-    void glNormal3sv(const GLshort *v);
-    void glNormal3s(GLshort nx, GLshort ny, GLshort nz);
-    void glNormal3iv(const GLint *v);
-    void glNormal3i(GLint nx, GLint ny, GLint nz);
-    void glNormal3fv(const GLfloat *v);
-    void glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz);
-    void glNormal3dv(const GLdouble *v);
-    void glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz);
-    void glNormal3bv(const GLbyte *v);
-    void glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz);
-    void glIndexsv(const GLshort *c);
-    void glIndexs(GLshort c);
-    void glIndexiv(const GLint *c);
-    void glIndexi(GLint c);
-    void glIndexfv(const GLfloat *c);
-    void glIndexf(GLfloat c);
-    void glIndexdv(const GLdouble *c);
-    void glIndexd(GLdouble c);
-    void glEnd();
-    void glEdgeFlagv(const GLboolean *flag);
-    void glEdgeFlag(GLboolean flag);
-    void glColor4usv(const GLushort *v);
-    void glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha);
-    void glColor4uiv(const GLuint *v);
-    void glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha);
-    void glColor4ubv(const GLubyte *v);
-    void glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
-    void glColor4sv(const GLshort *v);
-    void glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha);
-    void glColor4iv(const GLint *v);
-    void glColor4i(GLint red, GLint green, GLint blue, GLint alpha);
-    void glColor4fv(const GLfloat *v);
-    void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glColor4dv(const GLdouble *v);
-    void glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
-    void glColor4bv(const GLbyte *v);
-    void glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
-    void glColor3usv(const GLushort *v);
-    void glColor3us(GLushort red, GLushort green, GLushort blue);
-    void glColor3uiv(const GLuint *v);
-    void glColor3ui(GLuint red, GLuint green, GLuint blue);
-    void glColor3ubv(const GLubyte *v);
-    void glColor3ub(GLubyte red, GLubyte green, GLubyte blue);
-    void glColor3sv(const GLshort *v);
-    void glColor3s(GLshort red, GLshort green, GLshort blue);
-    void glColor3iv(const GLint *v);
-    void glColor3i(GLint red, GLint green, GLint blue);
-    void glColor3fv(const GLfloat *v);
-    void glColor3f(GLfloat red, GLfloat green, GLfloat blue);
-    void glColor3dv(const GLdouble *v);
-    void glColor3d(GLdouble red, GLdouble green, GLdouble blue);
-    void glColor3bv(const GLbyte *v);
-    void glColor3b(GLbyte red, GLbyte green, GLbyte blue);
-    void glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap);
-    void glBegin(GLenum mode);
-    void glListBase(GLuint base);
-    GLuint glGenLists(GLsizei range);
-    void glDeleteLists(GLuint list, GLsizei range);
-    void glCallLists(GLsizei n, GLenum type, const GLvoid *lists);
-    void glCallList(GLuint list);
-    void glEndList();
-    void glNewList(GLuint list, GLenum mode);
-
-    // OpenGL 1.1 deprecated functions
-    void glPushClientAttrib(GLbitfield mask);
-    void glPopClientAttrib();
-    void glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities);
-    GLboolean glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences);
-    void glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer);
-    void glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glEnableClientState(GLenum array);
-    void glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer);
-    void glDisableClientState(GLenum array);
-    void glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glArrayElement(GLint i);
-
-    // OpenGL 1.2 deprecated functions
-    void glResetMinmax(GLenum target);
-    void glResetHistogram(GLenum target);
-    void glMinmax(GLenum target, GLenum internalformat, GLboolean sink);
-    void glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink);
-    void glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
-    void glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
-    void glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column);
-    void glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span);
-    void glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image);
-    void glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
-    void glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glConvolutionParameteri(GLenum target, GLenum pname, GLint params);
-    void glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params);
-    void glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image);
-    void glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image);
-    void glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width);
-    void glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data);
-    void glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table);
-    void glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
-    void glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table);
-
-    // OpenGL 1.3 deprecated functions
-    void glMultTransposeMatrixd(const GLdouble *m);
-    void glMultTransposeMatrixf(const GLfloat *m);
-    void glLoadTransposeMatrixd(const GLdouble *m);
-    void glLoadTransposeMatrixf(const GLfloat *m);
-    void glMultiTexCoord4sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);
-    void glMultiTexCoord4iv(GLenum target, const GLint *v);
-    void glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q);
-    void glMultiTexCoord4fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
-    void glMultiTexCoord4dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
-    void glMultiTexCoord3sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r);
-    void glMultiTexCoord3iv(GLenum target, const GLint *v);
-    void glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r);
-    void glMultiTexCoord3fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r);
-    void glMultiTexCoord3dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r);
-    void glMultiTexCoord2sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord2s(GLenum target, GLshort s, GLshort t);
-    void glMultiTexCoord2iv(GLenum target, const GLint *v);
-    void glMultiTexCoord2i(GLenum target, GLint s, GLint t);
-    void glMultiTexCoord2fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t);
-    void glMultiTexCoord2dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t);
-    void glMultiTexCoord1sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord1s(GLenum target, GLshort s);
-    void glMultiTexCoord1iv(GLenum target, const GLint *v);
-    void glMultiTexCoord1i(GLenum target, GLint s);
-    void glMultiTexCoord1fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord1f(GLenum target, GLfloat s);
-    void glMultiTexCoord1dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord1d(GLenum target, GLdouble s);
-    void glClientActiveTexture(GLenum texture);
-
-    // OpenGL 1.4 deprecated functions
-    void glWindowPos3sv(const GLshort *v);
-    void glWindowPos3s(GLshort x, GLshort y, GLshort z);
-    void glWindowPos3iv(const GLint *v);
-    void glWindowPos3i(GLint x, GLint y, GLint z);
-    void glWindowPos3fv(const GLfloat *v);
-    void glWindowPos3f(GLfloat x, GLfloat y, GLfloat z);
-    void glWindowPos3dv(const GLdouble *v);
-    void glWindowPos3d(GLdouble x, GLdouble y, GLdouble z);
-    void glWindowPos2sv(const GLshort *v);
-    void glWindowPos2s(GLshort x, GLshort y);
-    void glWindowPos2iv(const GLint *v);
-    void glWindowPos2i(GLint x, GLint y);
-    void glWindowPos2fv(const GLfloat *v);
-    void glWindowPos2f(GLfloat x, GLfloat y);
-    void glWindowPos2dv(const GLdouble *v);
-    void glWindowPos2d(GLdouble x, GLdouble y);
-    void glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glSecondaryColor3usv(const GLushort *v);
-    void glSecondaryColor3us(GLushort red, GLushort green, GLushort blue);
-    void glSecondaryColor3uiv(const GLuint *v);
-    void glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue);
-    void glSecondaryColor3ubv(const GLubyte *v);
-    void glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue);
-    void glSecondaryColor3sv(const GLshort *v);
-    void glSecondaryColor3s(GLshort red, GLshort green, GLshort blue);
-    void glSecondaryColor3iv(const GLint *v);
-    void glSecondaryColor3i(GLint red, GLint green, GLint blue);
-    void glSecondaryColor3fv(const GLfloat *v);
-    void glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue);
-    void glSecondaryColor3dv(const GLdouble *v);
-    void glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue);
-    void glSecondaryColor3bv(const GLbyte *v);
-    void glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue);
-    void glFogCoordPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glFogCoorddv(const GLdouble *coord);
-    void glFogCoordd(GLdouble coord);
-    void glFogCoordfv(const GLfloat *coord);
-    void glFogCoordf(GLfloat coord);
-
-private:
-    friend class QOpenGLContext;
-
-    static bool isContextCompatible(QOpenGLContext *context);
-    static QOpenGLVersionProfile versionProfile();
-
-    QOpenGLFunctions_1_0_CoreBackend* d_1_0_Core;
-    QOpenGLFunctions_1_1_CoreBackend* d_1_1_Core;
-    QOpenGLFunctions_1_2_CoreBackend* d_1_2_Core;
-    QOpenGLFunctions_1_3_CoreBackend* d_1_3_Core;
-    QOpenGLFunctions_1_4_CoreBackend* d_1_4_Core;
-    QOpenGLFunctions_1_0_DeprecatedBackend* d_1_0_Deprecated;
-    QOpenGLFunctions_1_1_DeprecatedBackend* d_1_1_Deprecated;
-    QOpenGLFunctions_1_2_DeprecatedBackend* d_1_2_Deprecated;
-    QOpenGLFunctions_1_3_DeprecatedBackend* d_1_3_Deprecated;
-    QOpenGLFunctions_1_4_DeprecatedBackend* d_1_4_Deprecated;
-};
-
-// OpenGL 1.0 core functions
-inline void QOpenGLFunctions_1_4::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_0_Core->f.Viewport(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_1_4::glDepthRange(GLdouble nearVal, GLdouble farVal)
-{
-    d_1_0_Core->f.DepthRange(nearVal, farVal);
-}
-
-inline GLboolean QOpenGLFunctions_1_4::glIsEnabled(GLenum cap)
-{
-    return d_1_0_Core->f.IsEnabled(cap);
-}
-
-inline void QOpenGLFunctions_1_4::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
-}
-
-inline void QOpenGLFunctions_1_4::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
-}
-
-inline void QOpenGLFunctions_1_4::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetTexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_4::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetTexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_4::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
-{
-    d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
-}
-
-inline const GLubyte * QOpenGLFunctions_1_4::glGetString(GLenum name)
-{
-    return d_1_0_Core->f.GetString(name);
-}
-
-inline void QOpenGLFunctions_1_4::glGetIntegerv(GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetIntegerv(pname, params);
-}
-
-inline void QOpenGLFunctions_1_4::glGetFloatv(GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetFloatv(pname, params);
-}
-
-inline GLenum QOpenGLFunctions_1_4::glGetError()
-{
-    return d_1_0_Core->f.GetError();
-}
-
-inline void QOpenGLFunctions_1_4::glGetDoublev(GLenum pname, GLdouble *params)
-{
-    d_1_0_Core->f.GetDoublev(pname, params);
-}
-
-inline void QOpenGLFunctions_1_4::glGetBooleanv(GLenum pname, GLboolean *params)
-{
-    d_1_0_Core->f.GetBooleanv(pname, params);
-}
-
-inline void QOpenGLFunctions_1_4::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
-{
-    d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_1_4::glReadBuffer(GLenum mode)
-{
-    d_1_0_Core->f.ReadBuffer(mode);
-}
-
-inline void QOpenGLFunctions_1_4::glPixelStorei(GLenum pname, GLint param)
-{
-    d_1_0_Core->f.PixelStorei(pname, param);
-}
-
-inline void QOpenGLFunctions_1_4::glPixelStoref(GLenum pname, GLfloat param)
-{
-    d_1_0_Core->f.PixelStoref(pname, param);
-}
-
-inline void QOpenGLFunctions_1_4::glDepthFunc(GLenum func)
-{
-    d_1_0_Core->f.DepthFunc(func);
-}
-
-inline void QOpenGLFunctions_1_4::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
-{
-    d_1_0_Core->f.StencilOp(fail, zfail, zpass);
-}
-
-inline void QOpenGLFunctions_1_4::glStencilFunc(GLenum func, GLint ref, GLuint mask)
-{
-    d_1_0_Core->f.StencilFunc(func, ref, mask);
-}
-
-inline void QOpenGLFunctions_1_4::glLogicOp(GLenum opcode)
-{
-    d_1_0_Core->f.LogicOp(opcode);
-}
-
-inline void QOpenGLFunctions_1_4::glBlendFunc(GLenum sfactor, GLenum dfactor)
-{
-    d_1_0_Core->f.BlendFunc(sfactor, dfactor);
-}
-
-inline void QOpenGLFunctions_1_4::glFlush()
-{
-    d_1_0_Core->f.Flush();
-}
-
-inline void QOpenGLFunctions_1_4::glFinish()
-{
-    d_1_0_Core->f.Finish();
-}
-
-inline void QOpenGLFunctions_1_4::glEnable(GLenum cap)
-{
-    d_1_0_Core->f.Enable(cap);
-}
-
-inline void QOpenGLFunctions_1_4::glDisable(GLenum cap)
-{
-    d_1_0_Core->f.Disable(cap);
-}
-
-inline void QOpenGLFunctions_1_4::glDepthMask(GLboolean flag)
-{
-    d_1_0_Core->f.DepthMask(flag);
-}
-
-inline void QOpenGLFunctions_1_4::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
-{
-    d_1_0_Core->f.ColorMask(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_4::glStencilMask(GLuint mask)
-{
-    d_1_0_Core->f.StencilMask(mask);
-}
-
-inline void QOpenGLFunctions_1_4::glClearDepth(GLdouble depth)
-{
-    d_1_0_Core->f.ClearDepth(depth);
-}
-
-inline void QOpenGLFunctions_1_4::glClearStencil(GLint s)
-{
-    d_1_0_Core->f.ClearStencil(s);
-}
-
-inline void QOpenGLFunctions_1_4::glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Core->f.ClearColor(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_4::glClear(GLbitfield mask)
-{
-    d_1_0_Core->f.Clear(mask);
-}
-
-inline void QOpenGLFunctions_1_4::glDrawBuffer(GLenum mode)
-{
-    d_1_0_Core->f.DrawBuffer(mode);
-}
-
-inline void QOpenGLFunctions_1_4::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Core->f.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_1_4::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Core->f.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_1_4::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_0_Core->f.TexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_4::glTexParameteri(GLenum target, GLenum pname, GLint param)
-{
-    d_1_0_Core->f.TexParameteri(target, pname, param);
-}
-
-inline void QOpenGLFunctions_1_4::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Core->f.TexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_4::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
-{
-    d_1_0_Core->f.TexParameterf(target, pname, param);
-}
-
-inline void QOpenGLFunctions_1_4::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_0_Core->f.Scissor(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_1_4::glPolygonMode(GLenum face, GLenum mode)
-{
-    d_1_0_Core->f.PolygonMode(face, mode);
-}
-
-inline void QOpenGLFunctions_1_4::glPointSize(GLfloat size)
-{
-    d_1_0_Core->f.PointSize(size);
-}
-
-inline void QOpenGLFunctions_1_4::glLineWidth(GLfloat width)
-{
-    d_1_0_Core->f.LineWidth(width);
-}
-
-inline void QOpenGLFunctions_1_4::glHint(GLenum target, GLenum mode)
-{
-    d_1_0_Core->f.Hint(target, mode);
-}
-
-inline void QOpenGLFunctions_1_4::glFrontFace(GLenum mode)
-{
-    d_1_0_Core->f.FrontFace(mode);
-}
-
-inline void QOpenGLFunctions_1_4::glCullFace(GLenum mode)
-{
-    d_1_0_Core->f.CullFace(mode);
-}
-
-
-// OpenGL 1.1 core functions
-inline void QOpenGLFunctions_1_4::glIndexubv(const GLubyte *c)
-{
-    d_1_1_Deprecated->f.Indexubv(c);
-}
-
-inline void QOpenGLFunctions_1_4::glIndexub(GLubyte c)
-{
-    d_1_1_Deprecated->f.Indexub(c);
-}
-
-inline GLboolean QOpenGLFunctions_1_4::glIsTexture(GLuint texture)
-{
-    return d_1_1_Core->f.IsTexture(texture);
-}
-
-inline void QOpenGLFunctions_1_4::glGenTextures(GLsizei n, GLuint *textures)
-{
-    d_1_1_Core->f.GenTextures(n, textures);
-}
-
-inline void QOpenGLFunctions_1_4::glDeleteTextures(GLsizei n, const GLuint *textures)
-{
-    d_1_1_Core->f.DeleteTextures(n, textures);
-}
-
-inline void QOpenGLFunctions_1_4::glBindTexture(GLenum target, GLuint texture)
-{
-    d_1_1_Core->f.BindTexture(target, texture);
-}
-
-inline void QOpenGLFunctions_1_4::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_1_Core->f.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_1_4::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_1_Core->f.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_1_4::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_1_Core->f.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_1_4::glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
-{
-    d_1_1_Core->f.CopyTexSubImage1D(target, level, xoffset, x, y, width);
-}
-
-inline void QOpenGLFunctions_1_4::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
-{
-    d_1_1_Core->f.CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
-}
-
-inline void QOpenGLFunctions_1_4::glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
-{
-    d_1_1_Core->f.CopyTexImage1D(target, level, internalformat, x, y, width, border);
-}
-
-inline void QOpenGLFunctions_1_4::glPolygonOffset(GLfloat factor, GLfloat units)
-{
-    d_1_1_Core->f.PolygonOffset(factor, units);
-}
-
-inline void QOpenGLFunctions_1_4::glGetPointerv(GLenum pname, GLvoid* *params)
-{
-    d_1_1_Deprecated->f.GetPointerv(pname, params);
-}
-
-inline void QOpenGLFunctions_1_4::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
-{
-    d_1_1_Core->f.DrawElements(mode, count, type, indices);
-}
-
-inline void QOpenGLFunctions_1_4::glDrawArrays(GLenum mode, GLint first, GLsizei count)
-{
-    d_1_1_Core->f.DrawArrays(mode, first, count);
-}
-
-
-// OpenGL 1.2 core functions
-inline void QOpenGLFunctions_1_4::glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_2_Core->f.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_1_4::glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_2_Core->f.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_1_4::glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_2_Core->f.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_1_4::glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
-{
-    d_1_2_Core->f.DrawRangeElements(mode, start, end, count, type, indices);
-}
-
-inline void QOpenGLFunctions_1_4::glBlendEquation(GLenum mode)
-{
-    d_1_2_Core->f.BlendEquation(mode);
-}
-
-inline void QOpenGLFunctions_1_4::glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_2_Core->f.BlendColor(red, green, blue, alpha);
-}
-
-
-// OpenGL 1.3 core functions
-inline void QOpenGLFunctions_1_4::glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img)
-{
-    d_1_3_Core->f.GetCompressedTexImage(target, level, img);
-}
-
-inline void QOpenGLFunctions_1_4::glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_1_4::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_1_4::glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_1_4::glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_1_4::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_1_4::glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_1_4::glSampleCoverage(GLfloat value, GLboolean invert)
-{
-    d_1_3_Core->f.SampleCoverage(value, invert);
-}
-
-inline void QOpenGLFunctions_1_4::glActiveTexture(GLenum texture)
-{
-    d_1_3_Core->f.ActiveTexture(texture);
-}
-
-
-// OpenGL 1.4 core functions
-inline void QOpenGLFunctions_1_4::glPointParameteriv(GLenum pname, const GLint *params)
-{
-    d_1_4_Core->f.PointParameteriv(pname, params);
-}
-
-inline void QOpenGLFunctions_1_4::glPointParameteri(GLenum pname, GLint param)
-{
-    d_1_4_Core->f.PointParameteri(pname, param);
-}
-
-inline void QOpenGLFunctions_1_4::glPointParameterfv(GLenum pname, const GLfloat *params)
-{
-    d_1_4_Core->f.PointParameterfv(pname, params);
-}
-
-inline void QOpenGLFunctions_1_4::glPointParameterf(GLenum pname, GLfloat param)
-{
-    d_1_4_Core->f.PointParameterf(pname, param);
-}
-
-inline void QOpenGLFunctions_1_4::glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount)
-{
-    d_1_4_Core->f.MultiDrawElements(mode, count, type, indices, drawcount);
-}
-
-inline void QOpenGLFunctions_1_4::glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
-{
-    d_1_4_Core->f.MultiDrawArrays(mode, first, count, drawcount);
-}
-
-inline void QOpenGLFunctions_1_4::glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
-{
-    d_1_4_Core->f.BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
-}
-
-
-// OpenGL 1.0 deprecated functions
-inline void QOpenGLFunctions_1_4::glTranslatef(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Translatef(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_4::glTranslated(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Translated(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_4::glScalef(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Scalef(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_4::glScaled(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Scaled(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_4::glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Rotatef(angle, x, y, z);
-}
-
-inline void QOpenGLFunctions_1_4::glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Rotated(angle, x, y, z);
-}
-
-inline void QOpenGLFunctions_1_4::glPushMatrix()
-{
-    d_1_0_Deprecated->f.PushMatrix();
-}
-
-inline void QOpenGLFunctions_1_4::glPopMatrix()
-{
-    d_1_0_Deprecated->f.PopMatrix();
-}
-
-inline void QOpenGLFunctions_1_4::glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
-{
-    d_1_0_Deprecated->f.Ortho(left, right, bottom, top, zNear, zFar);
-}
-
-inline void QOpenGLFunctions_1_4::glMultMatrixd(const GLdouble *m)
-{
-    d_1_0_Deprecated->f.MultMatrixd(m);
-}
-
-inline void QOpenGLFunctions_1_4::glMultMatrixf(const GLfloat *m)
-{
-    d_1_0_Deprecated->f.MultMatrixf(m);
-}
-
-inline void QOpenGLFunctions_1_4::glMatrixMode(GLenum mode)
-{
-    d_1_0_Deprecated->f.MatrixMode(mode);
-}
-
-inline void QOpenGLFunctions_1_4::glLoadMatrixd(const GLdouble *m)
-{
-    d_1_0_Deprecated->f.LoadMatrixd(m);
-}
-
-inline void QOpenGLFunctions_1_4::glLoadMatrixf(const GLfloat *m)
-{
-    d_1_0_Deprecated->f.LoadMatrixf(m);
-}
-
-inline void QOpenGLFunctions_1_4::glLoadIdentity()
-{
-    d_1_0_Deprecated->f.LoadIdentity();
-}
-
-inline void QOpenGLFunctions_1_4::glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
-{
-    d_1_0_Deprecated->f.Frustum(left, right, bottom, top, zNear, zFar);
-}
-
-inline GLboolean QOpenGLFunctions_1_4::glIsList(GLuint list)
-{
-    return d_1_0_Deprecated->f.IsList(list);
-}
-
-inline void QOpenGLFunctions_1_4::glGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetTexGeniv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_1_4::glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetTexGenfv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_1_4::glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
-{
-    d_1_0_Deprecated->f.GetTexGendv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_1_4::glGetTexEnviv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetTexEnviv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_4::glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetTexEnvfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_4::glGetPolygonStipple(GLubyte *mask)
-{
-    d_1_0_Deprecated->f.GetPolygonStipple(mask);
-}
-
-inline void QOpenGLFunctions_1_4::glGetPixelMapusv(GLenum map, GLushort *values)
-{
-    d_1_0_Deprecated->f.GetPixelMapusv(map, values);
-}
-
-inline void QOpenGLFunctions_1_4::glGetPixelMapuiv(GLenum map, GLuint *values)
-{
-    d_1_0_Deprecated->f.GetPixelMapuiv(map, values);
-}
-
-inline void QOpenGLFunctions_1_4::glGetPixelMapfv(GLenum map, GLfloat *values)
-{
-    d_1_0_Deprecated->f.GetPixelMapfv(map, values);
-}
-
-inline void QOpenGLFunctions_1_4::glGetMaterialiv(GLenum face, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetMaterialiv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_1_4::glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetMaterialfv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_1_4::glGetMapiv(GLenum target, GLenum query, GLint *v)
-{
-    d_1_0_Deprecated->f.GetMapiv(target, query, v);
-}
-
-inline void QOpenGLFunctions_1_4::glGetMapfv(GLenum target, GLenum query, GLfloat *v)
-{
-    d_1_0_Deprecated->f.GetMapfv(target, query, v);
-}
-
-inline void QOpenGLFunctions_1_4::glGetMapdv(GLenum target, GLenum query, GLdouble *v)
-{
-    d_1_0_Deprecated->f.GetMapdv(target, query, v);
-}
-
-inline void QOpenGLFunctions_1_4::glGetLightiv(GLenum light, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetLightiv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_1_4::glGetLightfv(GLenum light, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetLightfv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_1_4::glGetClipPlane(GLenum plane, GLdouble *equation)
-{
-    d_1_0_Deprecated->f.GetClipPlane(plane, equation);
-}
-
-inline void QOpenGLFunctions_1_4::glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Deprecated->f.DrawPixels(width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_1_4::glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
-{
-    d_1_0_Deprecated->f.CopyPixels(x, y, width, height, type);
-}
-
-inline void QOpenGLFunctions_1_4::glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values)
-{
-    d_1_0_Deprecated->f.PixelMapusv(map, mapsize, values);
-}
-
-inline void QOpenGLFunctions_1_4::glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values)
-{
-    d_1_0_Deprecated->f.PixelMapuiv(map, mapsize, values);
-}
-
-inline void QOpenGLFunctions_1_4::glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values)
-{
-    d_1_0_Deprecated->f.PixelMapfv(map, mapsize, values);
-}
-
-inline void QOpenGLFunctions_1_4::glPixelTransferi(GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.PixelTransferi(pname, param);
-}
-
-inline void QOpenGLFunctions_1_4::glPixelTransferf(GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.PixelTransferf(pname, param);
-}
-
-inline void QOpenGLFunctions_1_4::glPixelZoom(GLfloat xfactor, GLfloat yfactor)
-{
-    d_1_0_Deprecated->f.PixelZoom(xfactor, yfactor);
-}
-
-inline void QOpenGLFunctions_1_4::glAlphaFunc(GLenum func, GLfloat ref)
-{
-    d_1_0_Deprecated->f.AlphaFunc(func, ref);
-}
-
-inline void QOpenGLFunctions_1_4::glEvalPoint2(GLint i, GLint j)
-{
-    d_1_0_Deprecated->f.EvalPoint2(i, j);
-}
-
-inline void QOpenGLFunctions_1_4::glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
-{
-    d_1_0_Deprecated->f.EvalMesh2(mode, i1, i2, j1, j2);
-}
-
-inline void QOpenGLFunctions_1_4::glEvalPoint1(GLint i)
-{
-    d_1_0_Deprecated->f.EvalPoint1(i);
-}
-
-inline void QOpenGLFunctions_1_4::glEvalMesh1(GLenum mode, GLint i1, GLint i2)
-{
-    d_1_0_Deprecated->f.EvalMesh1(mode, i1, i2);
-}
-
-inline void QOpenGLFunctions_1_4::glEvalCoord2fv(const GLfloat *u)
-{
-    d_1_0_Deprecated->f.EvalCoord2fv(u);
-}
-
-inline void QOpenGLFunctions_1_4::glEvalCoord2f(GLfloat u, GLfloat v)
-{
-    d_1_0_Deprecated->f.EvalCoord2f(u, v);
-}
-
-inline void QOpenGLFunctions_1_4::glEvalCoord2dv(const GLdouble *u)
-{
-    d_1_0_Deprecated->f.EvalCoord2dv(u);
-}
-
-inline void QOpenGLFunctions_1_4::glEvalCoord2d(GLdouble u, GLdouble v)
-{
-    d_1_0_Deprecated->f.EvalCoord2d(u, v);
-}
-
-inline void QOpenGLFunctions_1_4::glEvalCoord1fv(const GLfloat *u)
-{
-    d_1_0_Deprecated->f.EvalCoord1fv(u);
-}
-
-inline void QOpenGLFunctions_1_4::glEvalCoord1f(GLfloat u)
-{
-    d_1_0_Deprecated->f.EvalCoord1f(u);
-}
-
-inline void QOpenGLFunctions_1_4::glEvalCoord1dv(const GLdouble *u)
-{
-    d_1_0_Deprecated->f.EvalCoord1dv(u);
-}
-
-inline void QOpenGLFunctions_1_4::glEvalCoord1d(GLdouble u)
-{
-    d_1_0_Deprecated->f.EvalCoord1d(u);
-}
-
-inline void QOpenGLFunctions_1_4::glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
-{
-    d_1_0_Deprecated->f.MapGrid2f(un, u1, u2, vn, v1, v2);
-}
-
-inline void QOpenGLFunctions_1_4::glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
-{
-    d_1_0_Deprecated->f.MapGrid2d(un, u1, u2, vn, v1, v2);
-}
-
-inline void QOpenGLFunctions_1_4::glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
-{
-    d_1_0_Deprecated->f.MapGrid1f(un, u1, u2);
-}
-
-inline void QOpenGLFunctions_1_4::glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
-{
-    d_1_0_Deprecated->f.MapGrid1d(un, u1, u2);
-}
-
-inline void QOpenGLFunctions_1_4::glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
-{
-    d_1_0_Deprecated->f.Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
-}
-
-inline void QOpenGLFunctions_1_4::glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
-{
-    d_1_0_Deprecated->f.Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
-}
-
-inline void QOpenGLFunctions_1_4::glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
-{
-    d_1_0_Deprecated->f.Map1f(target, u1, u2, stride, order, points);
-}
-
-inline void QOpenGLFunctions_1_4::glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
-{
-    d_1_0_Deprecated->f.Map1d(target, u1, u2, stride, order, points);
-}
-
-inline void QOpenGLFunctions_1_4::glPushAttrib(GLbitfield mask)
-{
-    d_1_0_Deprecated->f.PushAttrib(mask);
-}
-
-inline void QOpenGLFunctions_1_4::glPopAttrib()
-{
-    d_1_0_Deprecated->f.PopAttrib();
-}
-
-inline void QOpenGLFunctions_1_4::glAccum(GLenum op, GLfloat value)
-{
-    d_1_0_Deprecated->f.Accum(op, value);
-}
-
-inline void QOpenGLFunctions_1_4::glIndexMask(GLuint mask)
-{
-    d_1_0_Deprecated->f.IndexMask(mask);
-}
-
-inline void QOpenGLFunctions_1_4::glClearIndex(GLfloat c)
-{
-    d_1_0_Deprecated->f.ClearIndex(c);
-}
-
-inline void QOpenGLFunctions_1_4::glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Deprecated->f.ClearAccum(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_4::glPushName(GLuint name)
-{
-    d_1_0_Deprecated->f.PushName(name);
-}
-
-inline void QOpenGLFunctions_1_4::glPopName()
-{
-    d_1_0_Deprecated->f.PopName();
-}
-
-inline void QOpenGLFunctions_1_4::glPassThrough(GLfloat token)
-{
-    d_1_0_Deprecated->f.PassThrough(token);
-}
-
-inline void QOpenGLFunctions_1_4::glLoadName(GLuint name)
-{
-    d_1_0_Deprecated->f.LoadName(name);
-}
-
-inline void QOpenGLFunctions_1_4::glInitNames()
-{
-    d_1_0_Deprecated->f.InitNames();
-}
-
-inline GLint QOpenGLFunctions_1_4::glRenderMode(GLenum mode)
-{
-    return d_1_0_Deprecated->f.RenderMode(mode);
-}
-
-inline void QOpenGLFunctions_1_4::glSelectBuffer(GLsizei size, GLuint *buffer)
-{
-    d_1_0_Deprecated->f.SelectBuffer(size, buffer);
-}
-
-inline void QOpenGLFunctions_1_4::glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
-{
-    d_1_0_Deprecated->f.FeedbackBuffer(size, type, buffer);
-}
-
-inline void QOpenGLFunctions_1_4::glTexGeniv(GLenum coord, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.TexGeniv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_1_4::glTexGeni(GLenum coord, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.TexGeni(coord, pname, param);
-}
-
-inline void QOpenGLFunctions_1_4::glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.TexGenfv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_1_4::glTexGenf(GLenum coord, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.TexGenf(coord, pname, param);
-}
-
-inline void QOpenGLFunctions_1_4::glTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
-{
-    d_1_0_Deprecated->f.TexGendv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_1_4::glTexGend(GLenum coord, GLenum pname, GLdouble param)
-{
-    d_1_0_Deprecated->f.TexGend(coord, pname, param);
-}
-
-inline void QOpenGLFunctions_1_4::glTexEnviv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.TexEnviv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_4::glTexEnvi(GLenum target, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.TexEnvi(target, pname, param);
-}
-
-inline void QOpenGLFunctions_1_4::glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.TexEnvfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_4::glTexEnvf(GLenum target, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.TexEnvf(target, pname, param);
-}
-
-inline void QOpenGLFunctions_1_4::glShadeModel(GLenum mode)
-{
-    d_1_0_Deprecated->f.ShadeModel(mode);
-}
-
-inline void QOpenGLFunctions_1_4::glPolygonStipple(const GLubyte *mask)
-{
-    d_1_0_Deprecated->f.PolygonStipple(mask);
-}
-
-inline void QOpenGLFunctions_1_4::glMaterialiv(GLenum face, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.Materialiv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_1_4::glMateriali(GLenum face, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.Materiali(face, pname, param);
-}
-
-inline void QOpenGLFunctions_1_4::glMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.Materialfv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_1_4::glMaterialf(GLenum face, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.Materialf(face, pname, param);
-}
-
-inline void QOpenGLFunctions_1_4::glLineStipple(GLint factor, GLushort pattern)
-{
-    d_1_0_Deprecated->f.LineStipple(factor, pattern);
-}
-
-inline void QOpenGLFunctions_1_4::glLightModeliv(GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.LightModeliv(pname, params);
-}
-
-inline void QOpenGLFunctions_1_4::glLightModeli(GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.LightModeli(pname, param);
-}
-
-inline void QOpenGLFunctions_1_4::glLightModelfv(GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.LightModelfv(pname, params);
-}
-
-inline void QOpenGLFunctions_1_4::glLightModelf(GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.LightModelf(pname, param);
-}
-
-inline void QOpenGLFunctions_1_4::glLightiv(GLenum light, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.Lightiv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_1_4::glLighti(GLenum light, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.Lighti(light, pname, param);
-}
-
-inline void QOpenGLFunctions_1_4::glLightfv(GLenum light, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.Lightfv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_1_4::glLightf(GLenum light, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.Lightf(light, pname, param);
-}
-
-inline void QOpenGLFunctions_1_4::glFogiv(GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.Fogiv(pname, params);
-}
-
-inline void QOpenGLFunctions_1_4::glFogi(GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.Fogi(pname, param);
-}
-
-inline void QOpenGLFunctions_1_4::glFogfv(GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.Fogfv(pname, params);
-}
-
-inline void QOpenGLFunctions_1_4::glFogf(GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.Fogf(pname, param);
-}
-
-inline void QOpenGLFunctions_1_4::glColorMaterial(GLenum face, GLenum mode)
-{
-    d_1_0_Deprecated->f.ColorMaterial(face, mode);
-}
-
-inline void QOpenGLFunctions_1_4::glClipPlane(GLenum plane, const GLdouble *equation)
-{
-    d_1_0_Deprecated->f.ClipPlane(plane, equation);
-}
-
-inline void QOpenGLFunctions_1_4::glVertex4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Vertex4sv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
-{
-    d_1_0_Deprecated->f.Vertex4s(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_1_4::glVertex4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Vertex4iv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glVertex4i(GLint x, GLint y, GLint z, GLint w)
-{
-    d_1_0_Deprecated->f.Vertex4i(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_1_4::glVertex4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Vertex4fv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    d_1_0_Deprecated->f.Vertex4f(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_1_4::glVertex4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Vertex4dv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_1_0_Deprecated->f.Vertex4d(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_1_4::glVertex3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Vertex3sv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glVertex3s(GLshort x, GLshort y, GLshort z)
-{
-    d_1_0_Deprecated->f.Vertex3s(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_4::glVertex3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Vertex3iv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glVertex3i(GLint x, GLint y, GLint z)
-{
-    d_1_0_Deprecated->f.Vertex3i(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_4::glVertex3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Vertex3fv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glVertex3f(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Vertex3f(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_4::glVertex3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Vertex3dv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glVertex3d(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Vertex3d(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_4::glVertex2sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Vertex2sv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glVertex2s(GLshort x, GLshort y)
-{
-    d_1_0_Deprecated->f.Vertex2s(x, y);
-}
-
-inline void QOpenGLFunctions_1_4::glVertex2iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Vertex2iv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glVertex2i(GLint x, GLint y)
-{
-    d_1_0_Deprecated->f.Vertex2i(x, y);
-}
-
-inline void QOpenGLFunctions_1_4::glVertex2fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Vertex2fv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glVertex2f(GLfloat x, GLfloat y)
-{
-    d_1_0_Deprecated->f.Vertex2f(x, y);
-}
-
-inline void QOpenGLFunctions_1_4::glVertex2dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Vertex2dv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glVertex2d(GLdouble x, GLdouble y)
-{
-    d_1_0_Deprecated->f.Vertex2d(x, y);
-}
-
-inline void QOpenGLFunctions_1_4::glTexCoord4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord4sv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
-{
-    d_1_0_Deprecated->f.TexCoord4s(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_1_4::glTexCoord4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord4iv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
-{
-    d_1_0_Deprecated->f.TexCoord4i(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_1_4::glTexCoord4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord4fv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
-{
-    d_1_0_Deprecated->f.TexCoord4f(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_1_4::glTexCoord4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord4dv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
-{
-    d_1_0_Deprecated->f.TexCoord4d(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_1_4::glTexCoord3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord3sv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glTexCoord3s(GLshort s, GLshort t, GLshort r)
-{
-    d_1_0_Deprecated->f.TexCoord3s(s, t, r);
-}
-
-inline void QOpenGLFunctions_1_4::glTexCoord3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord3iv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glTexCoord3i(GLint s, GLint t, GLint r)
-{
-    d_1_0_Deprecated->f.TexCoord3i(s, t, r);
-}
-
-inline void QOpenGLFunctions_1_4::glTexCoord3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord3fv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
-{
-    d_1_0_Deprecated->f.TexCoord3f(s, t, r);
-}
-
-inline void QOpenGLFunctions_1_4::glTexCoord3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord3dv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
-{
-    d_1_0_Deprecated->f.TexCoord3d(s, t, r);
-}
-
-inline void QOpenGLFunctions_1_4::glTexCoord2sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord2sv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glTexCoord2s(GLshort s, GLshort t)
-{
-    d_1_0_Deprecated->f.TexCoord2s(s, t);
-}
-
-inline void QOpenGLFunctions_1_4::glTexCoord2iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord2iv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glTexCoord2i(GLint s, GLint t)
-{
-    d_1_0_Deprecated->f.TexCoord2i(s, t);
-}
-
-inline void QOpenGLFunctions_1_4::glTexCoord2fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord2fv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glTexCoord2f(GLfloat s, GLfloat t)
-{
-    d_1_0_Deprecated->f.TexCoord2f(s, t);
-}
-
-inline void QOpenGLFunctions_1_4::glTexCoord2dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord2dv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glTexCoord2d(GLdouble s, GLdouble t)
-{
-    d_1_0_Deprecated->f.TexCoord2d(s, t);
-}
-
-inline void QOpenGLFunctions_1_4::glTexCoord1sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord1sv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glTexCoord1s(GLshort s)
-{
-    d_1_0_Deprecated->f.TexCoord1s(s);
-}
-
-inline void QOpenGLFunctions_1_4::glTexCoord1iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord1iv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glTexCoord1i(GLint s)
-{
-    d_1_0_Deprecated->f.TexCoord1i(s);
-}
-
-inline void QOpenGLFunctions_1_4::glTexCoord1fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord1fv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glTexCoord1f(GLfloat s)
-{
-    d_1_0_Deprecated->f.TexCoord1f(s);
-}
-
-inline void QOpenGLFunctions_1_4::glTexCoord1dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord1dv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glTexCoord1d(GLdouble s)
-{
-    d_1_0_Deprecated->f.TexCoord1d(s);
-}
-
-inline void QOpenGLFunctions_1_4::glRectsv(const GLshort *v1, const GLshort *v2)
-{
-    d_1_0_Deprecated->f.Rectsv(v1, v2);
-}
-
-inline void QOpenGLFunctions_1_4::glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
-{
-    d_1_0_Deprecated->f.Rects(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_1_4::glRectiv(const GLint *v1, const GLint *v2)
-{
-    d_1_0_Deprecated->f.Rectiv(v1, v2);
-}
-
-inline void QOpenGLFunctions_1_4::glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
-{
-    d_1_0_Deprecated->f.Recti(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_1_4::glRectfv(const GLfloat *v1, const GLfloat *v2)
-{
-    d_1_0_Deprecated->f.Rectfv(v1, v2);
-}
-
-inline void QOpenGLFunctions_1_4::glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
-{
-    d_1_0_Deprecated->f.Rectf(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_1_4::glRectdv(const GLdouble *v1, const GLdouble *v2)
-{
-    d_1_0_Deprecated->f.Rectdv(v1, v2);
-}
-
-inline void QOpenGLFunctions_1_4::glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
-{
-    d_1_0_Deprecated->f.Rectd(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_1_4::glRasterPos4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.RasterPos4sv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
-{
-    d_1_0_Deprecated->f.RasterPos4s(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_1_4::glRasterPos4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.RasterPos4iv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
-{
-    d_1_0_Deprecated->f.RasterPos4i(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_1_4::glRasterPos4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.RasterPos4fv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    d_1_0_Deprecated->f.RasterPos4f(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_1_4::glRasterPos4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.RasterPos4dv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_1_0_Deprecated->f.RasterPos4d(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_1_4::glRasterPos3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.RasterPos3sv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glRasterPos3s(GLshort x, GLshort y, GLshort z)
-{
-    d_1_0_Deprecated->f.RasterPos3s(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_4::glRasterPos3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.RasterPos3iv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glRasterPos3i(GLint x, GLint y, GLint z)
-{
-    d_1_0_Deprecated->f.RasterPos3i(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_4::glRasterPos3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.RasterPos3fv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.RasterPos3f(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_4::glRasterPos3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.RasterPos3dv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.RasterPos3d(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_4::glRasterPos2sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.RasterPos2sv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glRasterPos2s(GLshort x, GLshort y)
-{
-    d_1_0_Deprecated->f.RasterPos2s(x, y);
-}
-
-inline void QOpenGLFunctions_1_4::glRasterPos2iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.RasterPos2iv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glRasterPos2i(GLint x, GLint y)
-{
-    d_1_0_Deprecated->f.RasterPos2i(x, y);
-}
-
-inline void QOpenGLFunctions_1_4::glRasterPos2fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.RasterPos2fv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glRasterPos2f(GLfloat x, GLfloat y)
-{
-    d_1_0_Deprecated->f.RasterPos2f(x, y);
-}
-
-inline void QOpenGLFunctions_1_4::glRasterPos2dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.RasterPos2dv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glRasterPos2d(GLdouble x, GLdouble y)
-{
-    d_1_0_Deprecated->f.RasterPos2d(x, y);
-}
-
-inline void QOpenGLFunctions_1_4::glNormal3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Normal3sv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glNormal3s(GLshort nx, GLshort ny, GLshort nz)
-{
-    d_1_0_Deprecated->f.Normal3s(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_1_4::glNormal3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Normal3iv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glNormal3i(GLint nx, GLint ny, GLint nz)
-{
-    d_1_0_Deprecated->f.Normal3i(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_1_4::glNormal3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Normal3fv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
-{
-    d_1_0_Deprecated->f.Normal3f(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_1_4::glNormal3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Normal3dv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
-{
-    d_1_0_Deprecated->f.Normal3d(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_1_4::glNormal3bv(const GLbyte *v)
-{
-    d_1_0_Deprecated->f.Normal3bv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
-{
-    d_1_0_Deprecated->f.Normal3b(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_1_4::glIndexsv(const GLshort *c)
-{
-    d_1_0_Deprecated->f.Indexsv(c);
-}
-
-inline void QOpenGLFunctions_1_4::glIndexs(GLshort c)
-{
-    d_1_0_Deprecated->f.Indexs(c);
-}
-
-inline void QOpenGLFunctions_1_4::glIndexiv(const GLint *c)
-{
-    d_1_0_Deprecated->f.Indexiv(c);
-}
-
-inline void QOpenGLFunctions_1_4::glIndexi(GLint c)
-{
-    d_1_0_Deprecated->f.Indexi(c);
-}
-
-inline void QOpenGLFunctions_1_4::glIndexfv(const GLfloat *c)
-{
-    d_1_0_Deprecated->f.Indexfv(c);
-}
-
-inline void QOpenGLFunctions_1_4::glIndexf(GLfloat c)
-{
-    d_1_0_Deprecated->f.Indexf(c);
-}
-
-inline void QOpenGLFunctions_1_4::glIndexdv(const GLdouble *c)
-{
-    d_1_0_Deprecated->f.Indexdv(c);
-}
-
-inline void QOpenGLFunctions_1_4::glIndexd(GLdouble c)
-{
-    d_1_0_Deprecated->f.Indexd(c);
-}
-
-inline void QOpenGLFunctions_1_4::glEnd()
-{
-    d_1_0_Deprecated->f.End();
-}
-
-inline void QOpenGLFunctions_1_4::glEdgeFlagv(const GLboolean *flag)
-{
-    d_1_0_Deprecated->f.EdgeFlagv(flag);
-}
-
-inline void QOpenGLFunctions_1_4::glEdgeFlag(GLboolean flag)
-{
-    d_1_0_Deprecated->f.EdgeFlag(flag);
-}
-
-inline void QOpenGLFunctions_1_4::glColor4usv(const GLushort *v)
-{
-    d_1_0_Deprecated->f.Color4usv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
-{
-    d_1_0_Deprecated->f.Color4us(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_4::glColor4uiv(const GLuint *v)
-{
-    d_1_0_Deprecated->f.Color4uiv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
-{
-    d_1_0_Deprecated->f.Color4ui(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_4::glColor4ubv(const GLubyte *v)
-{
-    d_1_0_Deprecated->f.Color4ubv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
-{
-    d_1_0_Deprecated->f.Color4ub(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_4::glColor4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Color4sv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
-{
-    d_1_0_Deprecated->f.Color4s(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_4::glColor4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Color4iv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
-{
-    d_1_0_Deprecated->f.Color4i(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_4::glColor4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Color4fv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Deprecated->f.Color4f(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_4::glColor4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Color4dv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
-{
-    d_1_0_Deprecated->f.Color4d(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_4::glColor4bv(const GLbyte *v)
-{
-    d_1_0_Deprecated->f.Color4bv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
-{
-    d_1_0_Deprecated->f.Color4b(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_4::glColor3usv(const GLushort *v)
-{
-    d_1_0_Deprecated->f.Color3usv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glColor3us(GLushort red, GLushort green, GLushort blue)
-{
-    d_1_0_Deprecated->f.Color3us(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_4::glColor3uiv(const GLuint *v)
-{
-    d_1_0_Deprecated->f.Color3uiv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glColor3ui(GLuint red, GLuint green, GLuint blue)
-{
-    d_1_0_Deprecated->f.Color3ui(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_4::glColor3ubv(const GLubyte *v)
-{
-    d_1_0_Deprecated->f.Color3ubv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
-{
-    d_1_0_Deprecated->f.Color3ub(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_4::glColor3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Color3sv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glColor3s(GLshort red, GLshort green, GLshort blue)
-{
-    d_1_0_Deprecated->f.Color3s(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_4::glColor3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Color3iv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glColor3i(GLint red, GLint green, GLint blue)
-{
-    d_1_0_Deprecated->f.Color3i(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_4::glColor3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Color3fv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glColor3f(GLfloat red, GLfloat green, GLfloat blue)
-{
-    d_1_0_Deprecated->f.Color3f(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_4::glColor3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Color3dv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glColor3d(GLdouble red, GLdouble green, GLdouble blue)
-{
-    d_1_0_Deprecated->f.Color3d(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_4::glColor3bv(const GLbyte *v)
-{
-    d_1_0_Deprecated->f.Color3bv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glColor3b(GLbyte red, GLbyte green, GLbyte blue)
-{
-    d_1_0_Deprecated->f.Color3b(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_4::glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
-{
-    d_1_0_Deprecated->f.Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
-}
-
-inline void QOpenGLFunctions_1_4::glBegin(GLenum mode)
-{
-    d_1_0_Deprecated->f.Begin(mode);
-}
-
-inline void QOpenGLFunctions_1_4::glListBase(GLuint base)
-{
-    d_1_0_Deprecated->f.ListBase(base);
-}
-
-inline GLuint QOpenGLFunctions_1_4::glGenLists(GLsizei range)
-{
-    return d_1_0_Deprecated->f.GenLists(range);
-}
-
-inline void QOpenGLFunctions_1_4::glDeleteLists(GLuint list, GLsizei range)
-{
-    d_1_0_Deprecated->f.DeleteLists(list, range);
-}
-
-inline void QOpenGLFunctions_1_4::glCallLists(GLsizei n, GLenum type, const GLvoid *lists)
-{
-    d_1_0_Deprecated->f.CallLists(n, type, lists);
-}
-
-inline void QOpenGLFunctions_1_4::glCallList(GLuint list)
-{
-    d_1_0_Deprecated->f.CallList(list);
-}
-
-inline void QOpenGLFunctions_1_4::glEndList()
-{
-    d_1_0_Deprecated->f.EndList();
-}
-
-inline void QOpenGLFunctions_1_4::glNewList(GLuint list, GLenum mode)
-{
-    d_1_0_Deprecated->f.NewList(list, mode);
-}
-
-
-// OpenGL 1.1 deprecated functions
-inline void QOpenGLFunctions_1_4::glPushClientAttrib(GLbitfield mask)
-{
-    d_1_1_Deprecated->f.PushClientAttrib(mask);
-}
-
-inline void QOpenGLFunctions_1_4::glPopClientAttrib()
-{
-    d_1_1_Deprecated->f.PopClientAttrib();
-}
-
-inline void QOpenGLFunctions_1_4::glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities)
-{
-    d_1_1_Deprecated->f.PrioritizeTextures(n, textures, priorities);
-}
-
-inline GLboolean QOpenGLFunctions_1_4::glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
-{
-    return d_1_1_Deprecated->f.AreTexturesResident(n, textures, residences);
-}
-
-inline void QOpenGLFunctions_1_4::glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.VertexPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_1_4::glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.TexCoordPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_1_4::glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.NormalPointer(type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_1_4::glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.InterleavedArrays(format, stride, pointer);
-}
-
-inline void QOpenGLFunctions_1_4::glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.IndexPointer(type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_1_4::glEnableClientState(GLenum array)
-{
-    d_1_1_Deprecated->f.EnableClientState(array);
-}
-
-inline void QOpenGLFunctions_1_4::glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.EdgeFlagPointer(stride, pointer);
-}
-
-inline void QOpenGLFunctions_1_4::glDisableClientState(GLenum array)
-{
-    d_1_1_Deprecated->f.DisableClientState(array);
-}
-
-inline void QOpenGLFunctions_1_4::glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.ColorPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_1_4::glArrayElement(GLint i)
-{
-    d_1_1_Deprecated->f.ArrayElement(i);
-}
-
-
-// OpenGL 1.2 deprecated functions
-inline void QOpenGLFunctions_1_4::glResetMinmax(GLenum target)
-{
-    d_1_2_Deprecated->f.ResetMinmax(target);
-}
-
-inline void QOpenGLFunctions_1_4::glResetHistogram(GLenum target)
-{
-    d_1_2_Deprecated->f.ResetHistogram(target);
-}
-
-inline void QOpenGLFunctions_1_4::glMinmax(GLenum target, GLenum internalformat, GLboolean sink)
-{
-    d_1_2_Deprecated->f.Minmax(target, internalformat, sink);
-}
-
-inline void QOpenGLFunctions_1_4::glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
-{
-    d_1_2_Deprecated->f.Histogram(target, width, internalformat, sink);
-}
-
-inline void QOpenGLFunctions_1_4::glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetMinmaxParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_4::glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetMinmaxParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_4::glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
-{
-    d_1_2_Deprecated->f.GetMinmax(target, reset, format, type, values);
-}
-
-inline void QOpenGLFunctions_1_4::glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetHistogramParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_4::glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetHistogramParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_4::glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
-{
-    d_1_2_Deprecated->f.GetHistogram(target, reset, format, type, values);
-}
-
-inline void QOpenGLFunctions_1_4::glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column)
-{
-    d_1_2_Deprecated->f.SeparableFilter2D(target, internalformat, width, height, format, type, row, column);
-}
-
-inline void QOpenGLFunctions_1_4::glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span)
-{
-    d_1_2_Deprecated->f.GetSeparableFilter(target, format, type, row, column, span);
-}
-
-inline void QOpenGLFunctions_1_4::glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetConvolutionParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_4::glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetConvolutionParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_4::glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image)
-{
-    d_1_2_Deprecated->f.GetConvolutionFilter(target, format, type, image);
-}
-
-inline void QOpenGLFunctions_1_4::glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_2_Deprecated->f.CopyConvolutionFilter2D(target, internalformat, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_1_4::glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
-{
-    d_1_2_Deprecated->f.CopyConvolutionFilter1D(target, internalformat, x, y, width);
-}
-
-inline void QOpenGLFunctions_1_4::glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_4::glConvolutionParameteri(GLenum target, GLenum pname, GLint params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameteri(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_4::glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_4::glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameterf(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_4::glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image)
-{
-    d_1_2_Deprecated->f.ConvolutionFilter2D(target, internalformat, width, height, format, type, image);
-}
-
-inline void QOpenGLFunctions_1_4::glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image)
-{
-    d_1_2_Deprecated->f.ConvolutionFilter1D(target, internalformat, width, format, type, image);
-}
-
-inline void QOpenGLFunctions_1_4::glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
-{
-    d_1_2_Deprecated->f.CopyColorSubTable(target, start, x, y, width);
-}
-
-inline void QOpenGLFunctions_1_4::glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data)
-{
-    d_1_2_Deprecated->f.ColorSubTable(target, start, count, format, type, data);
-}
-
-inline void QOpenGLFunctions_1_4::glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetColorTableParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_4::glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetColorTableParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_4::glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table)
-{
-    d_1_2_Deprecated->f.GetColorTable(target, format, type, table);
-}
-
-inline void QOpenGLFunctions_1_4::glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
-{
-    d_1_2_Deprecated->f.CopyColorTable(target, internalformat, x, y, width);
-}
-
-inline void QOpenGLFunctions_1_4::glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_2_Deprecated->f.ColorTableParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_4::glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_2_Deprecated->f.ColorTableParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_4::glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table)
-{
-    d_1_2_Deprecated->f.ColorTable(target, internalformat, width, format, type, table);
-}
-
-
-// OpenGL 1.3 deprecated functions
-inline void QOpenGLFunctions_1_4::glMultTransposeMatrixd(const GLdouble *m)
-{
-    d_1_3_Deprecated->f.MultTransposeMatrixd(m);
-}
-
-inline void QOpenGLFunctions_1_4::glMultTransposeMatrixf(const GLfloat *m)
-{
-    d_1_3_Deprecated->f.MultTransposeMatrixf(m);
-}
-
-inline void QOpenGLFunctions_1_4::glLoadTransposeMatrixd(const GLdouble *m)
-{
-    d_1_3_Deprecated->f.LoadTransposeMatrixd(m);
-}
-
-inline void QOpenGLFunctions_1_4::glLoadTransposeMatrixf(const GLfloat *m)
-{
-    d_1_3_Deprecated->f.LoadTransposeMatrixf(m);
-}
-
-inline void QOpenGLFunctions_1_4::glMultiTexCoord4sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4sv(target, v);
-}
-
-inline void QOpenGLFunctions_1_4::glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4s(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_1_4::glMultiTexCoord4iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4iv(target, v);
-}
-
-inline void QOpenGLFunctions_1_4::glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4i(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_1_4::glMultiTexCoord4fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4fv(target, v);
-}
-
-inline void QOpenGLFunctions_1_4::glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4f(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_1_4::glMultiTexCoord4dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4dv(target, v);
-}
-
-inline void QOpenGLFunctions_1_4::glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4d(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_1_4::glMultiTexCoord3sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3sv(target, v);
-}
-
-inline void QOpenGLFunctions_1_4::glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3s(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_1_4::glMultiTexCoord3iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3iv(target, v);
-}
-
-inline void QOpenGLFunctions_1_4::glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3i(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_1_4::glMultiTexCoord3fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3fv(target, v);
-}
-
-inline void QOpenGLFunctions_1_4::glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3f(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_1_4::glMultiTexCoord3dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3dv(target, v);
-}
-
-inline void QOpenGLFunctions_1_4::glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3d(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_1_4::glMultiTexCoord2sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2sv(target, v);
-}
-
-inline void QOpenGLFunctions_1_4::glMultiTexCoord2s(GLenum target, GLshort s, GLshort t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2s(target, s, t);
-}
-
-inline void QOpenGLFunctions_1_4::glMultiTexCoord2iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2iv(target, v);
-}
-
-inline void QOpenGLFunctions_1_4::glMultiTexCoord2i(GLenum target, GLint s, GLint t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2i(target, s, t);
-}
-
-inline void QOpenGLFunctions_1_4::glMultiTexCoord2fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2fv(target, v);
-}
-
-inline void QOpenGLFunctions_1_4::glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2f(target, s, t);
-}
-
-inline void QOpenGLFunctions_1_4::glMultiTexCoord2dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2dv(target, v);
-}
-
-inline void QOpenGLFunctions_1_4::glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2d(target, s, t);
-}
-
-inline void QOpenGLFunctions_1_4::glMultiTexCoord1sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1sv(target, v);
-}
-
-inline void QOpenGLFunctions_1_4::glMultiTexCoord1s(GLenum target, GLshort s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1s(target, s);
-}
-
-inline void QOpenGLFunctions_1_4::glMultiTexCoord1iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1iv(target, v);
-}
-
-inline void QOpenGLFunctions_1_4::glMultiTexCoord1i(GLenum target, GLint s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1i(target, s);
-}
-
-inline void QOpenGLFunctions_1_4::glMultiTexCoord1fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1fv(target, v);
-}
-
-inline void QOpenGLFunctions_1_4::glMultiTexCoord1f(GLenum target, GLfloat s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1f(target, s);
-}
-
-inline void QOpenGLFunctions_1_4::glMultiTexCoord1dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1dv(target, v);
-}
-
-inline void QOpenGLFunctions_1_4::glMultiTexCoord1d(GLenum target, GLdouble s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1d(target, s);
-}
-
-inline void QOpenGLFunctions_1_4::glClientActiveTexture(GLenum texture)
-{
-    d_1_3_Deprecated->f.ClientActiveTexture(texture);
-}
-
-
-// OpenGL 1.4 deprecated functions
-inline void QOpenGLFunctions_1_4::glWindowPos3sv(const GLshort *v)
-{
-    d_1_4_Deprecated->f.WindowPos3sv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glWindowPos3s(GLshort x, GLshort y, GLshort z)
-{
-    d_1_4_Deprecated->f.WindowPos3s(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_4::glWindowPos3iv(const GLint *v)
-{
-    d_1_4_Deprecated->f.WindowPos3iv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glWindowPos3i(GLint x, GLint y, GLint z)
-{
-    d_1_4_Deprecated->f.WindowPos3i(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_4::glWindowPos3fv(const GLfloat *v)
-{
-    d_1_4_Deprecated->f.WindowPos3fv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glWindowPos3f(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_4_Deprecated->f.WindowPos3f(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_4::glWindowPos3dv(const GLdouble *v)
-{
-    d_1_4_Deprecated->f.WindowPos3dv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glWindowPos3d(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_4_Deprecated->f.WindowPos3d(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_4::glWindowPos2sv(const GLshort *v)
-{
-    d_1_4_Deprecated->f.WindowPos2sv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glWindowPos2s(GLshort x, GLshort y)
-{
-    d_1_4_Deprecated->f.WindowPos2s(x, y);
-}
-
-inline void QOpenGLFunctions_1_4::glWindowPos2iv(const GLint *v)
-{
-    d_1_4_Deprecated->f.WindowPos2iv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glWindowPos2i(GLint x, GLint y)
-{
-    d_1_4_Deprecated->f.WindowPos2i(x, y);
-}
-
-inline void QOpenGLFunctions_1_4::glWindowPos2fv(const GLfloat *v)
-{
-    d_1_4_Deprecated->f.WindowPos2fv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glWindowPos2f(GLfloat x, GLfloat y)
-{
-    d_1_4_Deprecated->f.WindowPos2f(x, y);
-}
-
-inline void QOpenGLFunctions_1_4::glWindowPos2dv(const GLdouble *v)
-{
-    d_1_4_Deprecated->f.WindowPos2dv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glWindowPos2d(GLdouble x, GLdouble y)
-{
-    d_1_4_Deprecated->f.WindowPos2d(x, y);
-}
-
-inline void QOpenGLFunctions_1_4::glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_4_Deprecated->f.SecondaryColorPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_1_4::glSecondaryColor3usv(const GLushort *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3usv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glSecondaryColor3us(GLushort red, GLushort green, GLushort blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3us(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_4::glSecondaryColor3uiv(const GLuint *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3uiv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3ui(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_4::glSecondaryColor3ubv(const GLubyte *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3ubv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3ub(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_4::glSecondaryColor3sv(const GLshort *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3sv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glSecondaryColor3s(GLshort red, GLshort green, GLshort blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3s(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_4::glSecondaryColor3iv(const GLint *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3iv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glSecondaryColor3i(GLint red, GLint green, GLint blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3i(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_4::glSecondaryColor3fv(const GLfloat *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3fv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3f(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_4::glSecondaryColor3dv(const GLdouble *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3dv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3d(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_4::glSecondaryColor3bv(const GLbyte *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3bv(v);
-}
-
-inline void QOpenGLFunctions_1_4::glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3b(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_4::glFogCoordPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_4_Deprecated->f.FogCoordPointer(type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_1_4::glFogCoorddv(const GLdouble *coord)
-{
-    d_1_4_Deprecated->f.FogCoorddv(coord);
-}
-
-inline void QOpenGLFunctions_1_4::glFogCoordd(GLdouble coord)
-{
-    d_1_4_Deprecated->f.FogCoordd(coord);
-}
-
-inline void QOpenGLFunctions_1_4::glFogCoordfv(const GLfloat *coord)
-{
-    d_1_4_Deprecated->f.FogCoordfv(coord);
-}
-
-inline void QOpenGLFunctions_1_4::glFogCoordf(GLfloat coord)
-{
-    d_1_4_Deprecated->f.FogCoordf(coord);
-}
-
-
-
-QT_END_NAMESPACE
-
-#endif // QT_NO_OPENGL && !QT_OPENGL_ES_2
-
-#endif
diff --git a/src/gui/opengl/qopenglfunctions_1_5.cpp b/src/gui/opengl/qopenglfunctions_1_5.cpp
deleted file mode 100644
index 3fa7668a36..0000000000
--- a/src/gui/opengl/qopenglfunctions_1_5.cpp
+++ /dev/null
@@ -1,217 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#include "qopenglfunctions_1_5.h"
-#include "qopenglcontext.h"
-
-QT_BEGIN_NAMESPACE
-
-/*!
-    \class QOpenGLFunctions_1_5
-    \inmodule QtGui
-    \since 5.1
-    \wrapper
-    \brief The QOpenGLFunctions_1_5 class provides all functions for OpenGL 1.5 specification.
-
-    This class is a wrapper for functions from OpenGL 1.5 specification.
-    See reference pages on \l {http://www.opengl.org/sdk/docs/}{opengl.org}
-    for function documentation.
-
-    \sa QAbstractOpenGLFunctions
-*/
-
-QOpenGLFunctions_1_5::QOpenGLFunctions_1_5()
- : QAbstractOpenGLFunctions()
- , d_1_0_Core(nullptr)
- , d_1_1_Core(nullptr)
- , d_1_2_Core(nullptr)
- , d_1_3_Core(nullptr)
- , d_1_4_Core(nullptr)
- , d_1_5_Core(nullptr)
- , d_1_0_Deprecated(nullptr)
- , d_1_1_Deprecated(nullptr)
- , d_1_2_Deprecated(nullptr)
- , d_1_3_Deprecated(nullptr)
- , d_1_4_Deprecated(nullptr)
-{
-}
-
-QOpenGLFunctions_1_5::~QOpenGLFunctions_1_5()
-{
-    if (d_1_0_Core) {
-        d_1_0_Core->refs.deref();
-        Q_ASSERT(d_1_0_Core->refs.loadRelaxed());
-    }
-    if (d_1_1_Core) {
-        d_1_1_Core->refs.deref();
-        Q_ASSERT(d_1_1_Core->refs.loadRelaxed());
-    }
-    if (d_1_2_Core) {
-        d_1_2_Core->refs.deref();
-        Q_ASSERT(d_1_2_Core->refs.loadRelaxed());
-    }
-    if (d_1_3_Core) {
-        d_1_3_Core->refs.deref();
-        Q_ASSERT(d_1_3_Core->refs.loadRelaxed());
-    }
-    if (d_1_4_Core) {
-        d_1_4_Core->refs.deref();
-        Q_ASSERT(d_1_4_Core->refs.loadRelaxed());
-    }
-    if (d_1_5_Core) {
-        d_1_5_Core->refs.deref();
-        Q_ASSERT(d_1_5_Core->refs.loadRelaxed());
-    }
-    if (d_1_0_Deprecated) {
-        d_1_0_Deprecated->refs.deref();
-        Q_ASSERT(d_1_0_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_1_Deprecated) {
-        d_1_1_Deprecated->refs.deref();
-        Q_ASSERT(d_1_1_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_2_Deprecated) {
-        d_1_2_Deprecated->refs.deref();
-        Q_ASSERT(d_1_2_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_3_Deprecated) {
-        d_1_3_Deprecated->refs.deref();
-        Q_ASSERT(d_1_3_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_4_Deprecated) {
-        d_1_4_Deprecated->refs.deref();
-        Q_ASSERT(d_1_4_Deprecated->refs.loadRelaxed());
-    }
-}
-
-bool QOpenGLFunctions_1_5::initializeOpenGLFunctions()
-{
-    if ( isInitialized() )
-        return true;
-
-    QOpenGLContext* context = QOpenGLContext::currentContext();
-
-    // If owned by a context object make sure it is current.
-    // Also check that current context is capable of resolving all needed functions
-    if (((owningContext() && owningContext() == context) || !owningContext())
-        && QOpenGLFunctions_1_5::isContextCompatible(context))
-    {
-        // Associate with private implementation, creating if necessary
-        // Function pointers in the backends are resolved at creation time
-        QOpenGLVersionFunctionsBackend* d = nullptr;
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        d_1_3_Core = static_cast<QOpenGLFunctions_1_3_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        d_1_4_Core = static_cast<QOpenGLFunctions_1_4_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        d_1_5_Core = static_cast<QOpenGLFunctions_1_5_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
-        d_1_0_Deprecated = static_cast<QOpenGLFunctions_1_0_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
-        d_1_1_Deprecated = static_cast<QOpenGLFunctions_1_1_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus());
-        d_1_2_Deprecated = static_cast<QOpenGLFunctions_1_2_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus());
-        d_1_3_Deprecated = static_cast<QOpenGLFunctions_1_3_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
-        d_1_4_Deprecated = static_cast<QOpenGLFunctions_1_4_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        QAbstractOpenGLFunctions::initializeOpenGLFunctions();
-    }
-    return isInitialized();
-}
-
-bool QOpenGLFunctions_1_5::isContextCompatible(QOpenGLContext *context)
-{
-    Q_ASSERT(context);
-    QSurfaceFormat f = context->format();
-    const QPair<int, int> v = qMakePair(f.majorVersion(), f.minorVersion());
-    if (v < qMakePair(1, 5))
-        return false;
-
-    if (f.profile() == QSurfaceFormat::CoreProfile)
-        return false;
-
-    return true;
-}
-
-QOpenGLVersionProfile QOpenGLFunctions_1_5::versionProfile()
-{
-    QOpenGLVersionProfile v;
-    v.setVersion(1, 5);
-    return v;
-}
-
-QT_END_NAMESPACE
diff --git a/src/gui/opengl/qopenglfunctions_1_5.h b/src/gui/opengl/qopenglfunctions_1_5.h
deleted file mode 100644
index d2f5311211..0000000000
--- a/src/gui/opengl/qopenglfunctions_1_5.h
+++ /dev/null
@@ -1,3046 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#ifndef QOPENGLVERSIONFUNCTIONS_1_5_H
-#define QOPENGLVERSIONFUNCTIONS_1_5_H
-
-#include <QtGui/qtguiglobal.h>
-
-#if !defined(QT_NO_OPENGL) && !defined(QT_OPENGL_ES_2)
-
-#include <QtGui/QOpenGLVersionFunctions>
-#include <QtGui/qopenglcontext.h>
-
-QT_BEGIN_NAMESPACE
-
-class Q_GUI_EXPORT QOpenGLFunctions_1_5 : public QAbstractOpenGLFunctions
-{
-public:
-    QOpenGLFunctions_1_5();
-    ~QOpenGLFunctions_1_5();
-
-    bool initializeOpenGLFunctions() override;
-
-    // OpenGL 1.0 core functions
-    void glViewport(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glDepthRange(GLdouble nearVal, GLdouble farVal);
-    GLboolean glIsEnabled(GLenum cap);
-    void glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params);
-    void glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params);
-    void glGetTexParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
-    const GLubyte * glGetString(GLenum name);
-    void glGetIntegerv(GLenum pname, GLint *params);
-    void glGetFloatv(GLenum pname, GLfloat *params);
-    GLenum glGetError();
-    void glGetDoublev(GLenum pname, GLdouble *params);
-    void glGetBooleanv(GLenum pname, GLboolean *params);
-    void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
-    void glReadBuffer(GLenum mode);
-    void glPixelStorei(GLenum pname, GLint param);
-    void glPixelStoref(GLenum pname, GLfloat param);
-    void glDepthFunc(GLenum func);
-    void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass);
-    void glStencilFunc(GLenum func, GLint ref, GLuint mask);
-    void glLogicOp(GLenum opcode);
-    void glBlendFunc(GLenum sfactor, GLenum dfactor);
-    void glFlush();
-    void glFinish();
-    void glEnable(GLenum cap);
-    void glDisable(GLenum cap);
-    void glDepthMask(GLboolean flag);
-    void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
-    void glStencilMask(GLuint mask);
-    void glClearDepth(GLdouble depth);
-    void glClearStencil(GLint s);
-    void glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glClear(GLbitfield mask);
-    void glDrawBuffer(GLenum mode);
-    void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glTexParameteri(GLenum target, GLenum pname, GLint param);
-    void glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glTexParameterf(GLenum target, GLenum pname, GLfloat param);
-    void glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glPolygonMode(GLenum face, GLenum mode);
-    void glPointSize(GLfloat size);
-    void glLineWidth(GLfloat width);
-    void glHint(GLenum target, GLenum mode);
-    void glFrontFace(GLenum mode);
-    void glCullFace(GLenum mode);
-
-    // OpenGL 1.1 core functions
-    void glIndexubv(const GLubyte *c);
-    void glIndexub(GLubyte c);
-    GLboolean glIsTexture(GLuint texture);
-    void glGenTextures(GLsizei n, GLuint *textures);
-    void glDeleteTextures(GLsizei n, const GLuint *textures);
-    void glBindTexture(GLenum target, GLuint texture);
-    void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
-    void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
-    void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
-    void glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
-    void glPolygonOffset(GLfloat factor, GLfloat units);
-    void glGetPointerv(GLenum pname, GLvoid* *params);
-    void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
-    void glDrawArrays(GLenum mode, GLint first, GLsizei count);
-
-    // OpenGL 1.2 core functions
-    void glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices);
-    void glBlendEquation(GLenum mode);
-    void glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-
-    // OpenGL 1.3 core functions
-    void glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img);
-    void glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glSampleCoverage(GLfloat value, GLboolean invert);
-    void glActiveTexture(GLenum texture);
-
-    // OpenGL 1.4 core functions
-    void glPointParameteriv(GLenum pname, const GLint *params);
-    void glPointParameteri(GLenum pname, GLint param);
-    void glPointParameterfv(GLenum pname, const GLfloat *params);
-    void glPointParameterf(GLenum pname, GLfloat param);
-    void glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount);
-    void glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount);
-    void glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
-
-    // OpenGL 1.5 core functions
-    void glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params);
-    void glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params);
-    GLboolean glUnmapBuffer(GLenum target);
-    GLvoid* glMapBuffer(GLenum target, GLenum access);
-    void glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data);
-    void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data);
-    void glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage);
-    GLboolean glIsBuffer(GLuint buffer);
-    void glGenBuffers(GLsizei n, GLuint *buffers);
-    void glDeleteBuffers(GLsizei n, const GLuint *buffers);
-    void glBindBuffer(GLenum target, GLuint buffer);
-    void glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params);
-    void glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params);
-    void glGetQueryiv(GLenum target, GLenum pname, GLint *params);
-    void glEndQuery(GLenum target);
-    void glBeginQuery(GLenum target, GLuint id);
-    GLboolean glIsQuery(GLuint id);
-    void glDeleteQueries(GLsizei n, const GLuint *ids);
-    void glGenQueries(GLsizei n, GLuint *ids);
-
-    // OpenGL 1.0 deprecated functions
-    void glTranslatef(GLfloat x, GLfloat y, GLfloat z);
-    void glTranslated(GLdouble x, GLdouble y, GLdouble z);
-    void glScalef(GLfloat x, GLfloat y, GLfloat z);
-    void glScaled(GLdouble x, GLdouble y, GLdouble z);
-    void glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
-    void glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
-    void glPushMatrix();
-    void glPopMatrix();
-    void glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
-    void glMultMatrixd(const GLdouble *m);
-    void glMultMatrixf(const GLfloat *m);
-    void glMatrixMode(GLenum mode);
-    void glLoadMatrixd(const GLdouble *m);
-    void glLoadMatrixf(const GLfloat *m);
-    void glLoadIdentity();
-    void glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
-    GLboolean glIsList(GLuint list);
-    void glGetTexGeniv(GLenum coord, GLenum pname, GLint *params);
-    void glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params);
-    void glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params);
-    void glGetTexEnviv(GLenum target, GLenum pname, GLint *params);
-    void glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetPolygonStipple(GLubyte *mask);
-    void glGetPixelMapusv(GLenum map, GLushort *values);
-    void glGetPixelMapuiv(GLenum map, GLuint *values);
-    void glGetPixelMapfv(GLenum map, GLfloat *values);
-    void glGetMaterialiv(GLenum face, GLenum pname, GLint *params);
-    void glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params);
-    void glGetMapiv(GLenum target, GLenum query, GLint *v);
-    void glGetMapfv(GLenum target, GLenum query, GLfloat *v);
-    void glGetMapdv(GLenum target, GLenum query, GLdouble *v);
-    void glGetLightiv(GLenum light, GLenum pname, GLint *params);
-    void glGetLightfv(GLenum light, GLenum pname, GLfloat *params);
-    void glGetClipPlane(GLenum plane, GLdouble *equation);
-    void glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
-    void glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
-    void glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values);
-    void glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values);
-    void glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values);
-    void glPixelTransferi(GLenum pname, GLint param);
-    void glPixelTransferf(GLenum pname, GLfloat param);
-    void glPixelZoom(GLfloat xfactor, GLfloat yfactor);
-    void glAlphaFunc(GLenum func, GLfloat ref);
-    void glEvalPoint2(GLint i, GLint j);
-    void glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
-    void glEvalPoint1(GLint i);
-    void glEvalMesh1(GLenum mode, GLint i1, GLint i2);
-    void glEvalCoord2fv(const GLfloat *u);
-    void glEvalCoord2f(GLfloat u, GLfloat v);
-    void glEvalCoord2dv(const GLdouble *u);
-    void glEvalCoord2d(GLdouble u, GLdouble v);
-    void glEvalCoord1fv(const GLfloat *u);
-    void glEvalCoord1f(GLfloat u);
-    void glEvalCoord1dv(const GLdouble *u);
-    void glEvalCoord1d(GLdouble u);
-    void glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
-    void glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
-    void glMapGrid1f(GLint un, GLfloat u1, GLfloat u2);
-    void glMapGrid1d(GLint un, GLdouble u1, GLdouble u2);
-    void glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);
-    void glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);
-    void glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);
-    void glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);
-    void glPushAttrib(GLbitfield mask);
-    void glPopAttrib();
-    void glAccum(GLenum op, GLfloat value);
-    void glIndexMask(GLuint mask);
-    void glClearIndex(GLfloat c);
-    void glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glPushName(GLuint name);
-    void glPopName();
-    void glPassThrough(GLfloat token);
-    void glLoadName(GLuint name);
-    void glInitNames();
-    GLint glRenderMode(GLenum mode);
-    void glSelectBuffer(GLsizei size, GLuint *buffer);
-    void glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer);
-    void glTexGeniv(GLenum coord, GLenum pname, const GLint *params);
-    void glTexGeni(GLenum coord, GLenum pname, GLint param);
-    void glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params);
-    void glTexGenf(GLenum coord, GLenum pname, GLfloat param);
-    void glTexGendv(GLenum coord, GLenum pname, const GLdouble *params);
-    void glTexGend(GLenum coord, GLenum pname, GLdouble param);
-    void glTexEnviv(GLenum target, GLenum pname, const GLint *params);
-    void glTexEnvi(GLenum target, GLenum pname, GLint param);
-    void glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glTexEnvf(GLenum target, GLenum pname, GLfloat param);
-    void glShadeModel(GLenum mode);
-    void glPolygonStipple(const GLubyte *mask);
-    void glMaterialiv(GLenum face, GLenum pname, const GLint *params);
-    void glMateriali(GLenum face, GLenum pname, GLint param);
-    void glMaterialfv(GLenum face, GLenum pname, const GLfloat *params);
-    void glMaterialf(GLenum face, GLenum pname, GLfloat param);
-    void glLineStipple(GLint factor, GLushort pattern);
-    void glLightModeliv(GLenum pname, const GLint *params);
-    void glLightModeli(GLenum pname, GLint param);
-    void glLightModelfv(GLenum pname, const GLfloat *params);
-    void glLightModelf(GLenum pname, GLfloat param);
-    void glLightiv(GLenum light, GLenum pname, const GLint *params);
-    void glLighti(GLenum light, GLenum pname, GLint param);
-    void glLightfv(GLenum light, GLenum pname, const GLfloat *params);
-    void glLightf(GLenum light, GLenum pname, GLfloat param);
-    void glFogiv(GLenum pname, const GLint *params);
-    void glFogi(GLenum pname, GLint param);
-    void glFogfv(GLenum pname, const GLfloat *params);
-    void glFogf(GLenum pname, GLfloat param);
-    void glColorMaterial(GLenum face, GLenum mode);
-    void glClipPlane(GLenum plane, const GLdouble *equation);
-    void glVertex4sv(const GLshort *v);
-    void glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w);
-    void glVertex4iv(const GLint *v);
-    void glVertex4i(GLint x, GLint y, GLint z, GLint w);
-    void glVertex4fv(const GLfloat *v);
-    void glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void glVertex4dv(const GLdouble *v);
-    void glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glVertex3sv(const GLshort *v);
-    void glVertex3s(GLshort x, GLshort y, GLshort z);
-    void glVertex3iv(const GLint *v);
-    void glVertex3i(GLint x, GLint y, GLint z);
-    void glVertex3fv(const GLfloat *v);
-    void glVertex3f(GLfloat x, GLfloat y, GLfloat z);
-    void glVertex3dv(const GLdouble *v);
-    void glVertex3d(GLdouble x, GLdouble y, GLdouble z);
-    void glVertex2sv(const GLshort *v);
-    void glVertex2s(GLshort x, GLshort y);
-    void glVertex2iv(const GLint *v);
-    void glVertex2i(GLint x, GLint y);
-    void glVertex2fv(const GLfloat *v);
-    void glVertex2f(GLfloat x, GLfloat y);
-    void glVertex2dv(const GLdouble *v);
-    void glVertex2d(GLdouble x, GLdouble y);
-    void glTexCoord4sv(const GLshort *v);
-    void glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q);
-    void glTexCoord4iv(const GLint *v);
-    void glTexCoord4i(GLint s, GLint t, GLint r, GLint q);
-    void glTexCoord4fv(const GLfloat *v);
-    void glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
-    void glTexCoord4dv(const GLdouble *v);
-    void glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q);
-    void glTexCoord3sv(const GLshort *v);
-    void glTexCoord3s(GLshort s, GLshort t, GLshort r);
-    void glTexCoord3iv(const GLint *v);
-    void glTexCoord3i(GLint s, GLint t, GLint r);
-    void glTexCoord3fv(const GLfloat *v);
-    void glTexCoord3f(GLfloat s, GLfloat t, GLfloat r);
-    void glTexCoord3dv(const GLdouble *v);
-    void glTexCoord3d(GLdouble s, GLdouble t, GLdouble r);
-    void glTexCoord2sv(const GLshort *v);
-    void glTexCoord2s(GLshort s, GLshort t);
-    void glTexCoord2iv(const GLint *v);
-    void glTexCoord2i(GLint s, GLint t);
-    void glTexCoord2fv(const GLfloat *v);
-    void glTexCoord2f(GLfloat s, GLfloat t);
-    void glTexCoord2dv(const GLdouble *v);
-    void glTexCoord2d(GLdouble s, GLdouble t);
-    void glTexCoord1sv(const GLshort *v);
-    void glTexCoord1s(GLshort s);
-    void glTexCoord1iv(const GLint *v);
-    void glTexCoord1i(GLint s);
-    void glTexCoord1fv(const GLfloat *v);
-    void glTexCoord1f(GLfloat s);
-    void glTexCoord1dv(const GLdouble *v);
-    void glTexCoord1d(GLdouble s);
-    void glRectsv(const GLshort *v1, const GLshort *v2);
-    void glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
-    void glRectiv(const GLint *v1, const GLint *v2);
-    void glRecti(GLint x1, GLint y1, GLint x2, GLint y2);
-    void glRectfv(const GLfloat *v1, const GLfloat *v2);
-    void glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
-    void glRectdv(const GLdouble *v1, const GLdouble *v2);
-    void glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
-    void glRasterPos4sv(const GLshort *v);
-    void glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w);
-    void glRasterPos4iv(const GLint *v);
-    void glRasterPos4i(GLint x, GLint y, GLint z, GLint w);
-    void glRasterPos4fv(const GLfloat *v);
-    void glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void glRasterPos4dv(const GLdouble *v);
-    void glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glRasterPos3sv(const GLshort *v);
-    void glRasterPos3s(GLshort x, GLshort y, GLshort z);
-    void glRasterPos3iv(const GLint *v);
-    void glRasterPos3i(GLint x, GLint y, GLint z);
-    void glRasterPos3fv(const GLfloat *v);
-    void glRasterPos3f(GLfloat x, GLfloat y, GLfloat z);
-    void glRasterPos3dv(const GLdouble *v);
-    void glRasterPos3d(GLdouble x, GLdouble y, GLdouble z);
-    void glRasterPos2sv(const GLshort *v);
-    void glRasterPos2s(GLshort x, GLshort y);
-    void glRasterPos2iv(const GLint *v);
-    void glRasterPos2i(GLint x, GLint y);
-    void glRasterPos2fv(const GLfloat *v);
-    void glRasterPos2f(GLfloat x, GLfloat y);
-    void glRasterPos2dv(const GLdouble *v);
-    void glRasterPos2d(GLdouble x, GLdouble y);
-    void glNormal3sv(const GLshort *v);
-    void glNormal3s(GLshort nx, GLshort ny, GLshort nz);
-    void glNormal3iv(const GLint *v);
-    void glNormal3i(GLint nx, GLint ny, GLint nz);
-    void glNormal3fv(const GLfloat *v);
-    void glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz);
-    void glNormal3dv(const GLdouble *v);
-    void glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz);
-    void glNormal3bv(const GLbyte *v);
-    void glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz);
-    void glIndexsv(const GLshort *c);
-    void glIndexs(GLshort c);
-    void glIndexiv(const GLint *c);
-    void glIndexi(GLint c);
-    void glIndexfv(const GLfloat *c);
-    void glIndexf(GLfloat c);
-    void glIndexdv(const GLdouble *c);
-    void glIndexd(GLdouble c);
-    void glEnd();
-    void glEdgeFlagv(const GLboolean *flag);
-    void glEdgeFlag(GLboolean flag);
-    void glColor4usv(const GLushort *v);
-    void glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha);
-    void glColor4uiv(const GLuint *v);
-    void glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha);
-    void glColor4ubv(const GLubyte *v);
-    void glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
-    void glColor4sv(const GLshort *v);
-    void glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha);
-    void glColor4iv(const GLint *v);
-    void glColor4i(GLint red, GLint green, GLint blue, GLint alpha);
-    void glColor4fv(const GLfloat *v);
-    void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glColor4dv(const GLdouble *v);
-    void glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
-    void glColor4bv(const GLbyte *v);
-    void glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
-    void glColor3usv(const GLushort *v);
-    void glColor3us(GLushort red, GLushort green, GLushort blue);
-    void glColor3uiv(const GLuint *v);
-    void glColor3ui(GLuint red, GLuint green, GLuint blue);
-    void glColor3ubv(const GLubyte *v);
-    void glColor3ub(GLubyte red, GLubyte green, GLubyte blue);
-    void glColor3sv(const GLshort *v);
-    void glColor3s(GLshort red, GLshort green, GLshort blue);
-    void glColor3iv(const GLint *v);
-    void glColor3i(GLint red, GLint green, GLint blue);
-    void glColor3fv(const GLfloat *v);
-    void glColor3f(GLfloat red, GLfloat green, GLfloat blue);
-    void glColor3dv(const GLdouble *v);
-    void glColor3d(GLdouble red, GLdouble green, GLdouble blue);
-    void glColor3bv(const GLbyte *v);
-    void glColor3b(GLbyte red, GLbyte green, GLbyte blue);
-    void glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap);
-    void glBegin(GLenum mode);
-    void glListBase(GLuint base);
-    GLuint glGenLists(GLsizei range);
-    void glDeleteLists(GLuint list, GLsizei range);
-    void glCallLists(GLsizei n, GLenum type, const GLvoid *lists);
-    void glCallList(GLuint list);
-    void glEndList();
-    void glNewList(GLuint list, GLenum mode);
-
-    // OpenGL 1.1 deprecated functions
-    void glPushClientAttrib(GLbitfield mask);
-    void glPopClientAttrib();
-    void glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities);
-    GLboolean glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences);
-    void glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer);
-    void glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glEnableClientState(GLenum array);
-    void glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer);
-    void glDisableClientState(GLenum array);
-    void glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glArrayElement(GLint i);
-
-    // OpenGL 1.2 deprecated functions
-    void glResetMinmax(GLenum target);
-    void glResetHistogram(GLenum target);
-    void glMinmax(GLenum target, GLenum internalformat, GLboolean sink);
-    void glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink);
-    void glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
-    void glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
-    void glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column);
-    void glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span);
-    void glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image);
-    void glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
-    void glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glConvolutionParameteri(GLenum target, GLenum pname, GLint params);
-    void glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params);
-    void glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image);
-    void glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image);
-    void glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width);
-    void glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data);
-    void glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table);
-    void glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
-    void glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table);
-
-    // OpenGL 1.3 deprecated functions
-    void glMultTransposeMatrixd(const GLdouble *m);
-    void glMultTransposeMatrixf(const GLfloat *m);
-    void glLoadTransposeMatrixd(const GLdouble *m);
-    void glLoadTransposeMatrixf(const GLfloat *m);
-    void glMultiTexCoord4sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);
-    void glMultiTexCoord4iv(GLenum target, const GLint *v);
-    void glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q);
-    void glMultiTexCoord4fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
-    void glMultiTexCoord4dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
-    void glMultiTexCoord3sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r);
-    void glMultiTexCoord3iv(GLenum target, const GLint *v);
-    void glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r);
-    void glMultiTexCoord3fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r);
-    void glMultiTexCoord3dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r);
-    void glMultiTexCoord2sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord2s(GLenum target, GLshort s, GLshort t);
-    void glMultiTexCoord2iv(GLenum target, const GLint *v);
-    void glMultiTexCoord2i(GLenum target, GLint s, GLint t);
-    void glMultiTexCoord2fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t);
-    void glMultiTexCoord2dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t);
-    void glMultiTexCoord1sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord1s(GLenum target, GLshort s);
-    void glMultiTexCoord1iv(GLenum target, const GLint *v);
-    void glMultiTexCoord1i(GLenum target, GLint s);
-    void glMultiTexCoord1fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord1f(GLenum target, GLfloat s);
-    void glMultiTexCoord1dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord1d(GLenum target, GLdouble s);
-    void glClientActiveTexture(GLenum texture);
-
-    // OpenGL 1.4 deprecated functions
-    void glWindowPos3sv(const GLshort *v);
-    void glWindowPos3s(GLshort x, GLshort y, GLshort z);
-    void glWindowPos3iv(const GLint *v);
-    void glWindowPos3i(GLint x, GLint y, GLint z);
-    void glWindowPos3fv(const GLfloat *v);
-    void glWindowPos3f(GLfloat x, GLfloat y, GLfloat z);
-    void glWindowPos3dv(const GLdouble *v);
-    void glWindowPos3d(GLdouble x, GLdouble y, GLdouble z);
-    void glWindowPos2sv(const GLshort *v);
-    void glWindowPos2s(GLshort x, GLshort y);
-    void glWindowPos2iv(const GLint *v);
-    void glWindowPos2i(GLint x, GLint y);
-    void glWindowPos2fv(const GLfloat *v);
-    void glWindowPos2f(GLfloat x, GLfloat y);
-    void glWindowPos2dv(const GLdouble *v);
-    void glWindowPos2d(GLdouble x, GLdouble y);
-    void glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glSecondaryColor3usv(const GLushort *v);
-    void glSecondaryColor3us(GLushort red, GLushort green, GLushort blue);
-    void glSecondaryColor3uiv(const GLuint *v);
-    void glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue);
-    void glSecondaryColor3ubv(const GLubyte *v);
-    void glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue);
-    void glSecondaryColor3sv(const GLshort *v);
-    void glSecondaryColor3s(GLshort red, GLshort green, GLshort blue);
-    void glSecondaryColor3iv(const GLint *v);
-    void glSecondaryColor3i(GLint red, GLint green, GLint blue);
-    void glSecondaryColor3fv(const GLfloat *v);
-    void glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue);
-    void glSecondaryColor3dv(const GLdouble *v);
-    void glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue);
-    void glSecondaryColor3bv(const GLbyte *v);
-    void glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue);
-    void glFogCoordPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glFogCoorddv(const GLdouble *coord);
-    void glFogCoordd(GLdouble coord);
-    void glFogCoordfv(const GLfloat *coord);
-    void glFogCoordf(GLfloat coord);
-
-    // OpenGL 1.5 deprecated functions
-
-private:
-    friend class QOpenGLContext;
-
-    static bool isContextCompatible(QOpenGLContext *context);
-    static QOpenGLVersionProfile versionProfile();
-
-    QOpenGLFunctions_1_0_CoreBackend* d_1_0_Core;
-    QOpenGLFunctions_1_1_CoreBackend* d_1_1_Core;
-    QOpenGLFunctions_1_2_CoreBackend* d_1_2_Core;
-    QOpenGLFunctions_1_3_CoreBackend* d_1_3_Core;
-    QOpenGLFunctions_1_4_CoreBackend* d_1_4_Core;
-    QOpenGLFunctions_1_5_CoreBackend* d_1_5_Core;
-    QOpenGLFunctions_1_0_DeprecatedBackend* d_1_0_Deprecated;
-    QOpenGLFunctions_1_1_DeprecatedBackend* d_1_1_Deprecated;
-    QOpenGLFunctions_1_2_DeprecatedBackend* d_1_2_Deprecated;
-    QOpenGLFunctions_1_3_DeprecatedBackend* d_1_3_Deprecated;
-    QOpenGLFunctions_1_4_DeprecatedBackend* d_1_4_Deprecated;
-};
-
-// OpenGL 1.0 core functions
-inline void QOpenGLFunctions_1_5::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_0_Core->f.Viewport(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_1_5::glDepthRange(GLdouble nearVal, GLdouble farVal)
-{
-    d_1_0_Core->f.DepthRange(nearVal, farVal);
-}
-
-inline GLboolean QOpenGLFunctions_1_5::glIsEnabled(GLenum cap)
-{
-    return d_1_0_Core->f.IsEnabled(cap);
-}
-
-inline void QOpenGLFunctions_1_5::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
-}
-
-inline void QOpenGLFunctions_1_5::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
-}
-
-inline void QOpenGLFunctions_1_5::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetTexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_5::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetTexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_5::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
-{
-    d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
-}
-
-inline const GLubyte * QOpenGLFunctions_1_5::glGetString(GLenum name)
-{
-    return d_1_0_Core->f.GetString(name);
-}
-
-inline void QOpenGLFunctions_1_5::glGetIntegerv(GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetIntegerv(pname, params);
-}
-
-inline void QOpenGLFunctions_1_5::glGetFloatv(GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetFloatv(pname, params);
-}
-
-inline GLenum QOpenGLFunctions_1_5::glGetError()
-{
-    return d_1_0_Core->f.GetError();
-}
-
-inline void QOpenGLFunctions_1_5::glGetDoublev(GLenum pname, GLdouble *params)
-{
-    d_1_0_Core->f.GetDoublev(pname, params);
-}
-
-inline void QOpenGLFunctions_1_5::glGetBooleanv(GLenum pname, GLboolean *params)
-{
-    d_1_0_Core->f.GetBooleanv(pname, params);
-}
-
-inline void QOpenGLFunctions_1_5::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
-{
-    d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_1_5::glReadBuffer(GLenum mode)
-{
-    d_1_0_Core->f.ReadBuffer(mode);
-}
-
-inline void QOpenGLFunctions_1_5::glPixelStorei(GLenum pname, GLint param)
-{
-    d_1_0_Core->f.PixelStorei(pname, param);
-}
-
-inline void QOpenGLFunctions_1_5::glPixelStoref(GLenum pname, GLfloat param)
-{
-    d_1_0_Core->f.PixelStoref(pname, param);
-}
-
-inline void QOpenGLFunctions_1_5::glDepthFunc(GLenum func)
-{
-    d_1_0_Core->f.DepthFunc(func);
-}
-
-inline void QOpenGLFunctions_1_5::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
-{
-    d_1_0_Core->f.StencilOp(fail, zfail, zpass);
-}
-
-inline void QOpenGLFunctions_1_5::glStencilFunc(GLenum func, GLint ref, GLuint mask)
-{
-    d_1_0_Core->f.StencilFunc(func, ref, mask);
-}
-
-inline void QOpenGLFunctions_1_5::glLogicOp(GLenum opcode)
-{
-    d_1_0_Core->f.LogicOp(opcode);
-}
-
-inline void QOpenGLFunctions_1_5::glBlendFunc(GLenum sfactor, GLenum dfactor)
-{
-    d_1_0_Core->f.BlendFunc(sfactor, dfactor);
-}
-
-inline void QOpenGLFunctions_1_5::glFlush()
-{
-    d_1_0_Core->f.Flush();
-}
-
-inline void QOpenGLFunctions_1_5::glFinish()
-{
-    d_1_0_Core->f.Finish();
-}
-
-inline void QOpenGLFunctions_1_5::glEnable(GLenum cap)
-{
-    d_1_0_Core->f.Enable(cap);
-}
-
-inline void QOpenGLFunctions_1_5::glDisable(GLenum cap)
-{
-    d_1_0_Core->f.Disable(cap);
-}
-
-inline void QOpenGLFunctions_1_5::glDepthMask(GLboolean flag)
-{
-    d_1_0_Core->f.DepthMask(flag);
-}
-
-inline void QOpenGLFunctions_1_5::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
-{
-    d_1_0_Core->f.ColorMask(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_5::glStencilMask(GLuint mask)
-{
-    d_1_0_Core->f.StencilMask(mask);
-}
-
-inline void QOpenGLFunctions_1_5::glClearDepth(GLdouble depth)
-{
-    d_1_0_Core->f.ClearDepth(depth);
-}
-
-inline void QOpenGLFunctions_1_5::glClearStencil(GLint s)
-{
-    d_1_0_Core->f.ClearStencil(s);
-}
-
-inline void QOpenGLFunctions_1_5::glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Core->f.ClearColor(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_5::glClear(GLbitfield mask)
-{
-    d_1_0_Core->f.Clear(mask);
-}
-
-inline void QOpenGLFunctions_1_5::glDrawBuffer(GLenum mode)
-{
-    d_1_0_Core->f.DrawBuffer(mode);
-}
-
-inline void QOpenGLFunctions_1_5::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Core->f.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_1_5::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Core->f.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_1_5::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_0_Core->f.TexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_5::glTexParameteri(GLenum target, GLenum pname, GLint param)
-{
-    d_1_0_Core->f.TexParameteri(target, pname, param);
-}
-
-inline void QOpenGLFunctions_1_5::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Core->f.TexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_5::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
-{
-    d_1_0_Core->f.TexParameterf(target, pname, param);
-}
-
-inline void QOpenGLFunctions_1_5::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_0_Core->f.Scissor(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_1_5::glPolygonMode(GLenum face, GLenum mode)
-{
-    d_1_0_Core->f.PolygonMode(face, mode);
-}
-
-inline void QOpenGLFunctions_1_5::glPointSize(GLfloat size)
-{
-    d_1_0_Core->f.PointSize(size);
-}
-
-inline void QOpenGLFunctions_1_5::glLineWidth(GLfloat width)
-{
-    d_1_0_Core->f.LineWidth(width);
-}
-
-inline void QOpenGLFunctions_1_5::glHint(GLenum target, GLenum mode)
-{
-    d_1_0_Core->f.Hint(target, mode);
-}
-
-inline void QOpenGLFunctions_1_5::glFrontFace(GLenum mode)
-{
-    d_1_0_Core->f.FrontFace(mode);
-}
-
-inline void QOpenGLFunctions_1_5::glCullFace(GLenum mode)
-{
-    d_1_0_Core->f.CullFace(mode);
-}
-
-
-// OpenGL 1.1 core functions
-inline void QOpenGLFunctions_1_5::glIndexubv(const GLubyte *c)
-{
-    d_1_1_Deprecated->f.Indexubv(c);
-}
-
-inline void QOpenGLFunctions_1_5::glIndexub(GLubyte c)
-{
-    d_1_1_Deprecated->f.Indexub(c);
-}
-
-inline GLboolean QOpenGLFunctions_1_5::glIsTexture(GLuint texture)
-{
-    return d_1_1_Core->f.IsTexture(texture);
-}
-
-inline void QOpenGLFunctions_1_5::glGenTextures(GLsizei n, GLuint *textures)
-{
-    d_1_1_Core->f.GenTextures(n, textures);
-}
-
-inline void QOpenGLFunctions_1_5::glDeleteTextures(GLsizei n, const GLuint *textures)
-{
-    d_1_1_Core->f.DeleteTextures(n, textures);
-}
-
-inline void QOpenGLFunctions_1_5::glBindTexture(GLenum target, GLuint texture)
-{
-    d_1_1_Core->f.BindTexture(target, texture);
-}
-
-inline void QOpenGLFunctions_1_5::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_1_Core->f.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_1_5::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_1_Core->f.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_1_5::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_1_Core->f.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_1_5::glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
-{
-    d_1_1_Core->f.CopyTexSubImage1D(target, level, xoffset, x, y, width);
-}
-
-inline void QOpenGLFunctions_1_5::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
-{
-    d_1_1_Core->f.CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
-}
-
-inline void QOpenGLFunctions_1_5::glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
-{
-    d_1_1_Core->f.CopyTexImage1D(target, level, internalformat, x, y, width, border);
-}
-
-inline void QOpenGLFunctions_1_5::glPolygonOffset(GLfloat factor, GLfloat units)
-{
-    d_1_1_Core->f.PolygonOffset(factor, units);
-}
-
-inline void QOpenGLFunctions_1_5::glGetPointerv(GLenum pname, GLvoid* *params)
-{
-    d_1_1_Deprecated->f.GetPointerv(pname, params);
-}
-
-inline void QOpenGLFunctions_1_5::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
-{
-    d_1_1_Core->f.DrawElements(mode, count, type, indices);
-}
-
-inline void QOpenGLFunctions_1_5::glDrawArrays(GLenum mode, GLint first, GLsizei count)
-{
-    d_1_1_Core->f.DrawArrays(mode, first, count);
-}
-
-
-// OpenGL 1.2 core functions
-inline void QOpenGLFunctions_1_5::glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_2_Core->f.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_1_5::glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_2_Core->f.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_1_5::glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_2_Core->f.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_1_5::glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
-{
-    d_1_2_Core->f.DrawRangeElements(mode, start, end, count, type, indices);
-}
-
-inline void QOpenGLFunctions_1_5::glBlendEquation(GLenum mode)
-{
-    d_1_2_Core->f.BlendEquation(mode);
-}
-
-inline void QOpenGLFunctions_1_5::glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_2_Core->f.BlendColor(red, green, blue, alpha);
-}
-
-
-// OpenGL 1.3 core functions
-inline void QOpenGLFunctions_1_5::glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img)
-{
-    d_1_3_Core->f.GetCompressedTexImage(target, level, img);
-}
-
-inline void QOpenGLFunctions_1_5::glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_1_5::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_1_5::glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_1_5::glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_1_5::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_1_5::glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_1_5::glSampleCoverage(GLfloat value, GLboolean invert)
-{
-    d_1_3_Core->f.SampleCoverage(value, invert);
-}
-
-inline void QOpenGLFunctions_1_5::glActiveTexture(GLenum texture)
-{
-    d_1_3_Core->f.ActiveTexture(texture);
-}
-
-
-// OpenGL 1.4 core functions
-inline void QOpenGLFunctions_1_5::glPointParameteriv(GLenum pname, const GLint *params)
-{
-    d_1_4_Core->f.PointParameteriv(pname, params);
-}
-
-inline void QOpenGLFunctions_1_5::glPointParameteri(GLenum pname, GLint param)
-{
-    d_1_4_Core->f.PointParameteri(pname, param);
-}
-
-inline void QOpenGLFunctions_1_5::glPointParameterfv(GLenum pname, const GLfloat *params)
-{
-    d_1_4_Core->f.PointParameterfv(pname, params);
-}
-
-inline void QOpenGLFunctions_1_5::glPointParameterf(GLenum pname, GLfloat param)
-{
-    d_1_4_Core->f.PointParameterf(pname, param);
-}
-
-inline void QOpenGLFunctions_1_5::glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount)
-{
-    d_1_4_Core->f.MultiDrawElements(mode, count, type, indices, drawcount);
-}
-
-inline void QOpenGLFunctions_1_5::glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
-{
-    d_1_4_Core->f.MultiDrawArrays(mode, first, count, drawcount);
-}
-
-inline void QOpenGLFunctions_1_5::glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
-{
-    d_1_4_Core->f.BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
-}
-
-
-// OpenGL 1.5 core functions
-inline void QOpenGLFunctions_1_5::glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params)
-{
-    d_1_5_Core->f.GetBufferPointerv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_5::glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetBufferParameteriv(target, pname, params);
-}
-
-inline GLboolean QOpenGLFunctions_1_5::glUnmapBuffer(GLenum target)
-{
-    return d_1_5_Core->f.UnmapBuffer(target);
-}
-
-inline GLvoid* QOpenGLFunctions_1_5::glMapBuffer(GLenum target, GLenum access)
-{
-    return d_1_5_Core->f.MapBuffer(target, access);
-}
-
-inline void QOpenGLFunctions_1_5::glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data)
-{
-    d_1_5_Core->f.GetBufferSubData(target, offset, size, data);
-}
-
-inline void QOpenGLFunctions_1_5::glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data)
-{
-    d_1_5_Core->f.BufferSubData(target, offset, size, data);
-}
-
-inline void QOpenGLFunctions_1_5::glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)
-{
-    d_1_5_Core->f.BufferData(target, size, data, usage);
-}
-
-inline GLboolean QOpenGLFunctions_1_5::glIsBuffer(GLuint buffer)
-{
-    return d_1_5_Core->f.IsBuffer(buffer);
-}
-
-inline void QOpenGLFunctions_1_5::glGenBuffers(GLsizei n, GLuint *buffers)
-{
-    d_1_5_Core->f.GenBuffers(n, buffers);
-}
-
-inline void QOpenGLFunctions_1_5::glDeleteBuffers(GLsizei n, const GLuint *buffers)
-{
-    d_1_5_Core->f.DeleteBuffers(n, buffers);
-}
-
-inline void QOpenGLFunctions_1_5::glBindBuffer(GLenum target, GLuint buffer)
-{
-    d_1_5_Core->f.BindBuffer(target, buffer);
-}
-
-inline void QOpenGLFunctions_1_5::glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
-{
-    d_1_5_Core->f.GetQueryObjectuiv(id, pname, params);
-}
-
-inline void QOpenGLFunctions_1_5::glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetQueryObjectiv(id, pname, params);
-}
-
-inline void QOpenGLFunctions_1_5::glGetQueryiv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetQueryiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_5::glEndQuery(GLenum target)
-{
-    d_1_5_Core->f.EndQuery(target);
-}
-
-inline void QOpenGLFunctions_1_5::glBeginQuery(GLenum target, GLuint id)
-{
-    d_1_5_Core->f.BeginQuery(target, id);
-}
-
-inline GLboolean QOpenGLFunctions_1_5::glIsQuery(GLuint id)
-{
-    return d_1_5_Core->f.IsQuery(id);
-}
-
-inline void QOpenGLFunctions_1_5::glDeleteQueries(GLsizei n, const GLuint *ids)
-{
-    d_1_5_Core->f.DeleteQueries(n, ids);
-}
-
-inline void QOpenGLFunctions_1_5::glGenQueries(GLsizei n, GLuint *ids)
-{
-    d_1_5_Core->f.GenQueries(n, ids);
-}
-
-
-// OpenGL 1.0 deprecated functions
-inline void QOpenGLFunctions_1_5::glTranslatef(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Translatef(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_5::glTranslated(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Translated(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_5::glScalef(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Scalef(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_5::glScaled(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Scaled(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_5::glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Rotatef(angle, x, y, z);
-}
-
-inline void QOpenGLFunctions_1_5::glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Rotated(angle, x, y, z);
-}
-
-inline void QOpenGLFunctions_1_5::glPushMatrix()
-{
-    d_1_0_Deprecated->f.PushMatrix();
-}
-
-inline void QOpenGLFunctions_1_5::glPopMatrix()
-{
-    d_1_0_Deprecated->f.PopMatrix();
-}
-
-inline void QOpenGLFunctions_1_5::glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
-{
-    d_1_0_Deprecated->f.Ortho(left, right, bottom, top, zNear, zFar);
-}
-
-inline void QOpenGLFunctions_1_5::glMultMatrixd(const GLdouble *m)
-{
-    d_1_0_Deprecated->f.MultMatrixd(m);
-}
-
-inline void QOpenGLFunctions_1_5::glMultMatrixf(const GLfloat *m)
-{
-    d_1_0_Deprecated->f.MultMatrixf(m);
-}
-
-inline void QOpenGLFunctions_1_5::glMatrixMode(GLenum mode)
-{
-    d_1_0_Deprecated->f.MatrixMode(mode);
-}
-
-inline void QOpenGLFunctions_1_5::glLoadMatrixd(const GLdouble *m)
-{
-    d_1_0_Deprecated->f.LoadMatrixd(m);
-}
-
-inline void QOpenGLFunctions_1_5::glLoadMatrixf(const GLfloat *m)
-{
-    d_1_0_Deprecated->f.LoadMatrixf(m);
-}
-
-inline void QOpenGLFunctions_1_5::glLoadIdentity()
-{
-    d_1_0_Deprecated->f.LoadIdentity();
-}
-
-inline void QOpenGLFunctions_1_5::glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
-{
-    d_1_0_Deprecated->f.Frustum(left, right, bottom, top, zNear, zFar);
-}
-
-inline GLboolean QOpenGLFunctions_1_5::glIsList(GLuint list)
-{
-    return d_1_0_Deprecated->f.IsList(list);
-}
-
-inline void QOpenGLFunctions_1_5::glGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetTexGeniv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_1_5::glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetTexGenfv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_1_5::glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
-{
-    d_1_0_Deprecated->f.GetTexGendv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_1_5::glGetTexEnviv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetTexEnviv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_5::glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetTexEnvfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_5::glGetPolygonStipple(GLubyte *mask)
-{
-    d_1_0_Deprecated->f.GetPolygonStipple(mask);
-}
-
-inline void QOpenGLFunctions_1_5::glGetPixelMapusv(GLenum map, GLushort *values)
-{
-    d_1_0_Deprecated->f.GetPixelMapusv(map, values);
-}
-
-inline void QOpenGLFunctions_1_5::glGetPixelMapuiv(GLenum map, GLuint *values)
-{
-    d_1_0_Deprecated->f.GetPixelMapuiv(map, values);
-}
-
-inline void QOpenGLFunctions_1_5::glGetPixelMapfv(GLenum map, GLfloat *values)
-{
-    d_1_0_Deprecated->f.GetPixelMapfv(map, values);
-}
-
-inline void QOpenGLFunctions_1_5::glGetMaterialiv(GLenum face, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetMaterialiv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_1_5::glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetMaterialfv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_1_5::glGetMapiv(GLenum target, GLenum query, GLint *v)
-{
-    d_1_0_Deprecated->f.GetMapiv(target, query, v);
-}
-
-inline void QOpenGLFunctions_1_5::glGetMapfv(GLenum target, GLenum query, GLfloat *v)
-{
-    d_1_0_Deprecated->f.GetMapfv(target, query, v);
-}
-
-inline void QOpenGLFunctions_1_5::glGetMapdv(GLenum target, GLenum query, GLdouble *v)
-{
-    d_1_0_Deprecated->f.GetMapdv(target, query, v);
-}
-
-inline void QOpenGLFunctions_1_5::glGetLightiv(GLenum light, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetLightiv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_1_5::glGetLightfv(GLenum light, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetLightfv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_1_5::glGetClipPlane(GLenum plane, GLdouble *equation)
-{
-    d_1_0_Deprecated->f.GetClipPlane(plane, equation);
-}
-
-inline void QOpenGLFunctions_1_5::glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Deprecated->f.DrawPixels(width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_1_5::glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
-{
-    d_1_0_Deprecated->f.CopyPixels(x, y, width, height, type);
-}
-
-inline void QOpenGLFunctions_1_5::glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values)
-{
-    d_1_0_Deprecated->f.PixelMapusv(map, mapsize, values);
-}
-
-inline void QOpenGLFunctions_1_5::glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values)
-{
-    d_1_0_Deprecated->f.PixelMapuiv(map, mapsize, values);
-}
-
-inline void QOpenGLFunctions_1_5::glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values)
-{
-    d_1_0_Deprecated->f.PixelMapfv(map, mapsize, values);
-}
-
-inline void QOpenGLFunctions_1_5::glPixelTransferi(GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.PixelTransferi(pname, param);
-}
-
-inline void QOpenGLFunctions_1_5::glPixelTransferf(GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.PixelTransferf(pname, param);
-}
-
-inline void QOpenGLFunctions_1_5::glPixelZoom(GLfloat xfactor, GLfloat yfactor)
-{
-    d_1_0_Deprecated->f.PixelZoom(xfactor, yfactor);
-}
-
-inline void QOpenGLFunctions_1_5::glAlphaFunc(GLenum func, GLfloat ref)
-{
-    d_1_0_Deprecated->f.AlphaFunc(func, ref);
-}
-
-inline void QOpenGLFunctions_1_5::glEvalPoint2(GLint i, GLint j)
-{
-    d_1_0_Deprecated->f.EvalPoint2(i, j);
-}
-
-inline void QOpenGLFunctions_1_5::glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
-{
-    d_1_0_Deprecated->f.EvalMesh2(mode, i1, i2, j1, j2);
-}
-
-inline void QOpenGLFunctions_1_5::glEvalPoint1(GLint i)
-{
-    d_1_0_Deprecated->f.EvalPoint1(i);
-}
-
-inline void QOpenGLFunctions_1_5::glEvalMesh1(GLenum mode, GLint i1, GLint i2)
-{
-    d_1_0_Deprecated->f.EvalMesh1(mode, i1, i2);
-}
-
-inline void QOpenGLFunctions_1_5::glEvalCoord2fv(const GLfloat *u)
-{
-    d_1_0_Deprecated->f.EvalCoord2fv(u);
-}
-
-inline void QOpenGLFunctions_1_5::glEvalCoord2f(GLfloat u, GLfloat v)
-{
-    d_1_0_Deprecated->f.EvalCoord2f(u, v);
-}
-
-inline void QOpenGLFunctions_1_5::glEvalCoord2dv(const GLdouble *u)
-{
-    d_1_0_Deprecated->f.EvalCoord2dv(u);
-}
-
-inline void QOpenGLFunctions_1_5::glEvalCoord2d(GLdouble u, GLdouble v)
-{
-    d_1_0_Deprecated->f.EvalCoord2d(u, v);
-}
-
-inline void QOpenGLFunctions_1_5::glEvalCoord1fv(const GLfloat *u)
-{
-    d_1_0_Deprecated->f.EvalCoord1fv(u);
-}
-
-inline void QOpenGLFunctions_1_5::glEvalCoord1f(GLfloat u)
-{
-    d_1_0_Deprecated->f.EvalCoord1f(u);
-}
-
-inline void QOpenGLFunctions_1_5::glEvalCoord1dv(const GLdouble *u)
-{
-    d_1_0_Deprecated->f.EvalCoord1dv(u);
-}
-
-inline void QOpenGLFunctions_1_5::glEvalCoord1d(GLdouble u)
-{
-    d_1_0_Deprecated->f.EvalCoord1d(u);
-}
-
-inline void QOpenGLFunctions_1_5::glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
-{
-    d_1_0_Deprecated->f.MapGrid2f(un, u1, u2, vn, v1, v2);
-}
-
-inline void QOpenGLFunctions_1_5::glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
-{
-    d_1_0_Deprecated->f.MapGrid2d(un, u1, u2, vn, v1, v2);
-}
-
-inline void QOpenGLFunctions_1_5::glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
-{
-    d_1_0_Deprecated->f.MapGrid1f(un, u1, u2);
-}
-
-inline void QOpenGLFunctions_1_5::glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
-{
-    d_1_0_Deprecated->f.MapGrid1d(un, u1, u2);
-}
-
-inline void QOpenGLFunctions_1_5::glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
-{
-    d_1_0_Deprecated->f.Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
-}
-
-inline void QOpenGLFunctions_1_5::glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
-{
-    d_1_0_Deprecated->f.Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
-}
-
-inline void QOpenGLFunctions_1_5::glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
-{
-    d_1_0_Deprecated->f.Map1f(target, u1, u2, stride, order, points);
-}
-
-inline void QOpenGLFunctions_1_5::glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
-{
-    d_1_0_Deprecated->f.Map1d(target, u1, u2, stride, order, points);
-}
-
-inline void QOpenGLFunctions_1_5::glPushAttrib(GLbitfield mask)
-{
-    d_1_0_Deprecated->f.PushAttrib(mask);
-}
-
-inline void QOpenGLFunctions_1_5::glPopAttrib()
-{
-    d_1_0_Deprecated->f.PopAttrib();
-}
-
-inline void QOpenGLFunctions_1_5::glAccum(GLenum op, GLfloat value)
-{
-    d_1_0_Deprecated->f.Accum(op, value);
-}
-
-inline void QOpenGLFunctions_1_5::glIndexMask(GLuint mask)
-{
-    d_1_0_Deprecated->f.IndexMask(mask);
-}
-
-inline void QOpenGLFunctions_1_5::glClearIndex(GLfloat c)
-{
-    d_1_0_Deprecated->f.ClearIndex(c);
-}
-
-inline void QOpenGLFunctions_1_5::glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Deprecated->f.ClearAccum(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_5::glPushName(GLuint name)
-{
-    d_1_0_Deprecated->f.PushName(name);
-}
-
-inline void QOpenGLFunctions_1_5::glPopName()
-{
-    d_1_0_Deprecated->f.PopName();
-}
-
-inline void QOpenGLFunctions_1_5::glPassThrough(GLfloat token)
-{
-    d_1_0_Deprecated->f.PassThrough(token);
-}
-
-inline void QOpenGLFunctions_1_5::glLoadName(GLuint name)
-{
-    d_1_0_Deprecated->f.LoadName(name);
-}
-
-inline void QOpenGLFunctions_1_5::glInitNames()
-{
-    d_1_0_Deprecated->f.InitNames();
-}
-
-inline GLint QOpenGLFunctions_1_5::glRenderMode(GLenum mode)
-{
-    return d_1_0_Deprecated->f.RenderMode(mode);
-}
-
-inline void QOpenGLFunctions_1_5::glSelectBuffer(GLsizei size, GLuint *buffer)
-{
-    d_1_0_Deprecated->f.SelectBuffer(size, buffer);
-}
-
-inline void QOpenGLFunctions_1_5::glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
-{
-    d_1_0_Deprecated->f.FeedbackBuffer(size, type, buffer);
-}
-
-inline void QOpenGLFunctions_1_5::glTexGeniv(GLenum coord, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.TexGeniv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_1_5::glTexGeni(GLenum coord, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.TexGeni(coord, pname, param);
-}
-
-inline void QOpenGLFunctions_1_5::glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.TexGenfv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_1_5::glTexGenf(GLenum coord, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.TexGenf(coord, pname, param);
-}
-
-inline void QOpenGLFunctions_1_5::glTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
-{
-    d_1_0_Deprecated->f.TexGendv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_1_5::glTexGend(GLenum coord, GLenum pname, GLdouble param)
-{
-    d_1_0_Deprecated->f.TexGend(coord, pname, param);
-}
-
-inline void QOpenGLFunctions_1_5::glTexEnviv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.TexEnviv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_5::glTexEnvi(GLenum target, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.TexEnvi(target, pname, param);
-}
-
-inline void QOpenGLFunctions_1_5::glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.TexEnvfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_5::glTexEnvf(GLenum target, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.TexEnvf(target, pname, param);
-}
-
-inline void QOpenGLFunctions_1_5::glShadeModel(GLenum mode)
-{
-    d_1_0_Deprecated->f.ShadeModel(mode);
-}
-
-inline void QOpenGLFunctions_1_5::glPolygonStipple(const GLubyte *mask)
-{
-    d_1_0_Deprecated->f.PolygonStipple(mask);
-}
-
-inline void QOpenGLFunctions_1_5::glMaterialiv(GLenum face, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.Materialiv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_1_5::glMateriali(GLenum face, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.Materiali(face, pname, param);
-}
-
-inline void QOpenGLFunctions_1_5::glMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.Materialfv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_1_5::glMaterialf(GLenum face, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.Materialf(face, pname, param);
-}
-
-inline void QOpenGLFunctions_1_5::glLineStipple(GLint factor, GLushort pattern)
-{
-    d_1_0_Deprecated->f.LineStipple(factor, pattern);
-}
-
-inline void QOpenGLFunctions_1_5::glLightModeliv(GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.LightModeliv(pname, params);
-}
-
-inline void QOpenGLFunctions_1_5::glLightModeli(GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.LightModeli(pname, param);
-}
-
-inline void QOpenGLFunctions_1_5::glLightModelfv(GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.LightModelfv(pname, params);
-}
-
-inline void QOpenGLFunctions_1_5::glLightModelf(GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.LightModelf(pname, param);
-}
-
-inline void QOpenGLFunctions_1_5::glLightiv(GLenum light, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.Lightiv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_1_5::glLighti(GLenum light, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.Lighti(light, pname, param);
-}
-
-inline void QOpenGLFunctions_1_5::glLightfv(GLenum light, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.Lightfv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_1_5::glLightf(GLenum light, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.Lightf(light, pname, param);
-}
-
-inline void QOpenGLFunctions_1_5::glFogiv(GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.Fogiv(pname, params);
-}
-
-inline void QOpenGLFunctions_1_5::glFogi(GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.Fogi(pname, param);
-}
-
-inline void QOpenGLFunctions_1_5::glFogfv(GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.Fogfv(pname, params);
-}
-
-inline void QOpenGLFunctions_1_5::glFogf(GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.Fogf(pname, param);
-}
-
-inline void QOpenGLFunctions_1_5::glColorMaterial(GLenum face, GLenum mode)
-{
-    d_1_0_Deprecated->f.ColorMaterial(face, mode);
-}
-
-inline void QOpenGLFunctions_1_5::glClipPlane(GLenum plane, const GLdouble *equation)
-{
-    d_1_0_Deprecated->f.ClipPlane(plane, equation);
-}
-
-inline void QOpenGLFunctions_1_5::glVertex4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Vertex4sv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
-{
-    d_1_0_Deprecated->f.Vertex4s(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_1_5::glVertex4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Vertex4iv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glVertex4i(GLint x, GLint y, GLint z, GLint w)
-{
-    d_1_0_Deprecated->f.Vertex4i(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_1_5::glVertex4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Vertex4fv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    d_1_0_Deprecated->f.Vertex4f(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_1_5::glVertex4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Vertex4dv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_1_0_Deprecated->f.Vertex4d(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_1_5::glVertex3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Vertex3sv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glVertex3s(GLshort x, GLshort y, GLshort z)
-{
-    d_1_0_Deprecated->f.Vertex3s(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_5::glVertex3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Vertex3iv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glVertex3i(GLint x, GLint y, GLint z)
-{
-    d_1_0_Deprecated->f.Vertex3i(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_5::glVertex3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Vertex3fv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glVertex3f(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Vertex3f(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_5::glVertex3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Vertex3dv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glVertex3d(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Vertex3d(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_5::glVertex2sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Vertex2sv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glVertex2s(GLshort x, GLshort y)
-{
-    d_1_0_Deprecated->f.Vertex2s(x, y);
-}
-
-inline void QOpenGLFunctions_1_5::glVertex2iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Vertex2iv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glVertex2i(GLint x, GLint y)
-{
-    d_1_0_Deprecated->f.Vertex2i(x, y);
-}
-
-inline void QOpenGLFunctions_1_5::glVertex2fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Vertex2fv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glVertex2f(GLfloat x, GLfloat y)
-{
-    d_1_0_Deprecated->f.Vertex2f(x, y);
-}
-
-inline void QOpenGLFunctions_1_5::glVertex2dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Vertex2dv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glVertex2d(GLdouble x, GLdouble y)
-{
-    d_1_0_Deprecated->f.Vertex2d(x, y);
-}
-
-inline void QOpenGLFunctions_1_5::glTexCoord4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord4sv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
-{
-    d_1_0_Deprecated->f.TexCoord4s(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_1_5::glTexCoord4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord4iv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
-{
-    d_1_0_Deprecated->f.TexCoord4i(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_1_5::glTexCoord4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord4fv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
-{
-    d_1_0_Deprecated->f.TexCoord4f(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_1_5::glTexCoord4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord4dv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
-{
-    d_1_0_Deprecated->f.TexCoord4d(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_1_5::glTexCoord3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord3sv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glTexCoord3s(GLshort s, GLshort t, GLshort r)
-{
-    d_1_0_Deprecated->f.TexCoord3s(s, t, r);
-}
-
-inline void QOpenGLFunctions_1_5::glTexCoord3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord3iv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glTexCoord3i(GLint s, GLint t, GLint r)
-{
-    d_1_0_Deprecated->f.TexCoord3i(s, t, r);
-}
-
-inline void QOpenGLFunctions_1_5::glTexCoord3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord3fv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
-{
-    d_1_0_Deprecated->f.TexCoord3f(s, t, r);
-}
-
-inline void QOpenGLFunctions_1_5::glTexCoord3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord3dv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
-{
-    d_1_0_Deprecated->f.TexCoord3d(s, t, r);
-}
-
-inline void QOpenGLFunctions_1_5::glTexCoord2sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord2sv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glTexCoord2s(GLshort s, GLshort t)
-{
-    d_1_0_Deprecated->f.TexCoord2s(s, t);
-}
-
-inline void QOpenGLFunctions_1_5::glTexCoord2iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord2iv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glTexCoord2i(GLint s, GLint t)
-{
-    d_1_0_Deprecated->f.TexCoord2i(s, t);
-}
-
-inline void QOpenGLFunctions_1_5::glTexCoord2fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord2fv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glTexCoord2f(GLfloat s, GLfloat t)
-{
-    d_1_0_Deprecated->f.TexCoord2f(s, t);
-}
-
-inline void QOpenGLFunctions_1_5::glTexCoord2dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord2dv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glTexCoord2d(GLdouble s, GLdouble t)
-{
-    d_1_0_Deprecated->f.TexCoord2d(s, t);
-}
-
-inline void QOpenGLFunctions_1_5::glTexCoord1sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord1sv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glTexCoord1s(GLshort s)
-{
-    d_1_0_Deprecated->f.TexCoord1s(s);
-}
-
-inline void QOpenGLFunctions_1_5::glTexCoord1iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord1iv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glTexCoord1i(GLint s)
-{
-    d_1_0_Deprecated->f.TexCoord1i(s);
-}
-
-inline void QOpenGLFunctions_1_5::glTexCoord1fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord1fv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glTexCoord1f(GLfloat s)
-{
-    d_1_0_Deprecated->f.TexCoord1f(s);
-}
-
-inline void QOpenGLFunctions_1_5::glTexCoord1dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord1dv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glTexCoord1d(GLdouble s)
-{
-    d_1_0_Deprecated->f.TexCoord1d(s);
-}
-
-inline void QOpenGLFunctions_1_5::glRectsv(const GLshort *v1, const GLshort *v2)
-{
-    d_1_0_Deprecated->f.Rectsv(v1, v2);
-}
-
-inline void QOpenGLFunctions_1_5::glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
-{
-    d_1_0_Deprecated->f.Rects(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_1_5::glRectiv(const GLint *v1, const GLint *v2)
-{
-    d_1_0_Deprecated->f.Rectiv(v1, v2);
-}
-
-inline void QOpenGLFunctions_1_5::glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
-{
-    d_1_0_Deprecated->f.Recti(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_1_5::glRectfv(const GLfloat *v1, const GLfloat *v2)
-{
-    d_1_0_Deprecated->f.Rectfv(v1, v2);
-}
-
-inline void QOpenGLFunctions_1_5::glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
-{
-    d_1_0_Deprecated->f.Rectf(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_1_5::glRectdv(const GLdouble *v1, const GLdouble *v2)
-{
-    d_1_0_Deprecated->f.Rectdv(v1, v2);
-}
-
-inline void QOpenGLFunctions_1_5::glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
-{
-    d_1_0_Deprecated->f.Rectd(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_1_5::glRasterPos4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.RasterPos4sv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
-{
-    d_1_0_Deprecated->f.RasterPos4s(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_1_5::glRasterPos4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.RasterPos4iv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
-{
-    d_1_0_Deprecated->f.RasterPos4i(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_1_5::glRasterPos4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.RasterPos4fv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    d_1_0_Deprecated->f.RasterPos4f(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_1_5::glRasterPos4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.RasterPos4dv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_1_0_Deprecated->f.RasterPos4d(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_1_5::glRasterPos3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.RasterPos3sv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glRasterPos3s(GLshort x, GLshort y, GLshort z)
-{
-    d_1_0_Deprecated->f.RasterPos3s(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_5::glRasterPos3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.RasterPos3iv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glRasterPos3i(GLint x, GLint y, GLint z)
-{
-    d_1_0_Deprecated->f.RasterPos3i(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_5::glRasterPos3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.RasterPos3fv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.RasterPos3f(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_5::glRasterPos3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.RasterPos3dv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.RasterPos3d(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_5::glRasterPos2sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.RasterPos2sv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glRasterPos2s(GLshort x, GLshort y)
-{
-    d_1_0_Deprecated->f.RasterPos2s(x, y);
-}
-
-inline void QOpenGLFunctions_1_5::glRasterPos2iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.RasterPos2iv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glRasterPos2i(GLint x, GLint y)
-{
-    d_1_0_Deprecated->f.RasterPos2i(x, y);
-}
-
-inline void QOpenGLFunctions_1_5::glRasterPos2fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.RasterPos2fv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glRasterPos2f(GLfloat x, GLfloat y)
-{
-    d_1_0_Deprecated->f.RasterPos2f(x, y);
-}
-
-inline void QOpenGLFunctions_1_5::glRasterPos2dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.RasterPos2dv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glRasterPos2d(GLdouble x, GLdouble y)
-{
-    d_1_0_Deprecated->f.RasterPos2d(x, y);
-}
-
-inline void QOpenGLFunctions_1_5::glNormal3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Normal3sv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glNormal3s(GLshort nx, GLshort ny, GLshort nz)
-{
-    d_1_0_Deprecated->f.Normal3s(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_1_5::glNormal3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Normal3iv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glNormal3i(GLint nx, GLint ny, GLint nz)
-{
-    d_1_0_Deprecated->f.Normal3i(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_1_5::glNormal3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Normal3fv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
-{
-    d_1_0_Deprecated->f.Normal3f(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_1_5::glNormal3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Normal3dv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
-{
-    d_1_0_Deprecated->f.Normal3d(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_1_5::glNormal3bv(const GLbyte *v)
-{
-    d_1_0_Deprecated->f.Normal3bv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
-{
-    d_1_0_Deprecated->f.Normal3b(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_1_5::glIndexsv(const GLshort *c)
-{
-    d_1_0_Deprecated->f.Indexsv(c);
-}
-
-inline void QOpenGLFunctions_1_5::glIndexs(GLshort c)
-{
-    d_1_0_Deprecated->f.Indexs(c);
-}
-
-inline void QOpenGLFunctions_1_5::glIndexiv(const GLint *c)
-{
-    d_1_0_Deprecated->f.Indexiv(c);
-}
-
-inline void QOpenGLFunctions_1_5::glIndexi(GLint c)
-{
-    d_1_0_Deprecated->f.Indexi(c);
-}
-
-inline void QOpenGLFunctions_1_5::glIndexfv(const GLfloat *c)
-{
-    d_1_0_Deprecated->f.Indexfv(c);
-}
-
-inline void QOpenGLFunctions_1_5::glIndexf(GLfloat c)
-{
-    d_1_0_Deprecated->f.Indexf(c);
-}
-
-inline void QOpenGLFunctions_1_5::glIndexdv(const GLdouble *c)
-{
-    d_1_0_Deprecated->f.Indexdv(c);
-}
-
-inline void QOpenGLFunctions_1_5::glIndexd(GLdouble c)
-{
-    d_1_0_Deprecated->f.Indexd(c);
-}
-
-inline void QOpenGLFunctions_1_5::glEnd()
-{
-    d_1_0_Deprecated->f.End();
-}
-
-inline void QOpenGLFunctions_1_5::glEdgeFlagv(const GLboolean *flag)
-{
-    d_1_0_Deprecated->f.EdgeFlagv(flag);
-}
-
-inline void QOpenGLFunctions_1_5::glEdgeFlag(GLboolean flag)
-{
-    d_1_0_Deprecated->f.EdgeFlag(flag);
-}
-
-inline void QOpenGLFunctions_1_5::glColor4usv(const GLushort *v)
-{
-    d_1_0_Deprecated->f.Color4usv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
-{
-    d_1_0_Deprecated->f.Color4us(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_5::glColor4uiv(const GLuint *v)
-{
-    d_1_0_Deprecated->f.Color4uiv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
-{
-    d_1_0_Deprecated->f.Color4ui(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_5::glColor4ubv(const GLubyte *v)
-{
-    d_1_0_Deprecated->f.Color4ubv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
-{
-    d_1_0_Deprecated->f.Color4ub(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_5::glColor4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Color4sv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
-{
-    d_1_0_Deprecated->f.Color4s(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_5::glColor4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Color4iv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
-{
-    d_1_0_Deprecated->f.Color4i(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_5::glColor4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Color4fv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Deprecated->f.Color4f(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_5::glColor4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Color4dv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
-{
-    d_1_0_Deprecated->f.Color4d(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_5::glColor4bv(const GLbyte *v)
-{
-    d_1_0_Deprecated->f.Color4bv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
-{
-    d_1_0_Deprecated->f.Color4b(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_1_5::glColor3usv(const GLushort *v)
-{
-    d_1_0_Deprecated->f.Color3usv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glColor3us(GLushort red, GLushort green, GLushort blue)
-{
-    d_1_0_Deprecated->f.Color3us(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_5::glColor3uiv(const GLuint *v)
-{
-    d_1_0_Deprecated->f.Color3uiv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glColor3ui(GLuint red, GLuint green, GLuint blue)
-{
-    d_1_0_Deprecated->f.Color3ui(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_5::glColor3ubv(const GLubyte *v)
-{
-    d_1_0_Deprecated->f.Color3ubv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
-{
-    d_1_0_Deprecated->f.Color3ub(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_5::glColor3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Color3sv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glColor3s(GLshort red, GLshort green, GLshort blue)
-{
-    d_1_0_Deprecated->f.Color3s(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_5::glColor3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Color3iv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glColor3i(GLint red, GLint green, GLint blue)
-{
-    d_1_0_Deprecated->f.Color3i(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_5::glColor3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Color3fv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glColor3f(GLfloat red, GLfloat green, GLfloat blue)
-{
-    d_1_0_Deprecated->f.Color3f(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_5::glColor3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Color3dv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glColor3d(GLdouble red, GLdouble green, GLdouble blue)
-{
-    d_1_0_Deprecated->f.Color3d(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_5::glColor3bv(const GLbyte *v)
-{
-    d_1_0_Deprecated->f.Color3bv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glColor3b(GLbyte red, GLbyte green, GLbyte blue)
-{
-    d_1_0_Deprecated->f.Color3b(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_5::glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
-{
-    d_1_0_Deprecated->f.Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
-}
-
-inline void QOpenGLFunctions_1_5::glBegin(GLenum mode)
-{
-    d_1_0_Deprecated->f.Begin(mode);
-}
-
-inline void QOpenGLFunctions_1_5::glListBase(GLuint base)
-{
-    d_1_0_Deprecated->f.ListBase(base);
-}
-
-inline GLuint QOpenGLFunctions_1_5::glGenLists(GLsizei range)
-{
-    return d_1_0_Deprecated->f.GenLists(range);
-}
-
-inline void QOpenGLFunctions_1_5::glDeleteLists(GLuint list, GLsizei range)
-{
-    d_1_0_Deprecated->f.DeleteLists(list, range);
-}
-
-inline void QOpenGLFunctions_1_5::glCallLists(GLsizei n, GLenum type, const GLvoid *lists)
-{
-    d_1_0_Deprecated->f.CallLists(n, type, lists);
-}
-
-inline void QOpenGLFunctions_1_5::glCallList(GLuint list)
-{
-    d_1_0_Deprecated->f.CallList(list);
-}
-
-inline void QOpenGLFunctions_1_5::glEndList()
-{
-    d_1_0_Deprecated->f.EndList();
-}
-
-inline void QOpenGLFunctions_1_5::glNewList(GLuint list, GLenum mode)
-{
-    d_1_0_Deprecated->f.NewList(list, mode);
-}
-
-
-// OpenGL 1.1 deprecated functions
-inline void QOpenGLFunctions_1_5::glPushClientAttrib(GLbitfield mask)
-{
-    d_1_1_Deprecated->f.PushClientAttrib(mask);
-}
-
-inline void QOpenGLFunctions_1_5::glPopClientAttrib()
-{
-    d_1_1_Deprecated->f.PopClientAttrib();
-}
-
-inline void QOpenGLFunctions_1_5::glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities)
-{
-    d_1_1_Deprecated->f.PrioritizeTextures(n, textures, priorities);
-}
-
-inline GLboolean QOpenGLFunctions_1_5::glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
-{
-    return d_1_1_Deprecated->f.AreTexturesResident(n, textures, residences);
-}
-
-inline void QOpenGLFunctions_1_5::glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.VertexPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_1_5::glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.TexCoordPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_1_5::glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.NormalPointer(type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_1_5::glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.InterleavedArrays(format, stride, pointer);
-}
-
-inline void QOpenGLFunctions_1_5::glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.IndexPointer(type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_1_5::glEnableClientState(GLenum array)
-{
-    d_1_1_Deprecated->f.EnableClientState(array);
-}
-
-inline void QOpenGLFunctions_1_5::glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.EdgeFlagPointer(stride, pointer);
-}
-
-inline void QOpenGLFunctions_1_5::glDisableClientState(GLenum array)
-{
-    d_1_1_Deprecated->f.DisableClientState(array);
-}
-
-inline void QOpenGLFunctions_1_5::glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.ColorPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_1_5::glArrayElement(GLint i)
-{
-    d_1_1_Deprecated->f.ArrayElement(i);
-}
-
-
-// OpenGL 1.2 deprecated functions
-inline void QOpenGLFunctions_1_5::glResetMinmax(GLenum target)
-{
-    d_1_2_Deprecated->f.ResetMinmax(target);
-}
-
-inline void QOpenGLFunctions_1_5::glResetHistogram(GLenum target)
-{
-    d_1_2_Deprecated->f.ResetHistogram(target);
-}
-
-inline void QOpenGLFunctions_1_5::glMinmax(GLenum target, GLenum internalformat, GLboolean sink)
-{
-    d_1_2_Deprecated->f.Minmax(target, internalformat, sink);
-}
-
-inline void QOpenGLFunctions_1_5::glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
-{
-    d_1_2_Deprecated->f.Histogram(target, width, internalformat, sink);
-}
-
-inline void QOpenGLFunctions_1_5::glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetMinmaxParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_5::glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetMinmaxParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_5::glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
-{
-    d_1_2_Deprecated->f.GetMinmax(target, reset, format, type, values);
-}
-
-inline void QOpenGLFunctions_1_5::glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetHistogramParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_5::glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetHistogramParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_5::glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
-{
-    d_1_2_Deprecated->f.GetHistogram(target, reset, format, type, values);
-}
-
-inline void QOpenGLFunctions_1_5::glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column)
-{
-    d_1_2_Deprecated->f.SeparableFilter2D(target, internalformat, width, height, format, type, row, column);
-}
-
-inline void QOpenGLFunctions_1_5::glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span)
-{
-    d_1_2_Deprecated->f.GetSeparableFilter(target, format, type, row, column, span);
-}
-
-inline void QOpenGLFunctions_1_5::glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetConvolutionParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_5::glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetConvolutionParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_5::glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image)
-{
-    d_1_2_Deprecated->f.GetConvolutionFilter(target, format, type, image);
-}
-
-inline void QOpenGLFunctions_1_5::glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_2_Deprecated->f.CopyConvolutionFilter2D(target, internalformat, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_1_5::glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
-{
-    d_1_2_Deprecated->f.CopyConvolutionFilter1D(target, internalformat, x, y, width);
-}
-
-inline void QOpenGLFunctions_1_5::glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_5::glConvolutionParameteri(GLenum target, GLenum pname, GLint params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameteri(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_5::glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_5::glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameterf(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_5::glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image)
-{
-    d_1_2_Deprecated->f.ConvolutionFilter2D(target, internalformat, width, height, format, type, image);
-}
-
-inline void QOpenGLFunctions_1_5::glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image)
-{
-    d_1_2_Deprecated->f.ConvolutionFilter1D(target, internalformat, width, format, type, image);
-}
-
-inline void QOpenGLFunctions_1_5::glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
-{
-    d_1_2_Deprecated->f.CopyColorSubTable(target, start, x, y, width);
-}
-
-inline void QOpenGLFunctions_1_5::glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data)
-{
-    d_1_2_Deprecated->f.ColorSubTable(target, start, count, format, type, data);
-}
-
-inline void QOpenGLFunctions_1_5::glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetColorTableParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_5::glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetColorTableParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_5::glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table)
-{
-    d_1_2_Deprecated->f.GetColorTable(target, format, type, table);
-}
-
-inline void QOpenGLFunctions_1_5::glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
-{
-    d_1_2_Deprecated->f.CopyColorTable(target, internalformat, x, y, width);
-}
-
-inline void QOpenGLFunctions_1_5::glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_2_Deprecated->f.ColorTableParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_5::glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_2_Deprecated->f.ColorTableParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_1_5::glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table)
-{
-    d_1_2_Deprecated->f.ColorTable(target, internalformat, width, format, type, table);
-}
-
-
-// OpenGL 1.3 deprecated functions
-inline void QOpenGLFunctions_1_5::glMultTransposeMatrixd(const GLdouble *m)
-{
-    d_1_3_Deprecated->f.MultTransposeMatrixd(m);
-}
-
-inline void QOpenGLFunctions_1_5::glMultTransposeMatrixf(const GLfloat *m)
-{
-    d_1_3_Deprecated->f.MultTransposeMatrixf(m);
-}
-
-inline void QOpenGLFunctions_1_5::glLoadTransposeMatrixd(const GLdouble *m)
-{
-    d_1_3_Deprecated->f.LoadTransposeMatrixd(m);
-}
-
-inline void QOpenGLFunctions_1_5::glLoadTransposeMatrixf(const GLfloat *m)
-{
-    d_1_3_Deprecated->f.LoadTransposeMatrixf(m);
-}
-
-inline void QOpenGLFunctions_1_5::glMultiTexCoord4sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4sv(target, v);
-}
-
-inline void QOpenGLFunctions_1_5::glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4s(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_1_5::glMultiTexCoord4iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4iv(target, v);
-}
-
-inline void QOpenGLFunctions_1_5::glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4i(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_1_5::glMultiTexCoord4fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4fv(target, v);
-}
-
-inline void QOpenGLFunctions_1_5::glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4f(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_1_5::glMultiTexCoord4dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4dv(target, v);
-}
-
-inline void QOpenGLFunctions_1_5::glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4d(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_1_5::glMultiTexCoord3sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3sv(target, v);
-}
-
-inline void QOpenGLFunctions_1_5::glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3s(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_1_5::glMultiTexCoord3iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3iv(target, v);
-}
-
-inline void QOpenGLFunctions_1_5::glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3i(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_1_5::glMultiTexCoord3fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3fv(target, v);
-}
-
-inline void QOpenGLFunctions_1_5::glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3f(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_1_5::glMultiTexCoord3dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3dv(target, v);
-}
-
-inline void QOpenGLFunctions_1_5::glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3d(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_1_5::glMultiTexCoord2sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2sv(target, v);
-}
-
-inline void QOpenGLFunctions_1_5::glMultiTexCoord2s(GLenum target, GLshort s, GLshort t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2s(target, s, t);
-}
-
-inline void QOpenGLFunctions_1_5::glMultiTexCoord2iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2iv(target, v);
-}
-
-inline void QOpenGLFunctions_1_5::glMultiTexCoord2i(GLenum target, GLint s, GLint t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2i(target, s, t);
-}
-
-inline void QOpenGLFunctions_1_5::glMultiTexCoord2fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2fv(target, v);
-}
-
-inline void QOpenGLFunctions_1_5::glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2f(target, s, t);
-}
-
-inline void QOpenGLFunctions_1_5::glMultiTexCoord2dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2dv(target, v);
-}
-
-inline void QOpenGLFunctions_1_5::glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2d(target, s, t);
-}
-
-inline void QOpenGLFunctions_1_5::glMultiTexCoord1sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1sv(target, v);
-}
-
-inline void QOpenGLFunctions_1_5::glMultiTexCoord1s(GLenum target, GLshort s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1s(target, s);
-}
-
-inline void QOpenGLFunctions_1_5::glMultiTexCoord1iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1iv(target, v);
-}
-
-inline void QOpenGLFunctions_1_5::glMultiTexCoord1i(GLenum target, GLint s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1i(target, s);
-}
-
-inline void QOpenGLFunctions_1_5::glMultiTexCoord1fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1fv(target, v);
-}
-
-inline void QOpenGLFunctions_1_5::glMultiTexCoord1f(GLenum target, GLfloat s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1f(target, s);
-}
-
-inline void QOpenGLFunctions_1_5::glMultiTexCoord1dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1dv(target, v);
-}
-
-inline void QOpenGLFunctions_1_5::glMultiTexCoord1d(GLenum target, GLdouble s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1d(target, s);
-}
-
-inline void QOpenGLFunctions_1_5::glClientActiveTexture(GLenum texture)
-{
-    d_1_3_Deprecated->f.ClientActiveTexture(texture);
-}
-
-
-// OpenGL 1.4 deprecated functions
-inline void QOpenGLFunctions_1_5::glWindowPos3sv(const GLshort *v)
-{
-    d_1_4_Deprecated->f.WindowPos3sv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glWindowPos3s(GLshort x, GLshort y, GLshort z)
-{
-    d_1_4_Deprecated->f.WindowPos3s(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_5::glWindowPos3iv(const GLint *v)
-{
-    d_1_4_Deprecated->f.WindowPos3iv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glWindowPos3i(GLint x, GLint y, GLint z)
-{
-    d_1_4_Deprecated->f.WindowPos3i(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_5::glWindowPos3fv(const GLfloat *v)
-{
-    d_1_4_Deprecated->f.WindowPos3fv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glWindowPos3f(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_4_Deprecated->f.WindowPos3f(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_5::glWindowPos3dv(const GLdouble *v)
-{
-    d_1_4_Deprecated->f.WindowPos3dv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glWindowPos3d(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_4_Deprecated->f.WindowPos3d(x, y, z);
-}
-
-inline void QOpenGLFunctions_1_5::glWindowPos2sv(const GLshort *v)
-{
-    d_1_4_Deprecated->f.WindowPos2sv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glWindowPos2s(GLshort x, GLshort y)
-{
-    d_1_4_Deprecated->f.WindowPos2s(x, y);
-}
-
-inline void QOpenGLFunctions_1_5::glWindowPos2iv(const GLint *v)
-{
-    d_1_4_Deprecated->f.WindowPos2iv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glWindowPos2i(GLint x, GLint y)
-{
-    d_1_4_Deprecated->f.WindowPos2i(x, y);
-}
-
-inline void QOpenGLFunctions_1_5::glWindowPos2fv(const GLfloat *v)
-{
-    d_1_4_Deprecated->f.WindowPos2fv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glWindowPos2f(GLfloat x, GLfloat y)
-{
-    d_1_4_Deprecated->f.WindowPos2f(x, y);
-}
-
-inline void QOpenGLFunctions_1_5::glWindowPos2dv(const GLdouble *v)
-{
-    d_1_4_Deprecated->f.WindowPos2dv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glWindowPos2d(GLdouble x, GLdouble y)
-{
-    d_1_4_Deprecated->f.WindowPos2d(x, y);
-}
-
-inline void QOpenGLFunctions_1_5::glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_4_Deprecated->f.SecondaryColorPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_1_5::glSecondaryColor3usv(const GLushort *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3usv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glSecondaryColor3us(GLushort red, GLushort green, GLushort blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3us(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_5::glSecondaryColor3uiv(const GLuint *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3uiv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3ui(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_5::glSecondaryColor3ubv(const GLubyte *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3ubv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3ub(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_5::glSecondaryColor3sv(const GLshort *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3sv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glSecondaryColor3s(GLshort red, GLshort green, GLshort blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3s(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_5::glSecondaryColor3iv(const GLint *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3iv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glSecondaryColor3i(GLint red, GLint green, GLint blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3i(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_5::glSecondaryColor3fv(const GLfloat *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3fv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3f(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_5::glSecondaryColor3dv(const GLdouble *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3dv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3d(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_5::glSecondaryColor3bv(const GLbyte *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3bv(v);
-}
-
-inline void QOpenGLFunctions_1_5::glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3b(red, green, blue);
-}
-
-inline void QOpenGLFunctions_1_5::glFogCoordPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_4_Deprecated->f.FogCoordPointer(type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_1_5::glFogCoorddv(const GLdouble *coord)
-{
-    d_1_4_Deprecated->f.FogCoorddv(coord);
-}
-
-inline void QOpenGLFunctions_1_5::glFogCoordd(GLdouble coord)
-{
-    d_1_4_Deprecated->f.FogCoordd(coord);
-}
-
-inline void QOpenGLFunctions_1_5::glFogCoordfv(const GLfloat *coord)
-{
-    d_1_4_Deprecated->f.FogCoordfv(coord);
-}
-
-inline void QOpenGLFunctions_1_5::glFogCoordf(GLfloat coord)
-{
-    d_1_4_Deprecated->f.FogCoordf(coord);
-}
-
-
-// OpenGL 1.5 deprecated functions
-
-
-QT_END_NAMESPACE
-
-#endif // QT_NO_OPENGL && !QT_OPENGL_ES_2
-
-#endif
diff --git a/src/gui/opengl/qopenglfunctions_2_0.cpp b/src/gui/opengl/qopenglfunctions_2_0.cpp
deleted file mode 100644
index 29eb055a1d..0000000000
--- a/src/gui/opengl/qopenglfunctions_2_0.cpp
+++ /dev/null
@@ -1,227 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#include "qopenglfunctions_2_0.h"
-#include "qopenglcontext.h"
-
-QT_BEGIN_NAMESPACE
-
-/*!
-    \class QOpenGLFunctions_2_0
-    \inmodule QtGui
-    \since 5.1
-    \wrapper
-    \brief The QOpenGLFunctions_2_0 class provides all functions for OpenGL 2.0 specification.
-
-    This class is a wrapper for functions from OpenGL 2.0 specification.
-    See reference pages on \l {http://www.opengl.org/sdk/docs/}{opengl.org}
-    for function documentation.
-
-    \sa QAbstractOpenGLFunctions
-*/
-
-QOpenGLFunctions_2_0::QOpenGLFunctions_2_0()
- : QAbstractOpenGLFunctions()
- , d_1_0_Core(nullptr)
- , d_1_1_Core(nullptr)
- , d_1_2_Core(nullptr)
- , d_1_3_Core(nullptr)
- , d_1_4_Core(nullptr)
- , d_1_5_Core(nullptr)
- , d_2_0_Core(nullptr)
- , d_1_0_Deprecated(nullptr)
- , d_1_1_Deprecated(nullptr)
- , d_1_2_Deprecated(nullptr)
- , d_1_3_Deprecated(nullptr)
- , d_1_4_Deprecated(nullptr)
- , m_reserved_2_0_Deprecated(nullptr)
-{
-}
-
-QOpenGLFunctions_2_0::~QOpenGLFunctions_2_0()
-{
-    if (d_1_0_Core) {
-        d_1_0_Core->refs.deref();
-        Q_ASSERT(d_1_0_Core->refs.loadRelaxed());
-    }
-    if (d_1_1_Core) {
-        d_1_1_Core->refs.deref();
-        Q_ASSERT(d_1_1_Core->refs.loadRelaxed());
-    }
-    if (d_1_2_Core) {
-        d_1_2_Core->refs.deref();
-        Q_ASSERT(d_1_2_Core->refs.loadRelaxed());
-    }
-    if (d_1_3_Core) {
-        d_1_3_Core->refs.deref();
-        Q_ASSERT(d_1_3_Core->refs.loadRelaxed());
-    }
-    if (d_1_4_Core) {
-        d_1_4_Core->refs.deref();
-        Q_ASSERT(d_1_4_Core->refs.loadRelaxed());
-    }
-    if (d_1_5_Core) {
-        d_1_5_Core->refs.deref();
-        Q_ASSERT(d_1_5_Core->refs.loadRelaxed());
-    }
-    if (d_2_0_Core) {
-        d_2_0_Core->refs.deref();
-        Q_ASSERT(d_2_0_Core->refs.loadRelaxed());
-    }
-    if (d_1_0_Deprecated) {
-        d_1_0_Deprecated->refs.deref();
-        Q_ASSERT(d_1_0_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_1_Deprecated) {
-        d_1_1_Deprecated->refs.deref();
-        Q_ASSERT(d_1_1_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_2_Deprecated) {
-        d_1_2_Deprecated->refs.deref();
-        Q_ASSERT(d_1_2_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_3_Deprecated) {
-        d_1_3_Deprecated->refs.deref();
-        Q_ASSERT(d_1_3_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_4_Deprecated) {
-        d_1_4_Deprecated->refs.deref();
-        Q_ASSERT(d_1_4_Deprecated->refs.loadRelaxed());
-    }
-}
-
-bool QOpenGLFunctions_2_0::initializeOpenGLFunctions()
-{
-    if ( isInitialized() )
-        return true;
-
-    QOpenGLContext* context = QOpenGLContext::currentContext();
-
-    // If owned by a context object make sure it is current.
-    // Also check that current context is capable of resolving all needed functions
-    if (((owningContext() && owningContext() == context) || !owningContext())
-        && QOpenGLFunctions_2_0::isContextCompatible(context))
-    {
-        // Associate with private implementation, creating if necessary
-        // Function pointers in the backends are resolved at creation time
-        QOpenGLVersionFunctionsBackend* d = nullptr;
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        d_1_3_Core = static_cast<QOpenGLFunctions_1_3_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        d_1_4_Core = static_cast<QOpenGLFunctions_1_4_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        d_1_5_Core = static_cast<QOpenGLFunctions_1_5_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        d_2_0_Core = static_cast<QOpenGLFunctions_2_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
-        d_1_0_Deprecated = static_cast<QOpenGLFunctions_1_0_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
-        d_1_1_Deprecated = static_cast<QOpenGLFunctions_1_1_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus());
-        d_1_2_Deprecated = static_cast<QOpenGLFunctions_1_2_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus());
-        d_1_3_Deprecated = static_cast<QOpenGLFunctions_1_3_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
-        d_1_4_Deprecated = static_cast<QOpenGLFunctions_1_4_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        QAbstractOpenGLFunctions::initializeOpenGLFunctions();
-    }
-    return isInitialized();
-}
-
-bool QOpenGLFunctions_2_0::isContextCompatible(QOpenGLContext *context)
-{
-    Q_ASSERT(context);
-    QSurfaceFormat f = context->format();
-    const QPair<int, int> v = qMakePair(f.majorVersion(), f.minorVersion());
-    if (v < qMakePair(2, 0))
-        return false;
-
-    if (f.profile() == QSurfaceFormat::CoreProfile)
-        return false;
-
-    return true;
-}
-
-QOpenGLVersionProfile QOpenGLFunctions_2_0::versionProfile()
-{
-    QOpenGLVersionProfile v;
-    v.setVersion(2, 0);
-    return v;
-}
-
-QT_END_NAMESPACE
diff --git a/src/gui/opengl/qopenglfunctions_2_0.h b/src/gui/opengl/qopenglfunctions_2_0.h
deleted file mode 100644
index 556597a9b3..0000000000
--- a/src/gui/opengl/qopenglfunctions_2_0.h
+++ /dev/null
@@ -1,3614 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#ifndef QOPENGLVERSIONFUNCTIONS_2_0_H
-#define QOPENGLVERSIONFUNCTIONS_2_0_H
-
-#include <QtGui/qtguiglobal.h>
-
-#if !defined(QT_NO_OPENGL) && !defined(QT_OPENGL_ES_2)
-
-#include <QtGui/QOpenGLVersionFunctions>
-#include <QtGui/qopenglcontext.h>
-
-QT_BEGIN_NAMESPACE
-
-class Q_GUI_EXPORT QOpenGLFunctions_2_0 : public QAbstractOpenGLFunctions
-{
-public:
-    QOpenGLFunctions_2_0();
-    ~QOpenGLFunctions_2_0();
-
-    bool initializeOpenGLFunctions() override;
-
-    // OpenGL 1.0 core functions
-    void glViewport(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glDepthRange(GLdouble nearVal, GLdouble farVal);
-    GLboolean glIsEnabled(GLenum cap);
-    void glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params);
-    void glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params);
-    void glGetTexParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
-    const GLubyte * glGetString(GLenum name);
-    void glGetIntegerv(GLenum pname, GLint *params);
-    void glGetFloatv(GLenum pname, GLfloat *params);
-    GLenum glGetError();
-    void glGetDoublev(GLenum pname, GLdouble *params);
-    void glGetBooleanv(GLenum pname, GLboolean *params);
-    void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
-    void glReadBuffer(GLenum mode);
-    void glPixelStorei(GLenum pname, GLint param);
-    void glPixelStoref(GLenum pname, GLfloat param);
-    void glDepthFunc(GLenum func);
-    void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass);
-    void glStencilFunc(GLenum func, GLint ref, GLuint mask);
-    void glLogicOp(GLenum opcode);
-    void glBlendFunc(GLenum sfactor, GLenum dfactor);
-    void glFlush();
-    void glFinish();
-    void glEnable(GLenum cap);
-    void glDisable(GLenum cap);
-    void glDepthMask(GLboolean flag);
-    void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
-    void glStencilMask(GLuint mask);
-    void glClearDepth(GLdouble depth);
-    void glClearStencil(GLint s);
-    void glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glClear(GLbitfield mask);
-    void glDrawBuffer(GLenum mode);
-    void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glTexParameteri(GLenum target, GLenum pname, GLint param);
-    void glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glTexParameterf(GLenum target, GLenum pname, GLfloat param);
-    void glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glPolygonMode(GLenum face, GLenum mode);
-    void glPointSize(GLfloat size);
-    void glLineWidth(GLfloat width);
-    void glHint(GLenum target, GLenum mode);
-    void glFrontFace(GLenum mode);
-    void glCullFace(GLenum mode);
-
-    // OpenGL 1.1 core functions
-    void glIndexubv(const GLubyte *c);
-    void glIndexub(GLubyte c);
-    GLboolean glIsTexture(GLuint texture);
-    void glGenTextures(GLsizei n, GLuint *textures);
-    void glDeleteTextures(GLsizei n, const GLuint *textures);
-    void glBindTexture(GLenum target, GLuint texture);
-    void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
-    void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
-    void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
-    void glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
-    void glPolygonOffset(GLfloat factor, GLfloat units);
-    void glGetPointerv(GLenum pname, GLvoid* *params);
-    void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
-    void glDrawArrays(GLenum mode, GLint first, GLsizei count);
-
-    // OpenGL 1.2 core functions
-    void glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices);
-    void glBlendEquation(GLenum mode);
-    void glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-
-    // OpenGL 1.3 core functions
-    void glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img);
-    void glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glSampleCoverage(GLfloat value, GLboolean invert);
-    void glActiveTexture(GLenum texture);
-
-    // OpenGL 1.4 core functions
-    void glPointParameteriv(GLenum pname, const GLint *params);
-    void glPointParameteri(GLenum pname, GLint param);
-    void glPointParameterfv(GLenum pname, const GLfloat *params);
-    void glPointParameterf(GLenum pname, GLfloat param);
-    void glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount);
-    void glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount);
-    void glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
-
-    // OpenGL 1.5 core functions
-    void glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params);
-    void glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params);
-    GLboolean glUnmapBuffer(GLenum target);
-    GLvoid* glMapBuffer(GLenum target, GLenum access);
-    void glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data);
-    void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data);
-    void glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage);
-    GLboolean glIsBuffer(GLuint buffer);
-    void glGenBuffers(GLsizei n, GLuint *buffers);
-    void glDeleteBuffers(GLsizei n, const GLuint *buffers);
-    void glBindBuffer(GLenum target, GLuint buffer);
-    void glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params);
-    void glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params);
-    void glGetQueryiv(GLenum target, GLenum pname, GLint *params);
-    void glEndQuery(GLenum target);
-    void glBeginQuery(GLenum target, GLuint id);
-    GLboolean glIsQuery(GLuint id);
-    void glDeleteQueries(GLsizei n, const GLuint *ids);
-    void glGenQueries(GLsizei n, GLuint *ids);
-
-    // OpenGL 2.0 core functions
-    void glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer);
-    void glValidateProgram(GLuint program);
-    void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniform4iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform3iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform2iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform1iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform4fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform3fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform2fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform1fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
-    void glUniform3i(GLint location, GLint v0, GLint v1, GLint v2);
-    void glUniform2i(GLint location, GLint v0, GLint v1);
-    void glUniform1i(GLint location, GLint v0);
-    void glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
-    void glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
-    void glUniform2f(GLint location, GLfloat v0, GLfloat v1);
-    void glUniform1f(GLint location, GLfloat v0);
-    void glUseProgram(GLuint program);
-    void glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length);
-    void glLinkProgram(GLuint program);
-    GLboolean glIsShader(GLuint shader);
-    GLboolean glIsProgram(GLuint program);
-    void glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer);
-    void glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params);
-    void glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params);
-    void glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params);
-    void glGetUniformiv(GLuint program, GLint location, GLint *params);
-    void glGetUniformfv(GLuint program, GLint location, GLfloat *params);
-    GLint glGetUniformLocation(GLuint program, const GLchar *name);
-    void glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source);
-    void glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void glGetShaderiv(GLuint shader, GLenum pname, GLint *params);
-    void glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void glGetProgramiv(GLuint program, GLenum pname, GLint *params);
-    GLint glGetAttribLocation(GLuint program, const GLchar *name);
-    void glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj);
-    void glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
-    void glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
-    void glEnableVertexAttribArray(GLuint index);
-    void glDisableVertexAttribArray(GLuint index);
-    void glDetachShader(GLuint program, GLuint shader);
-    void glDeleteShader(GLuint shader);
-    void glDeleteProgram(GLuint program);
-    GLuint glCreateShader(GLenum type);
-    GLuint glCreateProgram();
-    void glCompileShader(GLuint shader);
-    void glBindAttribLocation(GLuint program, GLuint index, const GLchar *name);
-    void glAttachShader(GLuint program, GLuint shader);
-    void glStencilMaskSeparate(GLenum face, GLuint mask);
-    void glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask);
-    void glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);
-    void glDrawBuffers(GLsizei n, const GLenum *bufs);
-    void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha);
-
-    // OpenGL 1.0 deprecated functions
-    void glTranslatef(GLfloat x, GLfloat y, GLfloat z);
-    void glTranslated(GLdouble x, GLdouble y, GLdouble z);
-    void glScalef(GLfloat x, GLfloat y, GLfloat z);
-    void glScaled(GLdouble x, GLdouble y, GLdouble z);
-    void glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
-    void glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
-    void glPushMatrix();
-    void glPopMatrix();
-    void glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
-    void glMultMatrixd(const GLdouble *m);
-    void glMultMatrixf(const GLfloat *m);
-    void glMatrixMode(GLenum mode);
-    void glLoadMatrixd(const GLdouble *m);
-    void glLoadMatrixf(const GLfloat *m);
-    void glLoadIdentity();
-    void glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
-    GLboolean glIsList(GLuint list);
-    void glGetTexGeniv(GLenum coord, GLenum pname, GLint *params);
-    void glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params);
-    void glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params);
-    void glGetTexEnviv(GLenum target, GLenum pname, GLint *params);
-    void glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetPolygonStipple(GLubyte *mask);
-    void glGetPixelMapusv(GLenum map, GLushort *values);
-    void glGetPixelMapuiv(GLenum map, GLuint *values);
-    void glGetPixelMapfv(GLenum map, GLfloat *values);
-    void glGetMaterialiv(GLenum face, GLenum pname, GLint *params);
-    void glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params);
-    void glGetMapiv(GLenum target, GLenum query, GLint *v);
-    void glGetMapfv(GLenum target, GLenum query, GLfloat *v);
-    void glGetMapdv(GLenum target, GLenum query, GLdouble *v);
-    void glGetLightiv(GLenum light, GLenum pname, GLint *params);
-    void glGetLightfv(GLenum light, GLenum pname, GLfloat *params);
-    void glGetClipPlane(GLenum plane, GLdouble *equation);
-    void glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
-    void glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
-    void glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values);
-    void glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values);
-    void glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values);
-    void glPixelTransferi(GLenum pname, GLint param);
-    void glPixelTransferf(GLenum pname, GLfloat param);
-    void glPixelZoom(GLfloat xfactor, GLfloat yfactor);
-    void glAlphaFunc(GLenum func, GLfloat ref);
-    void glEvalPoint2(GLint i, GLint j);
-    void glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
-    void glEvalPoint1(GLint i);
-    void glEvalMesh1(GLenum mode, GLint i1, GLint i2);
-    void glEvalCoord2fv(const GLfloat *u);
-    void glEvalCoord2f(GLfloat u, GLfloat v);
-    void glEvalCoord2dv(const GLdouble *u);
-    void glEvalCoord2d(GLdouble u, GLdouble v);
-    void glEvalCoord1fv(const GLfloat *u);
-    void glEvalCoord1f(GLfloat u);
-    void glEvalCoord1dv(const GLdouble *u);
-    void glEvalCoord1d(GLdouble u);
-    void glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
-    void glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
-    void glMapGrid1f(GLint un, GLfloat u1, GLfloat u2);
-    void glMapGrid1d(GLint un, GLdouble u1, GLdouble u2);
-    void glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);
-    void glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);
-    void glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);
-    void glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);
-    void glPushAttrib(GLbitfield mask);
-    void glPopAttrib();
-    void glAccum(GLenum op, GLfloat value);
-    void glIndexMask(GLuint mask);
-    void glClearIndex(GLfloat c);
-    void glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glPushName(GLuint name);
-    void glPopName();
-    void glPassThrough(GLfloat token);
-    void glLoadName(GLuint name);
-    void glInitNames();
-    GLint glRenderMode(GLenum mode);
-    void glSelectBuffer(GLsizei size, GLuint *buffer);
-    void glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer);
-    void glTexGeniv(GLenum coord, GLenum pname, const GLint *params);
-    void glTexGeni(GLenum coord, GLenum pname, GLint param);
-    void glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params);
-    void glTexGenf(GLenum coord, GLenum pname, GLfloat param);
-    void glTexGendv(GLenum coord, GLenum pname, const GLdouble *params);
-    void glTexGend(GLenum coord, GLenum pname, GLdouble param);
-    void glTexEnviv(GLenum target, GLenum pname, const GLint *params);
-    void glTexEnvi(GLenum target, GLenum pname, GLint param);
-    void glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glTexEnvf(GLenum target, GLenum pname, GLfloat param);
-    void glShadeModel(GLenum mode);
-    void glPolygonStipple(const GLubyte *mask);
-    void glMaterialiv(GLenum face, GLenum pname, const GLint *params);
-    void glMateriali(GLenum face, GLenum pname, GLint param);
-    void glMaterialfv(GLenum face, GLenum pname, const GLfloat *params);
-    void glMaterialf(GLenum face, GLenum pname, GLfloat param);
-    void glLineStipple(GLint factor, GLushort pattern);
-    void glLightModeliv(GLenum pname, const GLint *params);
-    void glLightModeli(GLenum pname, GLint param);
-    void glLightModelfv(GLenum pname, const GLfloat *params);
-    void glLightModelf(GLenum pname, GLfloat param);
-    void glLightiv(GLenum light, GLenum pname, const GLint *params);
-    void glLighti(GLenum light, GLenum pname, GLint param);
-    void glLightfv(GLenum light, GLenum pname, const GLfloat *params);
-    void glLightf(GLenum light, GLenum pname, GLfloat param);
-    void glFogiv(GLenum pname, const GLint *params);
-    void glFogi(GLenum pname, GLint param);
-    void glFogfv(GLenum pname, const GLfloat *params);
-    void glFogf(GLenum pname, GLfloat param);
-    void glColorMaterial(GLenum face, GLenum mode);
-    void glClipPlane(GLenum plane, const GLdouble *equation);
-    void glVertex4sv(const GLshort *v);
-    void glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w);
-    void glVertex4iv(const GLint *v);
-    void glVertex4i(GLint x, GLint y, GLint z, GLint w);
-    void glVertex4fv(const GLfloat *v);
-    void glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void glVertex4dv(const GLdouble *v);
-    void glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glVertex3sv(const GLshort *v);
-    void glVertex3s(GLshort x, GLshort y, GLshort z);
-    void glVertex3iv(const GLint *v);
-    void glVertex3i(GLint x, GLint y, GLint z);
-    void glVertex3fv(const GLfloat *v);
-    void glVertex3f(GLfloat x, GLfloat y, GLfloat z);
-    void glVertex3dv(const GLdouble *v);
-    void glVertex3d(GLdouble x, GLdouble y, GLdouble z);
-    void glVertex2sv(const GLshort *v);
-    void glVertex2s(GLshort x, GLshort y);
-    void glVertex2iv(const GLint *v);
-    void glVertex2i(GLint x, GLint y);
-    void glVertex2fv(const GLfloat *v);
-    void glVertex2f(GLfloat x, GLfloat y);
-    void glVertex2dv(const GLdouble *v);
-    void glVertex2d(GLdouble x, GLdouble y);
-    void glTexCoord4sv(const GLshort *v);
-    void glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q);
-    void glTexCoord4iv(const GLint *v);
-    void glTexCoord4i(GLint s, GLint t, GLint r, GLint q);
-    void glTexCoord4fv(const GLfloat *v);
-    void glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
-    void glTexCoord4dv(const GLdouble *v);
-    void glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q);
-    void glTexCoord3sv(const GLshort *v);
-    void glTexCoord3s(GLshort s, GLshort t, GLshort r);
-    void glTexCoord3iv(const GLint *v);
-    void glTexCoord3i(GLint s, GLint t, GLint r);
-    void glTexCoord3fv(const GLfloat *v);
-    void glTexCoord3f(GLfloat s, GLfloat t, GLfloat r);
-    void glTexCoord3dv(const GLdouble *v);
-    void glTexCoord3d(GLdouble s, GLdouble t, GLdouble r);
-    void glTexCoord2sv(const GLshort *v);
-    void glTexCoord2s(GLshort s, GLshort t);
-    void glTexCoord2iv(const GLint *v);
-    void glTexCoord2i(GLint s, GLint t);
-    void glTexCoord2fv(const GLfloat *v);
-    void glTexCoord2f(GLfloat s, GLfloat t);
-    void glTexCoord2dv(const GLdouble *v);
-    void glTexCoord2d(GLdouble s, GLdouble t);
-    void glTexCoord1sv(const GLshort *v);
-    void glTexCoord1s(GLshort s);
-    void glTexCoord1iv(const GLint *v);
-    void glTexCoord1i(GLint s);
-    void glTexCoord1fv(const GLfloat *v);
-    void glTexCoord1f(GLfloat s);
-    void glTexCoord1dv(const GLdouble *v);
-    void glTexCoord1d(GLdouble s);
-    void glRectsv(const GLshort *v1, const GLshort *v2);
-    void glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
-    void glRectiv(const GLint *v1, const GLint *v2);
-    void glRecti(GLint x1, GLint y1, GLint x2, GLint y2);
-    void glRectfv(const GLfloat *v1, const GLfloat *v2);
-    void glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
-    void glRectdv(const GLdouble *v1, const GLdouble *v2);
-    void glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
-    void glRasterPos4sv(const GLshort *v);
-    void glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w);
-    void glRasterPos4iv(const GLint *v);
-    void glRasterPos4i(GLint x, GLint y, GLint z, GLint w);
-    void glRasterPos4fv(const GLfloat *v);
-    void glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void glRasterPos4dv(const GLdouble *v);
-    void glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glRasterPos3sv(const GLshort *v);
-    void glRasterPos3s(GLshort x, GLshort y, GLshort z);
-    void glRasterPos3iv(const GLint *v);
-    void glRasterPos3i(GLint x, GLint y, GLint z);
-    void glRasterPos3fv(const GLfloat *v);
-    void glRasterPos3f(GLfloat x, GLfloat y, GLfloat z);
-    void glRasterPos3dv(const GLdouble *v);
-    void glRasterPos3d(GLdouble x, GLdouble y, GLdouble z);
-    void glRasterPos2sv(const GLshort *v);
-    void glRasterPos2s(GLshort x, GLshort y);
-    void glRasterPos2iv(const GLint *v);
-    void glRasterPos2i(GLint x, GLint y);
-    void glRasterPos2fv(const GLfloat *v);
-    void glRasterPos2f(GLfloat x, GLfloat y);
-    void glRasterPos2dv(const GLdouble *v);
-    void glRasterPos2d(GLdouble x, GLdouble y);
-    void glNormal3sv(const GLshort *v);
-    void glNormal3s(GLshort nx, GLshort ny, GLshort nz);
-    void glNormal3iv(const GLint *v);
-    void glNormal3i(GLint nx, GLint ny, GLint nz);
-    void glNormal3fv(const GLfloat *v);
-    void glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz);
-    void glNormal3dv(const GLdouble *v);
-    void glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz);
-    void glNormal3bv(const GLbyte *v);
-    void glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz);
-    void glIndexsv(const GLshort *c);
-    void glIndexs(GLshort c);
-    void glIndexiv(const GLint *c);
-    void glIndexi(GLint c);
-    void glIndexfv(const GLfloat *c);
-    void glIndexf(GLfloat c);
-    void glIndexdv(const GLdouble *c);
-    void glIndexd(GLdouble c);
-    void glEnd();
-    void glEdgeFlagv(const GLboolean *flag);
-    void glEdgeFlag(GLboolean flag);
-    void glColor4usv(const GLushort *v);
-    void glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha);
-    void glColor4uiv(const GLuint *v);
-    void glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha);
-    void glColor4ubv(const GLubyte *v);
-    void glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
-    void glColor4sv(const GLshort *v);
-    void glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha);
-    void glColor4iv(const GLint *v);
-    void glColor4i(GLint red, GLint green, GLint blue, GLint alpha);
-    void glColor4fv(const GLfloat *v);
-    void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glColor4dv(const GLdouble *v);
-    void glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
-    void glColor4bv(const GLbyte *v);
-    void glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
-    void glColor3usv(const GLushort *v);
-    void glColor3us(GLushort red, GLushort green, GLushort blue);
-    void glColor3uiv(const GLuint *v);
-    void glColor3ui(GLuint red, GLuint green, GLuint blue);
-    void glColor3ubv(const GLubyte *v);
-    void glColor3ub(GLubyte red, GLubyte green, GLubyte blue);
-    void glColor3sv(const GLshort *v);
-    void glColor3s(GLshort red, GLshort green, GLshort blue);
-    void glColor3iv(const GLint *v);
-    void glColor3i(GLint red, GLint green, GLint blue);
-    void glColor3fv(const GLfloat *v);
-    void glColor3f(GLfloat red, GLfloat green, GLfloat blue);
-    void glColor3dv(const GLdouble *v);
-    void glColor3d(GLdouble red, GLdouble green, GLdouble blue);
-    void glColor3bv(const GLbyte *v);
-    void glColor3b(GLbyte red, GLbyte green, GLbyte blue);
-    void glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap);
-    void glBegin(GLenum mode);
-    void glListBase(GLuint base);
-    GLuint glGenLists(GLsizei range);
-    void glDeleteLists(GLuint list, GLsizei range);
-    void glCallLists(GLsizei n, GLenum type, const GLvoid *lists);
-    void glCallList(GLuint list);
-    void glEndList();
-    void glNewList(GLuint list, GLenum mode);
-
-    // OpenGL 1.1 deprecated functions
-    void glPushClientAttrib(GLbitfield mask);
-    void glPopClientAttrib();
-    void glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities);
-    GLboolean glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences);
-    void glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer);
-    void glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glEnableClientState(GLenum array);
-    void glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer);
-    void glDisableClientState(GLenum array);
-    void glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glArrayElement(GLint i);
-
-    // OpenGL 1.2 deprecated functions
-    void glResetMinmax(GLenum target);
-    void glResetHistogram(GLenum target);
-    void glMinmax(GLenum target, GLenum internalformat, GLboolean sink);
-    void glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink);
-    void glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
-    void glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
-    void glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column);
-    void glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span);
-    void glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image);
-    void glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
-    void glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glConvolutionParameteri(GLenum target, GLenum pname, GLint params);
-    void glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params);
-    void glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image);
-    void glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image);
-    void glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width);
-    void glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data);
-    void glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table);
-    void glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
-    void glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table);
-
-    // OpenGL 1.3 deprecated functions
-    void glMultTransposeMatrixd(const GLdouble *m);
-    void glMultTransposeMatrixf(const GLfloat *m);
-    void glLoadTransposeMatrixd(const GLdouble *m);
-    void glLoadTransposeMatrixf(const GLfloat *m);
-    void glMultiTexCoord4sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);
-    void glMultiTexCoord4iv(GLenum target, const GLint *v);
-    void glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q);
-    void glMultiTexCoord4fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
-    void glMultiTexCoord4dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
-    void glMultiTexCoord3sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r);
-    void glMultiTexCoord3iv(GLenum target, const GLint *v);
-    void glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r);
-    void glMultiTexCoord3fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r);
-    void glMultiTexCoord3dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r);
-    void glMultiTexCoord2sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord2s(GLenum target, GLshort s, GLshort t);
-    void glMultiTexCoord2iv(GLenum target, const GLint *v);
-    void glMultiTexCoord2i(GLenum target, GLint s, GLint t);
-    void glMultiTexCoord2fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t);
-    void glMultiTexCoord2dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t);
-    void glMultiTexCoord1sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord1s(GLenum target, GLshort s);
-    void glMultiTexCoord1iv(GLenum target, const GLint *v);
-    void glMultiTexCoord1i(GLenum target, GLint s);
-    void glMultiTexCoord1fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord1f(GLenum target, GLfloat s);
-    void glMultiTexCoord1dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord1d(GLenum target, GLdouble s);
-    void glClientActiveTexture(GLenum texture);
-
-    // OpenGL 1.4 deprecated functions
-    void glWindowPos3sv(const GLshort *v);
-    void glWindowPos3s(GLshort x, GLshort y, GLshort z);
-    void glWindowPos3iv(const GLint *v);
-    void glWindowPos3i(GLint x, GLint y, GLint z);
-    void glWindowPos3fv(const GLfloat *v);
-    void glWindowPos3f(GLfloat x, GLfloat y, GLfloat z);
-    void glWindowPos3dv(const GLdouble *v);
-    void glWindowPos3d(GLdouble x, GLdouble y, GLdouble z);
-    void glWindowPos2sv(const GLshort *v);
-    void glWindowPos2s(GLshort x, GLshort y);
-    void glWindowPos2iv(const GLint *v);
-    void glWindowPos2i(GLint x, GLint y);
-    void glWindowPos2fv(const GLfloat *v);
-    void glWindowPos2f(GLfloat x, GLfloat y);
-    void glWindowPos2dv(const GLdouble *v);
-    void glWindowPos2d(GLdouble x, GLdouble y);
-    void glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glSecondaryColor3usv(const GLushort *v);
-    void glSecondaryColor3us(GLushort red, GLushort green, GLushort blue);
-    void glSecondaryColor3uiv(const GLuint *v);
-    void glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue);
-    void glSecondaryColor3ubv(const GLubyte *v);
-    void glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue);
-    void glSecondaryColor3sv(const GLshort *v);
-    void glSecondaryColor3s(GLshort red, GLshort green, GLshort blue);
-    void glSecondaryColor3iv(const GLint *v);
-    void glSecondaryColor3i(GLint red, GLint green, GLint blue);
-    void glSecondaryColor3fv(const GLfloat *v);
-    void glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue);
-    void glSecondaryColor3dv(const GLdouble *v);
-    void glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue);
-    void glSecondaryColor3bv(const GLbyte *v);
-    void glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue);
-    void glFogCoordPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glFogCoorddv(const GLdouble *coord);
-    void glFogCoordd(GLdouble coord);
-    void glFogCoordfv(const GLfloat *coord);
-    void glFogCoordf(GLfloat coord);
-
-    // OpenGL 1.5 deprecated functions
-
-    // OpenGL 2.0 deprecated functions
-    void glVertexAttrib4usv(GLuint index, const GLushort *v);
-    void glVertexAttrib4uiv(GLuint index, const GLuint *v);
-    void glVertexAttrib4ubv(GLuint index, const GLubyte *v);
-    void glVertexAttrib4sv(GLuint index, const GLshort *v);
-    void glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
-    void glVertexAttrib4iv(GLuint index, const GLint *v);
-    void glVertexAttrib4fv(GLuint index, const GLfloat *v);
-    void glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void glVertexAttrib4dv(GLuint index, const GLdouble *v);
-    void glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glVertexAttrib4bv(GLuint index, const GLbyte *v);
-    void glVertexAttrib4Nusv(GLuint index, const GLushort *v);
-    void glVertexAttrib4Nuiv(GLuint index, const GLuint *v);
-    void glVertexAttrib4Nubv(GLuint index, const GLubyte *v);
-    void glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
-    void glVertexAttrib4Nsv(GLuint index, const GLshort *v);
-    void glVertexAttrib4Niv(GLuint index, const GLint *v);
-    void glVertexAttrib4Nbv(GLuint index, const GLbyte *v);
-    void glVertexAttrib3sv(GLuint index, const GLshort *v);
-    void glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z);
-    void glVertexAttrib3fv(GLuint index, const GLfloat *v);
-    void glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z);
-    void glVertexAttrib3dv(GLuint index, const GLdouble *v);
-    void glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z);
-    void glVertexAttrib2sv(GLuint index, const GLshort *v);
-    void glVertexAttrib2s(GLuint index, GLshort x, GLshort y);
-    void glVertexAttrib2fv(GLuint index, const GLfloat *v);
-    void glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y);
-    void glVertexAttrib2dv(GLuint index, const GLdouble *v);
-    void glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y);
-    void glVertexAttrib1sv(GLuint index, const GLshort *v);
-    void glVertexAttrib1s(GLuint index, GLshort x);
-    void glVertexAttrib1fv(GLuint index, const GLfloat *v);
-    void glVertexAttrib1f(GLuint index, GLfloat x);
-    void glVertexAttrib1dv(GLuint index, const GLdouble *v);
-    void glVertexAttrib1d(GLuint index, GLdouble x);
-
-private:
-    friend class QOpenGLContext;
-
-    static bool isContextCompatible(QOpenGLContext *context);
-    static QOpenGLVersionProfile versionProfile();
-
-    QOpenGLFunctions_1_0_CoreBackend* d_1_0_Core;
-    QOpenGLFunctions_1_1_CoreBackend* d_1_1_Core;
-    QOpenGLFunctions_1_2_CoreBackend* d_1_2_Core;
-    QOpenGLFunctions_1_3_CoreBackend* d_1_3_Core;
-    QOpenGLFunctions_1_4_CoreBackend* d_1_4_Core;
-    QOpenGLFunctions_1_5_CoreBackend* d_1_5_Core;
-    QOpenGLFunctions_2_0_CoreBackend* d_2_0_Core;
-    QOpenGLFunctions_1_0_DeprecatedBackend* d_1_0_Deprecated;
-    QOpenGLFunctions_1_1_DeprecatedBackend* d_1_1_Deprecated;
-    QOpenGLFunctions_1_2_DeprecatedBackend* d_1_2_Deprecated;
-    QOpenGLFunctions_1_3_DeprecatedBackend* d_1_3_Deprecated;
-    QOpenGLFunctions_1_4_DeprecatedBackend* d_1_4_Deprecated;
-    void *m_reserved_2_0_Deprecated; // To maintain BC
-};
-
-// OpenGL 1.0 core functions
-inline void QOpenGLFunctions_2_0::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_0_Core->f.Viewport(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_2_0::glDepthRange(GLdouble nearVal, GLdouble farVal)
-{
-    d_1_0_Core->f.DepthRange(nearVal, farVal);
-}
-
-inline GLboolean QOpenGLFunctions_2_0::glIsEnabled(GLenum cap)
-{
-    return d_1_0_Core->f.IsEnabled(cap);
-}
-
-inline void QOpenGLFunctions_2_0::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetTexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetTexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
-{
-    d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
-}
-
-inline const GLubyte * QOpenGLFunctions_2_0::glGetString(GLenum name)
-{
-    return d_1_0_Core->f.GetString(name);
-}
-
-inline void QOpenGLFunctions_2_0::glGetIntegerv(GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetIntegerv(pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glGetFloatv(GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetFloatv(pname, params);
-}
-
-inline GLenum QOpenGLFunctions_2_0::glGetError()
-{
-    return d_1_0_Core->f.GetError();
-}
-
-inline void QOpenGLFunctions_2_0::glGetDoublev(GLenum pname, GLdouble *params)
-{
-    d_1_0_Core->f.GetDoublev(pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glGetBooleanv(GLenum pname, GLboolean *params)
-{
-    d_1_0_Core->f.GetBooleanv(pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
-{
-    d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_2_0::glReadBuffer(GLenum mode)
-{
-    d_1_0_Core->f.ReadBuffer(mode);
-}
-
-inline void QOpenGLFunctions_2_0::glPixelStorei(GLenum pname, GLint param)
-{
-    d_1_0_Core->f.PixelStorei(pname, param);
-}
-
-inline void QOpenGLFunctions_2_0::glPixelStoref(GLenum pname, GLfloat param)
-{
-    d_1_0_Core->f.PixelStoref(pname, param);
-}
-
-inline void QOpenGLFunctions_2_0::glDepthFunc(GLenum func)
-{
-    d_1_0_Core->f.DepthFunc(func);
-}
-
-inline void QOpenGLFunctions_2_0::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
-{
-    d_1_0_Core->f.StencilOp(fail, zfail, zpass);
-}
-
-inline void QOpenGLFunctions_2_0::glStencilFunc(GLenum func, GLint ref, GLuint mask)
-{
-    d_1_0_Core->f.StencilFunc(func, ref, mask);
-}
-
-inline void QOpenGLFunctions_2_0::glLogicOp(GLenum opcode)
-{
-    d_1_0_Core->f.LogicOp(opcode);
-}
-
-inline void QOpenGLFunctions_2_0::glBlendFunc(GLenum sfactor, GLenum dfactor)
-{
-    d_1_0_Core->f.BlendFunc(sfactor, dfactor);
-}
-
-inline void QOpenGLFunctions_2_0::glFlush()
-{
-    d_1_0_Core->f.Flush();
-}
-
-inline void QOpenGLFunctions_2_0::glFinish()
-{
-    d_1_0_Core->f.Finish();
-}
-
-inline void QOpenGLFunctions_2_0::glEnable(GLenum cap)
-{
-    d_1_0_Core->f.Enable(cap);
-}
-
-inline void QOpenGLFunctions_2_0::glDisable(GLenum cap)
-{
-    d_1_0_Core->f.Disable(cap);
-}
-
-inline void QOpenGLFunctions_2_0::glDepthMask(GLboolean flag)
-{
-    d_1_0_Core->f.DepthMask(flag);
-}
-
-inline void QOpenGLFunctions_2_0::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
-{
-    d_1_0_Core->f.ColorMask(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_2_0::glStencilMask(GLuint mask)
-{
-    d_1_0_Core->f.StencilMask(mask);
-}
-
-inline void QOpenGLFunctions_2_0::glClearDepth(GLdouble depth)
-{
-    d_1_0_Core->f.ClearDepth(depth);
-}
-
-inline void QOpenGLFunctions_2_0::glClearStencil(GLint s)
-{
-    d_1_0_Core->f.ClearStencil(s);
-}
-
-inline void QOpenGLFunctions_2_0::glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Core->f.ClearColor(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_2_0::glClear(GLbitfield mask)
-{
-    d_1_0_Core->f.Clear(mask);
-}
-
-inline void QOpenGLFunctions_2_0::glDrawBuffer(GLenum mode)
-{
-    d_1_0_Core->f.DrawBuffer(mode);
-}
-
-inline void QOpenGLFunctions_2_0::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Core->f.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_2_0::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Core->f.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_2_0::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_0_Core->f.TexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glTexParameteri(GLenum target, GLenum pname, GLint param)
-{
-    d_1_0_Core->f.TexParameteri(target, pname, param);
-}
-
-inline void QOpenGLFunctions_2_0::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Core->f.TexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
-{
-    d_1_0_Core->f.TexParameterf(target, pname, param);
-}
-
-inline void QOpenGLFunctions_2_0::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_0_Core->f.Scissor(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_2_0::glPolygonMode(GLenum face, GLenum mode)
-{
-    d_1_0_Core->f.PolygonMode(face, mode);
-}
-
-inline void QOpenGLFunctions_2_0::glPointSize(GLfloat size)
-{
-    d_1_0_Core->f.PointSize(size);
-}
-
-inline void QOpenGLFunctions_2_0::glLineWidth(GLfloat width)
-{
-    d_1_0_Core->f.LineWidth(width);
-}
-
-inline void QOpenGLFunctions_2_0::glHint(GLenum target, GLenum mode)
-{
-    d_1_0_Core->f.Hint(target, mode);
-}
-
-inline void QOpenGLFunctions_2_0::glFrontFace(GLenum mode)
-{
-    d_1_0_Core->f.FrontFace(mode);
-}
-
-inline void QOpenGLFunctions_2_0::glCullFace(GLenum mode)
-{
-    d_1_0_Core->f.CullFace(mode);
-}
-
-
-// OpenGL 1.1 core functions
-inline void QOpenGLFunctions_2_0::glIndexubv(const GLubyte *c)
-{
-    d_1_1_Deprecated->f.Indexubv(c);
-}
-
-inline void QOpenGLFunctions_2_0::glIndexub(GLubyte c)
-{
-    d_1_1_Deprecated->f.Indexub(c);
-}
-
-inline GLboolean QOpenGLFunctions_2_0::glIsTexture(GLuint texture)
-{
-    return d_1_1_Core->f.IsTexture(texture);
-}
-
-inline void QOpenGLFunctions_2_0::glGenTextures(GLsizei n, GLuint *textures)
-{
-    d_1_1_Core->f.GenTextures(n, textures);
-}
-
-inline void QOpenGLFunctions_2_0::glDeleteTextures(GLsizei n, const GLuint *textures)
-{
-    d_1_1_Core->f.DeleteTextures(n, textures);
-}
-
-inline void QOpenGLFunctions_2_0::glBindTexture(GLenum target, GLuint texture)
-{
-    d_1_1_Core->f.BindTexture(target, texture);
-}
-
-inline void QOpenGLFunctions_2_0::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_1_Core->f.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_2_0::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_1_Core->f.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_2_0::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_1_Core->f.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_2_0::glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
-{
-    d_1_1_Core->f.CopyTexSubImage1D(target, level, xoffset, x, y, width);
-}
-
-inline void QOpenGLFunctions_2_0::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
-{
-    d_1_1_Core->f.CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
-}
-
-inline void QOpenGLFunctions_2_0::glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
-{
-    d_1_1_Core->f.CopyTexImage1D(target, level, internalformat, x, y, width, border);
-}
-
-inline void QOpenGLFunctions_2_0::glPolygonOffset(GLfloat factor, GLfloat units)
-{
-    d_1_1_Core->f.PolygonOffset(factor, units);
-}
-
-inline void QOpenGLFunctions_2_0::glGetPointerv(GLenum pname, GLvoid* *params)
-{
-    d_1_1_Deprecated->f.GetPointerv(pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
-{
-    d_1_1_Core->f.DrawElements(mode, count, type, indices);
-}
-
-inline void QOpenGLFunctions_2_0::glDrawArrays(GLenum mode, GLint first, GLsizei count)
-{
-    d_1_1_Core->f.DrawArrays(mode, first, count);
-}
-
-
-// OpenGL 1.2 core functions
-inline void QOpenGLFunctions_2_0::glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_2_Core->f.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_2_0::glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_2_Core->f.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_2_0::glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_2_Core->f.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_2_0::glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
-{
-    d_1_2_Core->f.DrawRangeElements(mode, start, end, count, type, indices);
-}
-
-inline void QOpenGLFunctions_2_0::glBlendEquation(GLenum mode)
-{
-    d_1_2_Core->f.BlendEquation(mode);
-}
-
-inline void QOpenGLFunctions_2_0::glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_2_Core->f.BlendColor(red, green, blue, alpha);
-}
-
-
-// OpenGL 1.3 core functions
-inline void QOpenGLFunctions_2_0::glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img)
-{
-    d_1_3_Core->f.GetCompressedTexImage(target, level, img);
-}
-
-inline void QOpenGLFunctions_2_0::glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_2_0::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_2_0::glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_2_0::glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_2_0::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_2_0::glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_2_0::glSampleCoverage(GLfloat value, GLboolean invert)
-{
-    d_1_3_Core->f.SampleCoverage(value, invert);
-}
-
-inline void QOpenGLFunctions_2_0::glActiveTexture(GLenum texture)
-{
-    d_1_3_Core->f.ActiveTexture(texture);
-}
-
-
-// OpenGL 1.4 core functions
-inline void QOpenGLFunctions_2_0::glPointParameteriv(GLenum pname, const GLint *params)
-{
-    d_1_4_Core->f.PointParameteriv(pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glPointParameteri(GLenum pname, GLint param)
-{
-    d_1_4_Core->f.PointParameteri(pname, param);
-}
-
-inline void QOpenGLFunctions_2_0::glPointParameterfv(GLenum pname, const GLfloat *params)
-{
-    d_1_4_Core->f.PointParameterfv(pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glPointParameterf(GLenum pname, GLfloat param)
-{
-    d_1_4_Core->f.PointParameterf(pname, param);
-}
-
-inline void QOpenGLFunctions_2_0::glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount)
-{
-    d_1_4_Core->f.MultiDrawElements(mode, count, type, indices, drawcount);
-}
-
-inline void QOpenGLFunctions_2_0::glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
-{
-    d_1_4_Core->f.MultiDrawArrays(mode, first, count, drawcount);
-}
-
-inline void QOpenGLFunctions_2_0::glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
-{
-    d_1_4_Core->f.BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
-}
-
-
-// OpenGL 1.5 core functions
-inline void QOpenGLFunctions_2_0::glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params)
-{
-    d_1_5_Core->f.GetBufferPointerv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetBufferParameteriv(target, pname, params);
-}
-
-inline GLboolean QOpenGLFunctions_2_0::glUnmapBuffer(GLenum target)
-{
-    return d_1_5_Core->f.UnmapBuffer(target);
-}
-
-inline GLvoid* QOpenGLFunctions_2_0::glMapBuffer(GLenum target, GLenum access)
-{
-    return d_1_5_Core->f.MapBuffer(target, access);
-}
-
-inline void QOpenGLFunctions_2_0::glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data)
-{
-    d_1_5_Core->f.GetBufferSubData(target, offset, size, data);
-}
-
-inline void QOpenGLFunctions_2_0::glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data)
-{
-    d_1_5_Core->f.BufferSubData(target, offset, size, data);
-}
-
-inline void QOpenGLFunctions_2_0::glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)
-{
-    d_1_5_Core->f.BufferData(target, size, data, usage);
-}
-
-inline GLboolean QOpenGLFunctions_2_0::glIsBuffer(GLuint buffer)
-{
-    return d_1_5_Core->f.IsBuffer(buffer);
-}
-
-inline void QOpenGLFunctions_2_0::glGenBuffers(GLsizei n, GLuint *buffers)
-{
-    d_1_5_Core->f.GenBuffers(n, buffers);
-}
-
-inline void QOpenGLFunctions_2_0::glDeleteBuffers(GLsizei n, const GLuint *buffers)
-{
-    d_1_5_Core->f.DeleteBuffers(n, buffers);
-}
-
-inline void QOpenGLFunctions_2_0::glBindBuffer(GLenum target, GLuint buffer)
-{
-    d_1_5_Core->f.BindBuffer(target, buffer);
-}
-
-inline void QOpenGLFunctions_2_0::glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
-{
-    d_1_5_Core->f.GetQueryObjectuiv(id, pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetQueryObjectiv(id, pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glGetQueryiv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetQueryiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glEndQuery(GLenum target)
-{
-    d_1_5_Core->f.EndQuery(target);
-}
-
-inline void QOpenGLFunctions_2_0::glBeginQuery(GLenum target, GLuint id)
-{
-    d_1_5_Core->f.BeginQuery(target, id);
-}
-
-inline GLboolean QOpenGLFunctions_2_0::glIsQuery(GLuint id)
-{
-    return d_1_5_Core->f.IsQuery(id);
-}
-
-inline void QOpenGLFunctions_2_0::glDeleteQueries(GLsizei n, const GLuint *ids)
-{
-    d_1_5_Core->f.DeleteQueries(n, ids);
-}
-
-inline void QOpenGLFunctions_2_0::glGenQueries(GLsizei n, GLuint *ids)
-{
-    d_1_5_Core->f.GenQueries(n, ids);
-}
-
-
-// OpenGL 2.0 core functions
-inline void QOpenGLFunctions_2_0::glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer)
-{
-    d_2_0_Core->f.VertexAttribPointer(index, size, type, normalized, stride, pointer);
-}
-
-inline void QOpenGLFunctions_2_0::glValidateProgram(GLuint program)
-{
-    d_2_0_Core->f.ValidateProgram(program);
-}
-
-inline void QOpenGLFunctions_2_0::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_2_0::glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix3fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_2_0::glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_2_0::glUniform4iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform4iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_2_0::glUniform3iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform3iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_2_0::glUniform2iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform2iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_2_0::glUniform1iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform1iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_2_0::glUniform4fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform4fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_2_0::glUniform3fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform3fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_2_0::glUniform2fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform2fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_2_0::glUniform1fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform1fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_2_0::glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
-{
-    d_2_0_Core->f.Uniform4i(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_2_0::glUniform3i(GLint location, GLint v0, GLint v1, GLint v2)
-{
-    d_2_0_Core->f.Uniform3i(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_2_0::glUniform2i(GLint location, GLint v0, GLint v1)
-{
-    d_2_0_Core->f.Uniform2i(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_2_0::glUniform1i(GLint location, GLint v0)
-{
-    d_2_0_Core->f.Uniform1i(location, v0);
-}
-
-inline void QOpenGLFunctions_2_0::glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
-{
-    d_2_0_Core->f.Uniform4f(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_2_0::glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
-{
-    d_2_0_Core->f.Uniform3f(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_2_0::glUniform2f(GLint location, GLfloat v0, GLfloat v1)
-{
-    d_2_0_Core->f.Uniform2f(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_2_0::glUniform1f(GLint location, GLfloat v0)
-{
-    d_2_0_Core->f.Uniform1f(location, v0);
-}
-
-inline void QOpenGLFunctions_2_0::glUseProgram(GLuint program)
-{
-    d_2_0_Core->f.UseProgram(program);
-}
-
-inline void QOpenGLFunctions_2_0::glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length)
-{
-    d_2_0_Core->f.ShaderSource(shader, count, string, length);
-}
-
-inline void QOpenGLFunctions_2_0::glLinkProgram(GLuint program)
-{
-    d_2_0_Core->f.LinkProgram(program);
-}
-
-inline GLboolean QOpenGLFunctions_2_0::glIsShader(GLuint shader)
-{
-    return d_2_0_Core->f.IsShader(shader);
-}
-
-inline GLboolean QOpenGLFunctions_2_0::glIsProgram(GLuint program)
-{
-    return d_2_0_Core->f.IsProgram(program);
-}
-
-inline void QOpenGLFunctions_2_0::glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer)
-{
-    d_2_0_Core->f.GetVertexAttribPointerv(index, pname, pointer);
-}
-
-inline void QOpenGLFunctions_2_0::glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetVertexAttribiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
-{
-    d_2_0_Core->f.GetVertexAttribfv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
-{
-    d_2_0_Core->f.GetVertexAttribdv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glGetUniformiv(GLuint program, GLint location, GLint *params)
-{
-    d_2_0_Core->f.GetUniformiv(program, location, params);
-}
-
-inline void QOpenGLFunctions_2_0::glGetUniformfv(GLuint program, GLint location, GLfloat *params)
-{
-    d_2_0_Core->f.GetUniformfv(program, location, params);
-}
-
-inline GLint QOpenGLFunctions_2_0::glGetUniformLocation(GLuint program, const GLchar *name)
-{
-    return d_2_0_Core->f.GetUniformLocation(program, name);
-}
-
-inline void QOpenGLFunctions_2_0::glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
-{
-    d_2_0_Core->f.GetShaderSource(shader, bufSize, length, source);
-}
-
-inline void QOpenGLFunctions_2_0::glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-{
-    d_2_0_Core->f.GetShaderInfoLog(shader, bufSize, length, infoLog);
-}
-
-inline void QOpenGLFunctions_2_0::glGetShaderiv(GLuint shader, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetShaderiv(shader, pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-{
-    d_2_0_Core->f.GetProgramInfoLog(program, bufSize, length, infoLog);
-}
-
-inline void QOpenGLFunctions_2_0::glGetProgramiv(GLuint program, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetProgramiv(program, pname, params);
-}
-
-inline GLint QOpenGLFunctions_2_0::glGetAttribLocation(GLuint program, const GLchar *name)
-{
-    return d_2_0_Core->f.GetAttribLocation(program, name);
-}
-
-inline void QOpenGLFunctions_2_0::glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj)
-{
-    d_2_0_Core->f.GetAttachedShaders(program, maxCount, count, obj);
-}
-
-inline void QOpenGLFunctions_2_0::glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
-{
-    d_2_0_Core->f.GetActiveUniform(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_2_0::glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
-{
-    d_2_0_Core->f.GetActiveAttrib(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_2_0::glEnableVertexAttribArray(GLuint index)
-{
-    d_2_0_Core->f.EnableVertexAttribArray(index);
-}
-
-inline void QOpenGLFunctions_2_0::glDisableVertexAttribArray(GLuint index)
-{
-    d_2_0_Core->f.DisableVertexAttribArray(index);
-}
-
-inline void QOpenGLFunctions_2_0::glDetachShader(GLuint program, GLuint shader)
-{
-    d_2_0_Core->f.DetachShader(program, shader);
-}
-
-inline void QOpenGLFunctions_2_0::glDeleteShader(GLuint shader)
-{
-    d_2_0_Core->f.DeleteShader(shader);
-}
-
-inline void QOpenGLFunctions_2_0::glDeleteProgram(GLuint program)
-{
-    d_2_0_Core->f.DeleteProgram(program);
-}
-
-inline GLuint QOpenGLFunctions_2_0::glCreateShader(GLenum type)
-{
-    return d_2_0_Core->f.CreateShader(type);
-}
-
-inline GLuint QOpenGLFunctions_2_0::glCreateProgram()
-{
-    return d_2_0_Core->f.CreateProgram();
-}
-
-inline void QOpenGLFunctions_2_0::glCompileShader(GLuint shader)
-{
-    d_2_0_Core->f.CompileShader(shader);
-}
-
-inline void QOpenGLFunctions_2_0::glBindAttribLocation(GLuint program, GLuint index, const GLchar *name)
-{
-    d_2_0_Core->f.BindAttribLocation(program, index, name);
-}
-
-inline void QOpenGLFunctions_2_0::glAttachShader(GLuint program, GLuint shader)
-{
-    d_2_0_Core->f.AttachShader(program, shader);
-}
-
-inline void QOpenGLFunctions_2_0::glStencilMaskSeparate(GLenum face, GLuint mask)
-{
-    d_2_0_Core->f.StencilMaskSeparate(face, mask);
-}
-
-inline void QOpenGLFunctions_2_0::glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
-{
-    d_2_0_Core->f.StencilFuncSeparate(face, func, ref, mask);
-}
-
-inline void QOpenGLFunctions_2_0::glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
-{
-    d_2_0_Core->f.StencilOpSeparate(face, sfail, dpfail, dppass);
-}
-
-inline void QOpenGLFunctions_2_0::glDrawBuffers(GLsizei n, const GLenum *bufs)
-{
-    d_2_0_Core->f.DrawBuffers(n, bufs);
-}
-
-inline void QOpenGLFunctions_2_0::glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
-{
-    d_2_0_Core->f.BlendEquationSeparate(modeRGB, modeAlpha);
-}
-
-
-// OpenGL 1.0 deprecated functions
-inline void QOpenGLFunctions_2_0::glTranslatef(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Translatef(x, y, z);
-}
-
-inline void QOpenGLFunctions_2_0::glTranslated(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Translated(x, y, z);
-}
-
-inline void QOpenGLFunctions_2_0::glScalef(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Scalef(x, y, z);
-}
-
-inline void QOpenGLFunctions_2_0::glScaled(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Scaled(x, y, z);
-}
-
-inline void QOpenGLFunctions_2_0::glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Rotatef(angle, x, y, z);
-}
-
-inline void QOpenGLFunctions_2_0::glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Rotated(angle, x, y, z);
-}
-
-inline void QOpenGLFunctions_2_0::glPushMatrix()
-{
-    d_1_0_Deprecated->f.PushMatrix();
-}
-
-inline void QOpenGLFunctions_2_0::glPopMatrix()
-{
-    d_1_0_Deprecated->f.PopMatrix();
-}
-
-inline void QOpenGLFunctions_2_0::glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
-{
-    d_1_0_Deprecated->f.Ortho(left, right, bottom, top, zNear, zFar);
-}
-
-inline void QOpenGLFunctions_2_0::glMultMatrixd(const GLdouble *m)
-{
-    d_1_0_Deprecated->f.MultMatrixd(m);
-}
-
-inline void QOpenGLFunctions_2_0::glMultMatrixf(const GLfloat *m)
-{
-    d_1_0_Deprecated->f.MultMatrixf(m);
-}
-
-inline void QOpenGLFunctions_2_0::glMatrixMode(GLenum mode)
-{
-    d_1_0_Deprecated->f.MatrixMode(mode);
-}
-
-inline void QOpenGLFunctions_2_0::glLoadMatrixd(const GLdouble *m)
-{
-    d_1_0_Deprecated->f.LoadMatrixd(m);
-}
-
-inline void QOpenGLFunctions_2_0::glLoadMatrixf(const GLfloat *m)
-{
-    d_1_0_Deprecated->f.LoadMatrixf(m);
-}
-
-inline void QOpenGLFunctions_2_0::glLoadIdentity()
-{
-    d_1_0_Deprecated->f.LoadIdentity();
-}
-
-inline void QOpenGLFunctions_2_0::glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
-{
-    d_1_0_Deprecated->f.Frustum(left, right, bottom, top, zNear, zFar);
-}
-
-inline GLboolean QOpenGLFunctions_2_0::glIsList(GLuint list)
-{
-    return d_1_0_Deprecated->f.IsList(list);
-}
-
-inline void QOpenGLFunctions_2_0::glGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetTexGeniv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetTexGenfv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
-{
-    d_1_0_Deprecated->f.GetTexGendv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glGetTexEnviv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetTexEnviv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetTexEnvfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glGetPolygonStipple(GLubyte *mask)
-{
-    d_1_0_Deprecated->f.GetPolygonStipple(mask);
-}
-
-inline void QOpenGLFunctions_2_0::glGetPixelMapusv(GLenum map, GLushort *values)
-{
-    d_1_0_Deprecated->f.GetPixelMapusv(map, values);
-}
-
-inline void QOpenGLFunctions_2_0::glGetPixelMapuiv(GLenum map, GLuint *values)
-{
-    d_1_0_Deprecated->f.GetPixelMapuiv(map, values);
-}
-
-inline void QOpenGLFunctions_2_0::glGetPixelMapfv(GLenum map, GLfloat *values)
-{
-    d_1_0_Deprecated->f.GetPixelMapfv(map, values);
-}
-
-inline void QOpenGLFunctions_2_0::glGetMaterialiv(GLenum face, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetMaterialiv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetMaterialfv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glGetMapiv(GLenum target, GLenum query, GLint *v)
-{
-    d_1_0_Deprecated->f.GetMapiv(target, query, v);
-}
-
-inline void QOpenGLFunctions_2_0::glGetMapfv(GLenum target, GLenum query, GLfloat *v)
-{
-    d_1_0_Deprecated->f.GetMapfv(target, query, v);
-}
-
-inline void QOpenGLFunctions_2_0::glGetMapdv(GLenum target, GLenum query, GLdouble *v)
-{
-    d_1_0_Deprecated->f.GetMapdv(target, query, v);
-}
-
-inline void QOpenGLFunctions_2_0::glGetLightiv(GLenum light, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetLightiv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glGetLightfv(GLenum light, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetLightfv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glGetClipPlane(GLenum plane, GLdouble *equation)
-{
-    d_1_0_Deprecated->f.GetClipPlane(plane, equation);
-}
-
-inline void QOpenGLFunctions_2_0::glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Deprecated->f.DrawPixels(width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_2_0::glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
-{
-    d_1_0_Deprecated->f.CopyPixels(x, y, width, height, type);
-}
-
-inline void QOpenGLFunctions_2_0::glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values)
-{
-    d_1_0_Deprecated->f.PixelMapusv(map, mapsize, values);
-}
-
-inline void QOpenGLFunctions_2_0::glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values)
-{
-    d_1_0_Deprecated->f.PixelMapuiv(map, mapsize, values);
-}
-
-inline void QOpenGLFunctions_2_0::glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values)
-{
-    d_1_0_Deprecated->f.PixelMapfv(map, mapsize, values);
-}
-
-inline void QOpenGLFunctions_2_0::glPixelTransferi(GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.PixelTransferi(pname, param);
-}
-
-inline void QOpenGLFunctions_2_0::glPixelTransferf(GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.PixelTransferf(pname, param);
-}
-
-inline void QOpenGLFunctions_2_0::glPixelZoom(GLfloat xfactor, GLfloat yfactor)
-{
-    d_1_0_Deprecated->f.PixelZoom(xfactor, yfactor);
-}
-
-inline void QOpenGLFunctions_2_0::glAlphaFunc(GLenum func, GLfloat ref)
-{
-    d_1_0_Deprecated->f.AlphaFunc(func, ref);
-}
-
-inline void QOpenGLFunctions_2_0::glEvalPoint2(GLint i, GLint j)
-{
-    d_1_0_Deprecated->f.EvalPoint2(i, j);
-}
-
-inline void QOpenGLFunctions_2_0::glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
-{
-    d_1_0_Deprecated->f.EvalMesh2(mode, i1, i2, j1, j2);
-}
-
-inline void QOpenGLFunctions_2_0::glEvalPoint1(GLint i)
-{
-    d_1_0_Deprecated->f.EvalPoint1(i);
-}
-
-inline void QOpenGLFunctions_2_0::glEvalMesh1(GLenum mode, GLint i1, GLint i2)
-{
-    d_1_0_Deprecated->f.EvalMesh1(mode, i1, i2);
-}
-
-inline void QOpenGLFunctions_2_0::glEvalCoord2fv(const GLfloat *u)
-{
-    d_1_0_Deprecated->f.EvalCoord2fv(u);
-}
-
-inline void QOpenGLFunctions_2_0::glEvalCoord2f(GLfloat u, GLfloat v)
-{
-    d_1_0_Deprecated->f.EvalCoord2f(u, v);
-}
-
-inline void QOpenGLFunctions_2_0::glEvalCoord2dv(const GLdouble *u)
-{
-    d_1_0_Deprecated->f.EvalCoord2dv(u);
-}
-
-inline void QOpenGLFunctions_2_0::glEvalCoord2d(GLdouble u, GLdouble v)
-{
-    d_1_0_Deprecated->f.EvalCoord2d(u, v);
-}
-
-inline void QOpenGLFunctions_2_0::glEvalCoord1fv(const GLfloat *u)
-{
-    d_1_0_Deprecated->f.EvalCoord1fv(u);
-}
-
-inline void QOpenGLFunctions_2_0::glEvalCoord1f(GLfloat u)
-{
-    d_1_0_Deprecated->f.EvalCoord1f(u);
-}
-
-inline void QOpenGLFunctions_2_0::glEvalCoord1dv(const GLdouble *u)
-{
-    d_1_0_Deprecated->f.EvalCoord1dv(u);
-}
-
-inline void QOpenGLFunctions_2_0::glEvalCoord1d(GLdouble u)
-{
-    d_1_0_Deprecated->f.EvalCoord1d(u);
-}
-
-inline void QOpenGLFunctions_2_0::glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
-{
-    d_1_0_Deprecated->f.MapGrid2f(un, u1, u2, vn, v1, v2);
-}
-
-inline void QOpenGLFunctions_2_0::glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
-{
-    d_1_0_Deprecated->f.MapGrid2d(un, u1, u2, vn, v1, v2);
-}
-
-inline void QOpenGLFunctions_2_0::glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
-{
-    d_1_0_Deprecated->f.MapGrid1f(un, u1, u2);
-}
-
-inline void QOpenGLFunctions_2_0::glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
-{
-    d_1_0_Deprecated->f.MapGrid1d(un, u1, u2);
-}
-
-inline void QOpenGLFunctions_2_0::glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
-{
-    d_1_0_Deprecated->f.Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
-}
-
-inline void QOpenGLFunctions_2_0::glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
-{
-    d_1_0_Deprecated->f.Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
-}
-
-inline void QOpenGLFunctions_2_0::glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
-{
-    d_1_0_Deprecated->f.Map1f(target, u1, u2, stride, order, points);
-}
-
-inline void QOpenGLFunctions_2_0::glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
-{
-    d_1_0_Deprecated->f.Map1d(target, u1, u2, stride, order, points);
-}
-
-inline void QOpenGLFunctions_2_0::glPushAttrib(GLbitfield mask)
-{
-    d_1_0_Deprecated->f.PushAttrib(mask);
-}
-
-inline void QOpenGLFunctions_2_0::glPopAttrib()
-{
-    d_1_0_Deprecated->f.PopAttrib();
-}
-
-inline void QOpenGLFunctions_2_0::glAccum(GLenum op, GLfloat value)
-{
-    d_1_0_Deprecated->f.Accum(op, value);
-}
-
-inline void QOpenGLFunctions_2_0::glIndexMask(GLuint mask)
-{
-    d_1_0_Deprecated->f.IndexMask(mask);
-}
-
-inline void QOpenGLFunctions_2_0::glClearIndex(GLfloat c)
-{
-    d_1_0_Deprecated->f.ClearIndex(c);
-}
-
-inline void QOpenGLFunctions_2_0::glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Deprecated->f.ClearAccum(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_2_0::glPushName(GLuint name)
-{
-    d_1_0_Deprecated->f.PushName(name);
-}
-
-inline void QOpenGLFunctions_2_0::glPopName()
-{
-    d_1_0_Deprecated->f.PopName();
-}
-
-inline void QOpenGLFunctions_2_0::glPassThrough(GLfloat token)
-{
-    d_1_0_Deprecated->f.PassThrough(token);
-}
-
-inline void QOpenGLFunctions_2_0::glLoadName(GLuint name)
-{
-    d_1_0_Deprecated->f.LoadName(name);
-}
-
-inline void QOpenGLFunctions_2_0::glInitNames()
-{
-    d_1_0_Deprecated->f.InitNames();
-}
-
-inline GLint QOpenGLFunctions_2_0::glRenderMode(GLenum mode)
-{
-    return d_1_0_Deprecated->f.RenderMode(mode);
-}
-
-inline void QOpenGLFunctions_2_0::glSelectBuffer(GLsizei size, GLuint *buffer)
-{
-    d_1_0_Deprecated->f.SelectBuffer(size, buffer);
-}
-
-inline void QOpenGLFunctions_2_0::glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
-{
-    d_1_0_Deprecated->f.FeedbackBuffer(size, type, buffer);
-}
-
-inline void QOpenGLFunctions_2_0::glTexGeniv(GLenum coord, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.TexGeniv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glTexGeni(GLenum coord, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.TexGeni(coord, pname, param);
-}
-
-inline void QOpenGLFunctions_2_0::glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.TexGenfv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glTexGenf(GLenum coord, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.TexGenf(coord, pname, param);
-}
-
-inline void QOpenGLFunctions_2_0::glTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
-{
-    d_1_0_Deprecated->f.TexGendv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glTexGend(GLenum coord, GLenum pname, GLdouble param)
-{
-    d_1_0_Deprecated->f.TexGend(coord, pname, param);
-}
-
-inline void QOpenGLFunctions_2_0::glTexEnviv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.TexEnviv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glTexEnvi(GLenum target, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.TexEnvi(target, pname, param);
-}
-
-inline void QOpenGLFunctions_2_0::glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.TexEnvfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glTexEnvf(GLenum target, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.TexEnvf(target, pname, param);
-}
-
-inline void QOpenGLFunctions_2_0::glShadeModel(GLenum mode)
-{
-    d_1_0_Deprecated->f.ShadeModel(mode);
-}
-
-inline void QOpenGLFunctions_2_0::glPolygonStipple(const GLubyte *mask)
-{
-    d_1_0_Deprecated->f.PolygonStipple(mask);
-}
-
-inline void QOpenGLFunctions_2_0::glMaterialiv(GLenum face, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.Materialiv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glMateriali(GLenum face, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.Materiali(face, pname, param);
-}
-
-inline void QOpenGLFunctions_2_0::glMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.Materialfv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glMaterialf(GLenum face, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.Materialf(face, pname, param);
-}
-
-inline void QOpenGLFunctions_2_0::glLineStipple(GLint factor, GLushort pattern)
-{
-    d_1_0_Deprecated->f.LineStipple(factor, pattern);
-}
-
-inline void QOpenGLFunctions_2_0::glLightModeliv(GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.LightModeliv(pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glLightModeli(GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.LightModeli(pname, param);
-}
-
-inline void QOpenGLFunctions_2_0::glLightModelfv(GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.LightModelfv(pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glLightModelf(GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.LightModelf(pname, param);
-}
-
-inline void QOpenGLFunctions_2_0::glLightiv(GLenum light, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.Lightiv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glLighti(GLenum light, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.Lighti(light, pname, param);
-}
-
-inline void QOpenGLFunctions_2_0::glLightfv(GLenum light, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.Lightfv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glLightf(GLenum light, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.Lightf(light, pname, param);
-}
-
-inline void QOpenGLFunctions_2_0::glFogiv(GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.Fogiv(pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glFogi(GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.Fogi(pname, param);
-}
-
-inline void QOpenGLFunctions_2_0::glFogfv(GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.Fogfv(pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glFogf(GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.Fogf(pname, param);
-}
-
-inline void QOpenGLFunctions_2_0::glColorMaterial(GLenum face, GLenum mode)
-{
-    d_1_0_Deprecated->f.ColorMaterial(face, mode);
-}
-
-inline void QOpenGLFunctions_2_0::glClipPlane(GLenum plane, const GLdouble *equation)
-{
-    d_1_0_Deprecated->f.ClipPlane(plane, equation);
-}
-
-inline void QOpenGLFunctions_2_0::glVertex4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Vertex4sv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
-{
-    d_1_0_Deprecated->f.Vertex4s(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_2_0::glVertex4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Vertex4iv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glVertex4i(GLint x, GLint y, GLint z, GLint w)
-{
-    d_1_0_Deprecated->f.Vertex4i(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_2_0::glVertex4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Vertex4fv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    d_1_0_Deprecated->f.Vertex4f(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_2_0::glVertex4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Vertex4dv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_1_0_Deprecated->f.Vertex4d(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_2_0::glVertex3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Vertex3sv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glVertex3s(GLshort x, GLshort y, GLshort z)
-{
-    d_1_0_Deprecated->f.Vertex3s(x, y, z);
-}
-
-inline void QOpenGLFunctions_2_0::glVertex3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Vertex3iv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glVertex3i(GLint x, GLint y, GLint z)
-{
-    d_1_0_Deprecated->f.Vertex3i(x, y, z);
-}
-
-inline void QOpenGLFunctions_2_0::glVertex3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Vertex3fv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glVertex3f(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Vertex3f(x, y, z);
-}
-
-inline void QOpenGLFunctions_2_0::glVertex3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Vertex3dv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glVertex3d(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Vertex3d(x, y, z);
-}
-
-inline void QOpenGLFunctions_2_0::glVertex2sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Vertex2sv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glVertex2s(GLshort x, GLshort y)
-{
-    d_1_0_Deprecated->f.Vertex2s(x, y);
-}
-
-inline void QOpenGLFunctions_2_0::glVertex2iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Vertex2iv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glVertex2i(GLint x, GLint y)
-{
-    d_1_0_Deprecated->f.Vertex2i(x, y);
-}
-
-inline void QOpenGLFunctions_2_0::glVertex2fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Vertex2fv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glVertex2f(GLfloat x, GLfloat y)
-{
-    d_1_0_Deprecated->f.Vertex2f(x, y);
-}
-
-inline void QOpenGLFunctions_2_0::glVertex2dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Vertex2dv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glVertex2d(GLdouble x, GLdouble y)
-{
-    d_1_0_Deprecated->f.Vertex2d(x, y);
-}
-
-inline void QOpenGLFunctions_2_0::glTexCoord4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord4sv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
-{
-    d_1_0_Deprecated->f.TexCoord4s(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_2_0::glTexCoord4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord4iv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
-{
-    d_1_0_Deprecated->f.TexCoord4i(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_2_0::glTexCoord4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord4fv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
-{
-    d_1_0_Deprecated->f.TexCoord4f(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_2_0::glTexCoord4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord4dv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
-{
-    d_1_0_Deprecated->f.TexCoord4d(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_2_0::glTexCoord3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord3sv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glTexCoord3s(GLshort s, GLshort t, GLshort r)
-{
-    d_1_0_Deprecated->f.TexCoord3s(s, t, r);
-}
-
-inline void QOpenGLFunctions_2_0::glTexCoord3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord3iv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glTexCoord3i(GLint s, GLint t, GLint r)
-{
-    d_1_0_Deprecated->f.TexCoord3i(s, t, r);
-}
-
-inline void QOpenGLFunctions_2_0::glTexCoord3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord3fv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
-{
-    d_1_0_Deprecated->f.TexCoord3f(s, t, r);
-}
-
-inline void QOpenGLFunctions_2_0::glTexCoord3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord3dv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
-{
-    d_1_0_Deprecated->f.TexCoord3d(s, t, r);
-}
-
-inline void QOpenGLFunctions_2_0::glTexCoord2sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord2sv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glTexCoord2s(GLshort s, GLshort t)
-{
-    d_1_0_Deprecated->f.TexCoord2s(s, t);
-}
-
-inline void QOpenGLFunctions_2_0::glTexCoord2iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord2iv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glTexCoord2i(GLint s, GLint t)
-{
-    d_1_0_Deprecated->f.TexCoord2i(s, t);
-}
-
-inline void QOpenGLFunctions_2_0::glTexCoord2fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord2fv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glTexCoord2f(GLfloat s, GLfloat t)
-{
-    d_1_0_Deprecated->f.TexCoord2f(s, t);
-}
-
-inline void QOpenGLFunctions_2_0::glTexCoord2dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord2dv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glTexCoord2d(GLdouble s, GLdouble t)
-{
-    d_1_0_Deprecated->f.TexCoord2d(s, t);
-}
-
-inline void QOpenGLFunctions_2_0::glTexCoord1sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord1sv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glTexCoord1s(GLshort s)
-{
-    d_1_0_Deprecated->f.TexCoord1s(s);
-}
-
-inline void QOpenGLFunctions_2_0::glTexCoord1iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord1iv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glTexCoord1i(GLint s)
-{
-    d_1_0_Deprecated->f.TexCoord1i(s);
-}
-
-inline void QOpenGLFunctions_2_0::glTexCoord1fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord1fv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glTexCoord1f(GLfloat s)
-{
-    d_1_0_Deprecated->f.TexCoord1f(s);
-}
-
-inline void QOpenGLFunctions_2_0::glTexCoord1dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord1dv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glTexCoord1d(GLdouble s)
-{
-    d_1_0_Deprecated->f.TexCoord1d(s);
-}
-
-inline void QOpenGLFunctions_2_0::glRectsv(const GLshort *v1, const GLshort *v2)
-{
-    d_1_0_Deprecated->f.Rectsv(v1, v2);
-}
-
-inline void QOpenGLFunctions_2_0::glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
-{
-    d_1_0_Deprecated->f.Rects(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_2_0::glRectiv(const GLint *v1, const GLint *v2)
-{
-    d_1_0_Deprecated->f.Rectiv(v1, v2);
-}
-
-inline void QOpenGLFunctions_2_0::glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
-{
-    d_1_0_Deprecated->f.Recti(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_2_0::glRectfv(const GLfloat *v1, const GLfloat *v2)
-{
-    d_1_0_Deprecated->f.Rectfv(v1, v2);
-}
-
-inline void QOpenGLFunctions_2_0::glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
-{
-    d_1_0_Deprecated->f.Rectf(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_2_0::glRectdv(const GLdouble *v1, const GLdouble *v2)
-{
-    d_1_0_Deprecated->f.Rectdv(v1, v2);
-}
-
-inline void QOpenGLFunctions_2_0::glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
-{
-    d_1_0_Deprecated->f.Rectd(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_2_0::glRasterPos4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.RasterPos4sv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
-{
-    d_1_0_Deprecated->f.RasterPos4s(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_2_0::glRasterPos4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.RasterPos4iv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
-{
-    d_1_0_Deprecated->f.RasterPos4i(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_2_0::glRasterPos4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.RasterPos4fv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    d_1_0_Deprecated->f.RasterPos4f(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_2_0::glRasterPos4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.RasterPos4dv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_1_0_Deprecated->f.RasterPos4d(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_2_0::glRasterPos3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.RasterPos3sv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glRasterPos3s(GLshort x, GLshort y, GLshort z)
-{
-    d_1_0_Deprecated->f.RasterPos3s(x, y, z);
-}
-
-inline void QOpenGLFunctions_2_0::glRasterPos3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.RasterPos3iv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glRasterPos3i(GLint x, GLint y, GLint z)
-{
-    d_1_0_Deprecated->f.RasterPos3i(x, y, z);
-}
-
-inline void QOpenGLFunctions_2_0::glRasterPos3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.RasterPos3fv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.RasterPos3f(x, y, z);
-}
-
-inline void QOpenGLFunctions_2_0::glRasterPos3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.RasterPos3dv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.RasterPos3d(x, y, z);
-}
-
-inline void QOpenGLFunctions_2_0::glRasterPos2sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.RasterPos2sv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glRasterPos2s(GLshort x, GLshort y)
-{
-    d_1_0_Deprecated->f.RasterPos2s(x, y);
-}
-
-inline void QOpenGLFunctions_2_0::glRasterPos2iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.RasterPos2iv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glRasterPos2i(GLint x, GLint y)
-{
-    d_1_0_Deprecated->f.RasterPos2i(x, y);
-}
-
-inline void QOpenGLFunctions_2_0::glRasterPos2fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.RasterPos2fv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glRasterPos2f(GLfloat x, GLfloat y)
-{
-    d_1_0_Deprecated->f.RasterPos2f(x, y);
-}
-
-inline void QOpenGLFunctions_2_0::glRasterPos2dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.RasterPos2dv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glRasterPos2d(GLdouble x, GLdouble y)
-{
-    d_1_0_Deprecated->f.RasterPos2d(x, y);
-}
-
-inline void QOpenGLFunctions_2_0::glNormal3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Normal3sv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glNormal3s(GLshort nx, GLshort ny, GLshort nz)
-{
-    d_1_0_Deprecated->f.Normal3s(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_2_0::glNormal3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Normal3iv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glNormal3i(GLint nx, GLint ny, GLint nz)
-{
-    d_1_0_Deprecated->f.Normal3i(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_2_0::glNormal3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Normal3fv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
-{
-    d_1_0_Deprecated->f.Normal3f(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_2_0::glNormal3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Normal3dv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
-{
-    d_1_0_Deprecated->f.Normal3d(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_2_0::glNormal3bv(const GLbyte *v)
-{
-    d_1_0_Deprecated->f.Normal3bv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
-{
-    d_1_0_Deprecated->f.Normal3b(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_2_0::glIndexsv(const GLshort *c)
-{
-    d_1_0_Deprecated->f.Indexsv(c);
-}
-
-inline void QOpenGLFunctions_2_0::glIndexs(GLshort c)
-{
-    d_1_0_Deprecated->f.Indexs(c);
-}
-
-inline void QOpenGLFunctions_2_0::glIndexiv(const GLint *c)
-{
-    d_1_0_Deprecated->f.Indexiv(c);
-}
-
-inline void QOpenGLFunctions_2_0::glIndexi(GLint c)
-{
-    d_1_0_Deprecated->f.Indexi(c);
-}
-
-inline void QOpenGLFunctions_2_0::glIndexfv(const GLfloat *c)
-{
-    d_1_0_Deprecated->f.Indexfv(c);
-}
-
-inline void QOpenGLFunctions_2_0::glIndexf(GLfloat c)
-{
-    d_1_0_Deprecated->f.Indexf(c);
-}
-
-inline void QOpenGLFunctions_2_0::glIndexdv(const GLdouble *c)
-{
-    d_1_0_Deprecated->f.Indexdv(c);
-}
-
-inline void QOpenGLFunctions_2_0::glIndexd(GLdouble c)
-{
-    d_1_0_Deprecated->f.Indexd(c);
-}
-
-inline void QOpenGLFunctions_2_0::glEnd()
-{
-    d_1_0_Deprecated->f.End();
-}
-
-inline void QOpenGLFunctions_2_0::glEdgeFlagv(const GLboolean *flag)
-{
-    d_1_0_Deprecated->f.EdgeFlagv(flag);
-}
-
-inline void QOpenGLFunctions_2_0::glEdgeFlag(GLboolean flag)
-{
-    d_1_0_Deprecated->f.EdgeFlag(flag);
-}
-
-inline void QOpenGLFunctions_2_0::glColor4usv(const GLushort *v)
-{
-    d_1_0_Deprecated->f.Color4usv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
-{
-    d_1_0_Deprecated->f.Color4us(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_2_0::glColor4uiv(const GLuint *v)
-{
-    d_1_0_Deprecated->f.Color4uiv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
-{
-    d_1_0_Deprecated->f.Color4ui(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_2_0::glColor4ubv(const GLubyte *v)
-{
-    d_1_0_Deprecated->f.Color4ubv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
-{
-    d_1_0_Deprecated->f.Color4ub(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_2_0::glColor4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Color4sv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
-{
-    d_1_0_Deprecated->f.Color4s(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_2_0::glColor4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Color4iv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
-{
-    d_1_0_Deprecated->f.Color4i(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_2_0::glColor4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Color4fv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Deprecated->f.Color4f(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_2_0::glColor4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Color4dv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
-{
-    d_1_0_Deprecated->f.Color4d(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_2_0::glColor4bv(const GLbyte *v)
-{
-    d_1_0_Deprecated->f.Color4bv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
-{
-    d_1_0_Deprecated->f.Color4b(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_2_0::glColor3usv(const GLushort *v)
-{
-    d_1_0_Deprecated->f.Color3usv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glColor3us(GLushort red, GLushort green, GLushort blue)
-{
-    d_1_0_Deprecated->f.Color3us(red, green, blue);
-}
-
-inline void QOpenGLFunctions_2_0::glColor3uiv(const GLuint *v)
-{
-    d_1_0_Deprecated->f.Color3uiv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glColor3ui(GLuint red, GLuint green, GLuint blue)
-{
-    d_1_0_Deprecated->f.Color3ui(red, green, blue);
-}
-
-inline void QOpenGLFunctions_2_0::glColor3ubv(const GLubyte *v)
-{
-    d_1_0_Deprecated->f.Color3ubv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
-{
-    d_1_0_Deprecated->f.Color3ub(red, green, blue);
-}
-
-inline void QOpenGLFunctions_2_0::glColor3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Color3sv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glColor3s(GLshort red, GLshort green, GLshort blue)
-{
-    d_1_0_Deprecated->f.Color3s(red, green, blue);
-}
-
-inline void QOpenGLFunctions_2_0::glColor3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Color3iv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glColor3i(GLint red, GLint green, GLint blue)
-{
-    d_1_0_Deprecated->f.Color3i(red, green, blue);
-}
-
-inline void QOpenGLFunctions_2_0::glColor3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Color3fv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glColor3f(GLfloat red, GLfloat green, GLfloat blue)
-{
-    d_1_0_Deprecated->f.Color3f(red, green, blue);
-}
-
-inline void QOpenGLFunctions_2_0::glColor3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Color3dv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glColor3d(GLdouble red, GLdouble green, GLdouble blue)
-{
-    d_1_0_Deprecated->f.Color3d(red, green, blue);
-}
-
-inline void QOpenGLFunctions_2_0::glColor3bv(const GLbyte *v)
-{
-    d_1_0_Deprecated->f.Color3bv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glColor3b(GLbyte red, GLbyte green, GLbyte blue)
-{
-    d_1_0_Deprecated->f.Color3b(red, green, blue);
-}
-
-inline void QOpenGLFunctions_2_0::glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
-{
-    d_1_0_Deprecated->f.Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
-}
-
-inline void QOpenGLFunctions_2_0::glBegin(GLenum mode)
-{
-    d_1_0_Deprecated->f.Begin(mode);
-}
-
-inline void QOpenGLFunctions_2_0::glListBase(GLuint base)
-{
-    d_1_0_Deprecated->f.ListBase(base);
-}
-
-inline GLuint QOpenGLFunctions_2_0::glGenLists(GLsizei range)
-{
-    return d_1_0_Deprecated->f.GenLists(range);
-}
-
-inline void QOpenGLFunctions_2_0::glDeleteLists(GLuint list, GLsizei range)
-{
-    d_1_0_Deprecated->f.DeleteLists(list, range);
-}
-
-inline void QOpenGLFunctions_2_0::glCallLists(GLsizei n, GLenum type, const GLvoid *lists)
-{
-    d_1_0_Deprecated->f.CallLists(n, type, lists);
-}
-
-inline void QOpenGLFunctions_2_0::glCallList(GLuint list)
-{
-    d_1_0_Deprecated->f.CallList(list);
-}
-
-inline void QOpenGLFunctions_2_0::glEndList()
-{
-    d_1_0_Deprecated->f.EndList();
-}
-
-inline void QOpenGLFunctions_2_0::glNewList(GLuint list, GLenum mode)
-{
-    d_1_0_Deprecated->f.NewList(list, mode);
-}
-
-
-// OpenGL 1.1 deprecated functions
-inline void QOpenGLFunctions_2_0::glPushClientAttrib(GLbitfield mask)
-{
-    d_1_1_Deprecated->f.PushClientAttrib(mask);
-}
-
-inline void QOpenGLFunctions_2_0::glPopClientAttrib()
-{
-    d_1_1_Deprecated->f.PopClientAttrib();
-}
-
-inline void QOpenGLFunctions_2_0::glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities)
-{
-    d_1_1_Deprecated->f.PrioritizeTextures(n, textures, priorities);
-}
-
-inline GLboolean QOpenGLFunctions_2_0::glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
-{
-    return d_1_1_Deprecated->f.AreTexturesResident(n, textures, residences);
-}
-
-inline void QOpenGLFunctions_2_0::glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.VertexPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_2_0::glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.TexCoordPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_2_0::glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.NormalPointer(type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_2_0::glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.InterleavedArrays(format, stride, pointer);
-}
-
-inline void QOpenGLFunctions_2_0::glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.IndexPointer(type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_2_0::glEnableClientState(GLenum array)
-{
-    d_1_1_Deprecated->f.EnableClientState(array);
-}
-
-inline void QOpenGLFunctions_2_0::glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.EdgeFlagPointer(stride, pointer);
-}
-
-inline void QOpenGLFunctions_2_0::glDisableClientState(GLenum array)
-{
-    d_1_1_Deprecated->f.DisableClientState(array);
-}
-
-inline void QOpenGLFunctions_2_0::glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.ColorPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_2_0::glArrayElement(GLint i)
-{
-    d_1_1_Deprecated->f.ArrayElement(i);
-}
-
-
-// OpenGL 1.2 deprecated functions
-inline void QOpenGLFunctions_2_0::glResetMinmax(GLenum target)
-{
-    d_1_2_Deprecated->f.ResetMinmax(target);
-}
-
-inline void QOpenGLFunctions_2_0::glResetHistogram(GLenum target)
-{
-    d_1_2_Deprecated->f.ResetHistogram(target);
-}
-
-inline void QOpenGLFunctions_2_0::glMinmax(GLenum target, GLenum internalformat, GLboolean sink)
-{
-    d_1_2_Deprecated->f.Minmax(target, internalformat, sink);
-}
-
-inline void QOpenGLFunctions_2_0::glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
-{
-    d_1_2_Deprecated->f.Histogram(target, width, internalformat, sink);
-}
-
-inline void QOpenGLFunctions_2_0::glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetMinmaxParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetMinmaxParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
-{
-    d_1_2_Deprecated->f.GetMinmax(target, reset, format, type, values);
-}
-
-inline void QOpenGLFunctions_2_0::glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetHistogramParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetHistogramParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
-{
-    d_1_2_Deprecated->f.GetHistogram(target, reset, format, type, values);
-}
-
-inline void QOpenGLFunctions_2_0::glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column)
-{
-    d_1_2_Deprecated->f.SeparableFilter2D(target, internalformat, width, height, format, type, row, column);
-}
-
-inline void QOpenGLFunctions_2_0::glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span)
-{
-    d_1_2_Deprecated->f.GetSeparableFilter(target, format, type, row, column, span);
-}
-
-inline void QOpenGLFunctions_2_0::glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetConvolutionParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetConvolutionParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image)
-{
-    d_1_2_Deprecated->f.GetConvolutionFilter(target, format, type, image);
-}
-
-inline void QOpenGLFunctions_2_0::glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_2_Deprecated->f.CopyConvolutionFilter2D(target, internalformat, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_2_0::glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
-{
-    d_1_2_Deprecated->f.CopyConvolutionFilter1D(target, internalformat, x, y, width);
-}
-
-inline void QOpenGLFunctions_2_0::glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glConvolutionParameteri(GLenum target, GLenum pname, GLint params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameteri(target, pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameterf(target, pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image)
-{
-    d_1_2_Deprecated->f.ConvolutionFilter2D(target, internalformat, width, height, format, type, image);
-}
-
-inline void QOpenGLFunctions_2_0::glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image)
-{
-    d_1_2_Deprecated->f.ConvolutionFilter1D(target, internalformat, width, format, type, image);
-}
-
-inline void QOpenGLFunctions_2_0::glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
-{
-    d_1_2_Deprecated->f.CopyColorSubTable(target, start, x, y, width);
-}
-
-inline void QOpenGLFunctions_2_0::glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data)
-{
-    d_1_2_Deprecated->f.ColorSubTable(target, start, count, format, type, data);
-}
-
-inline void QOpenGLFunctions_2_0::glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetColorTableParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetColorTableParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table)
-{
-    d_1_2_Deprecated->f.GetColorTable(target, format, type, table);
-}
-
-inline void QOpenGLFunctions_2_0::glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
-{
-    d_1_2_Deprecated->f.CopyColorTable(target, internalformat, x, y, width);
-}
-
-inline void QOpenGLFunctions_2_0::glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_2_Deprecated->f.ColorTableParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_2_Deprecated->f.ColorTableParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_2_0::glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table)
-{
-    d_1_2_Deprecated->f.ColorTable(target, internalformat, width, format, type, table);
-}
-
-
-// OpenGL 1.3 deprecated functions
-inline void QOpenGLFunctions_2_0::glMultTransposeMatrixd(const GLdouble *m)
-{
-    d_1_3_Deprecated->f.MultTransposeMatrixd(m);
-}
-
-inline void QOpenGLFunctions_2_0::glMultTransposeMatrixf(const GLfloat *m)
-{
-    d_1_3_Deprecated->f.MultTransposeMatrixf(m);
-}
-
-inline void QOpenGLFunctions_2_0::glLoadTransposeMatrixd(const GLdouble *m)
-{
-    d_1_3_Deprecated->f.LoadTransposeMatrixd(m);
-}
-
-inline void QOpenGLFunctions_2_0::glLoadTransposeMatrixf(const GLfloat *m)
-{
-    d_1_3_Deprecated->f.LoadTransposeMatrixf(m);
-}
-
-inline void QOpenGLFunctions_2_0::glMultiTexCoord4sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4sv(target, v);
-}
-
-inline void QOpenGLFunctions_2_0::glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4s(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_2_0::glMultiTexCoord4iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4iv(target, v);
-}
-
-inline void QOpenGLFunctions_2_0::glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4i(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_2_0::glMultiTexCoord4fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4fv(target, v);
-}
-
-inline void QOpenGLFunctions_2_0::glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4f(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_2_0::glMultiTexCoord4dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4dv(target, v);
-}
-
-inline void QOpenGLFunctions_2_0::glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4d(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_2_0::glMultiTexCoord3sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3sv(target, v);
-}
-
-inline void QOpenGLFunctions_2_0::glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3s(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_2_0::glMultiTexCoord3iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3iv(target, v);
-}
-
-inline void QOpenGLFunctions_2_0::glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3i(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_2_0::glMultiTexCoord3fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3fv(target, v);
-}
-
-inline void QOpenGLFunctions_2_0::glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3f(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_2_0::glMultiTexCoord3dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3dv(target, v);
-}
-
-inline void QOpenGLFunctions_2_0::glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3d(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_2_0::glMultiTexCoord2sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2sv(target, v);
-}
-
-inline void QOpenGLFunctions_2_0::glMultiTexCoord2s(GLenum target, GLshort s, GLshort t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2s(target, s, t);
-}
-
-inline void QOpenGLFunctions_2_0::glMultiTexCoord2iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2iv(target, v);
-}
-
-inline void QOpenGLFunctions_2_0::glMultiTexCoord2i(GLenum target, GLint s, GLint t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2i(target, s, t);
-}
-
-inline void QOpenGLFunctions_2_0::glMultiTexCoord2fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2fv(target, v);
-}
-
-inline void QOpenGLFunctions_2_0::glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2f(target, s, t);
-}
-
-inline void QOpenGLFunctions_2_0::glMultiTexCoord2dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2dv(target, v);
-}
-
-inline void QOpenGLFunctions_2_0::glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2d(target, s, t);
-}
-
-inline void QOpenGLFunctions_2_0::glMultiTexCoord1sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1sv(target, v);
-}
-
-inline void QOpenGLFunctions_2_0::glMultiTexCoord1s(GLenum target, GLshort s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1s(target, s);
-}
-
-inline void QOpenGLFunctions_2_0::glMultiTexCoord1iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1iv(target, v);
-}
-
-inline void QOpenGLFunctions_2_0::glMultiTexCoord1i(GLenum target, GLint s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1i(target, s);
-}
-
-inline void QOpenGLFunctions_2_0::glMultiTexCoord1fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1fv(target, v);
-}
-
-inline void QOpenGLFunctions_2_0::glMultiTexCoord1f(GLenum target, GLfloat s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1f(target, s);
-}
-
-inline void QOpenGLFunctions_2_0::glMultiTexCoord1dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1dv(target, v);
-}
-
-inline void QOpenGLFunctions_2_0::glMultiTexCoord1d(GLenum target, GLdouble s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1d(target, s);
-}
-
-inline void QOpenGLFunctions_2_0::glClientActiveTexture(GLenum texture)
-{
-    d_1_3_Deprecated->f.ClientActiveTexture(texture);
-}
-
-
-// OpenGL 1.4 deprecated functions
-inline void QOpenGLFunctions_2_0::glWindowPos3sv(const GLshort *v)
-{
-    d_1_4_Deprecated->f.WindowPos3sv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glWindowPos3s(GLshort x, GLshort y, GLshort z)
-{
-    d_1_4_Deprecated->f.WindowPos3s(x, y, z);
-}
-
-inline void QOpenGLFunctions_2_0::glWindowPos3iv(const GLint *v)
-{
-    d_1_4_Deprecated->f.WindowPos3iv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glWindowPos3i(GLint x, GLint y, GLint z)
-{
-    d_1_4_Deprecated->f.WindowPos3i(x, y, z);
-}
-
-inline void QOpenGLFunctions_2_0::glWindowPos3fv(const GLfloat *v)
-{
-    d_1_4_Deprecated->f.WindowPos3fv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glWindowPos3f(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_4_Deprecated->f.WindowPos3f(x, y, z);
-}
-
-inline void QOpenGLFunctions_2_0::glWindowPos3dv(const GLdouble *v)
-{
-    d_1_4_Deprecated->f.WindowPos3dv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glWindowPos3d(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_4_Deprecated->f.WindowPos3d(x, y, z);
-}
-
-inline void QOpenGLFunctions_2_0::glWindowPos2sv(const GLshort *v)
-{
-    d_1_4_Deprecated->f.WindowPos2sv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glWindowPos2s(GLshort x, GLshort y)
-{
-    d_1_4_Deprecated->f.WindowPos2s(x, y);
-}
-
-inline void QOpenGLFunctions_2_0::glWindowPos2iv(const GLint *v)
-{
-    d_1_4_Deprecated->f.WindowPos2iv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glWindowPos2i(GLint x, GLint y)
-{
-    d_1_4_Deprecated->f.WindowPos2i(x, y);
-}
-
-inline void QOpenGLFunctions_2_0::glWindowPos2fv(const GLfloat *v)
-{
-    d_1_4_Deprecated->f.WindowPos2fv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glWindowPos2f(GLfloat x, GLfloat y)
-{
-    d_1_4_Deprecated->f.WindowPos2f(x, y);
-}
-
-inline void QOpenGLFunctions_2_0::glWindowPos2dv(const GLdouble *v)
-{
-    d_1_4_Deprecated->f.WindowPos2dv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glWindowPos2d(GLdouble x, GLdouble y)
-{
-    d_1_4_Deprecated->f.WindowPos2d(x, y);
-}
-
-inline void QOpenGLFunctions_2_0::glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_4_Deprecated->f.SecondaryColorPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_2_0::glSecondaryColor3usv(const GLushort *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3usv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glSecondaryColor3us(GLushort red, GLushort green, GLushort blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3us(red, green, blue);
-}
-
-inline void QOpenGLFunctions_2_0::glSecondaryColor3uiv(const GLuint *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3uiv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3ui(red, green, blue);
-}
-
-inline void QOpenGLFunctions_2_0::glSecondaryColor3ubv(const GLubyte *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3ubv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3ub(red, green, blue);
-}
-
-inline void QOpenGLFunctions_2_0::glSecondaryColor3sv(const GLshort *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3sv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glSecondaryColor3s(GLshort red, GLshort green, GLshort blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3s(red, green, blue);
-}
-
-inline void QOpenGLFunctions_2_0::glSecondaryColor3iv(const GLint *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3iv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glSecondaryColor3i(GLint red, GLint green, GLint blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3i(red, green, blue);
-}
-
-inline void QOpenGLFunctions_2_0::glSecondaryColor3fv(const GLfloat *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3fv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3f(red, green, blue);
-}
-
-inline void QOpenGLFunctions_2_0::glSecondaryColor3dv(const GLdouble *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3dv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3d(red, green, blue);
-}
-
-inline void QOpenGLFunctions_2_0::glSecondaryColor3bv(const GLbyte *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3bv(v);
-}
-
-inline void QOpenGLFunctions_2_0::glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3b(red, green, blue);
-}
-
-inline void QOpenGLFunctions_2_0::glFogCoordPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_4_Deprecated->f.FogCoordPointer(type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_2_0::glFogCoorddv(const GLdouble *coord)
-{
-    d_1_4_Deprecated->f.FogCoorddv(coord);
-}
-
-inline void QOpenGLFunctions_2_0::glFogCoordd(GLdouble coord)
-{
-    d_1_4_Deprecated->f.FogCoordd(coord);
-}
-
-inline void QOpenGLFunctions_2_0::glFogCoordfv(const GLfloat *coord)
-{
-    d_1_4_Deprecated->f.FogCoordfv(coord);
-}
-
-inline void QOpenGLFunctions_2_0::glFogCoordf(GLfloat coord)
-{
-    d_1_4_Deprecated->f.FogCoordf(coord);
-}
-
-
-// OpenGL 1.5 deprecated functions
-
-// OpenGL 2.0 deprecated functions
-inline void QOpenGLFunctions_2_0::glVertexAttrib4usv(GLuint index, const GLushort *v)
-{
-    d_2_0_Core->f.VertexAttrib4usv(index, v);
-}
-
-inline void QOpenGLFunctions_2_0::glVertexAttrib4uiv(GLuint index, const GLuint *v)
-{
-    d_2_0_Core->f.VertexAttrib4uiv(index, v);
-}
-
-inline void QOpenGLFunctions_2_0::glVertexAttrib4ubv(GLuint index, const GLubyte *v)
-{
-    d_2_0_Core->f.VertexAttrib4ubv(index, v);
-}
-
-inline void QOpenGLFunctions_2_0::glVertexAttrib4sv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib4sv(index, v);
-}
-
-inline void QOpenGLFunctions_2_0::glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
-{
-    d_2_0_Core->f.VertexAttrib4s(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_2_0::glVertexAttrib4iv(GLuint index, const GLint *v)
-{
-    d_2_0_Core->f.VertexAttrib4iv(index, v);
-}
-
-inline void QOpenGLFunctions_2_0::glVertexAttrib4fv(GLuint index, const GLfloat *v)
-{
-    d_2_0_Core->f.VertexAttrib4fv(index, v);
-}
-
-inline void QOpenGLFunctions_2_0::glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    d_2_0_Core->f.VertexAttrib4f(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_2_0::glVertexAttrib4dv(GLuint index, const GLdouble *v)
-{
-    d_2_0_Core->f.VertexAttrib4dv(index, v);
-}
-
-inline void QOpenGLFunctions_2_0::glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_2_0_Core->f.VertexAttrib4d(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_2_0::glVertexAttrib4bv(GLuint index, const GLbyte *v)
-{
-    d_2_0_Core->f.VertexAttrib4bv(index, v);
-}
-
-inline void QOpenGLFunctions_2_0::glVertexAttrib4Nusv(GLuint index, const GLushort *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nusv(index, v);
-}
-
-inline void QOpenGLFunctions_2_0::glVertexAttrib4Nuiv(GLuint index, const GLuint *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nuiv(index, v);
-}
-
-inline void QOpenGLFunctions_2_0::glVertexAttrib4Nubv(GLuint index, const GLubyte *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nubv(index, v);
-}
-
-inline void QOpenGLFunctions_2_0::glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
-{
-    d_2_0_Core->f.VertexAttrib4Nub(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_2_0::glVertexAttrib4Nsv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nsv(index, v);
-}
-
-inline void QOpenGLFunctions_2_0::glVertexAttrib4Niv(GLuint index, const GLint *v)
-{
-    d_2_0_Core->f.VertexAttrib4Niv(index, v);
-}
-
-inline void QOpenGLFunctions_2_0::glVertexAttrib4Nbv(GLuint index, const GLbyte *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nbv(index, v);
-}
-
-inline void QOpenGLFunctions_2_0::glVertexAttrib3sv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib3sv(index, v);
-}
-
-inline void QOpenGLFunctions_2_0::glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
-{
-    d_2_0_Core->f.VertexAttrib3s(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_2_0::glVertexAttrib3fv(GLuint index, const GLfloat *v)
-{
-    d_2_0_Core->f.VertexAttrib3fv(index, v);
-}
-
-inline void QOpenGLFunctions_2_0::glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
-{
-    d_2_0_Core->f.VertexAttrib3f(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_2_0::glVertexAttrib3dv(GLuint index, const GLdouble *v)
-{
-    d_2_0_Core->f.VertexAttrib3dv(index, v);
-}
-
-inline void QOpenGLFunctions_2_0::glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
-{
-    d_2_0_Core->f.VertexAttrib3d(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_2_0::glVertexAttrib2sv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib2sv(index, v);
-}
-
-inline void QOpenGLFunctions_2_0::glVertexAttrib2s(GLuint index, GLshort x, GLshort y)
-{
-    d_2_0_Core->f.VertexAttrib2s(index, x, y);
-}
-
-inline void QOpenGLFunctions_2_0::glVertexAttrib2fv(GLuint index, const GLfloat *v)
-{
-    d_2_0_Core->f.VertexAttrib2fv(index, v);
-}
-
-inline void QOpenGLFunctions_2_0::glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
-{
-    d_2_0_Core->f.VertexAttrib2f(index, x, y);
-}
-
-inline void QOpenGLFunctions_2_0::glVertexAttrib2dv(GLuint index, const GLdouble *v)
-{
-    d_2_0_Core->f.VertexAttrib2dv(index, v);
-}
-
-inline void QOpenGLFunctions_2_0::glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
-{
-    d_2_0_Core->f.VertexAttrib2d(index, x, y);
-}
-
-inline void QOpenGLFunctions_2_0::glVertexAttrib1sv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib1sv(index, v);
-}
-
-inline void QOpenGLFunctions_2_0::glVertexAttrib1s(GLuint index, GLshort x)
-{
-    d_2_0_Core->f.VertexAttrib1s(index, x);
-}
-
-inline void QOpenGLFunctions_2_0::glVertexAttrib1fv(GLuint index, const GLfloat *v)
-{
-    d_2_0_Core->f.VertexAttrib1fv(index, v);
-}
-
-inline void QOpenGLFunctions_2_0::glVertexAttrib1f(GLuint index, GLfloat x)
-{
-    d_2_0_Core->f.VertexAttrib1f(index, x);
-}
-
-inline void QOpenGLFunctions_2_0::glVertexAttrib1dv(GLuint index, const GLdouble *v)
-{
-    d_2_0_Core->f.VertexAttrib1dv(index, v);
-}
-
-inline void QOpenGLFunctions_2_0::glVertexAttrib1d(GLuint index, GLdouble x)
-{
-    d_2_0_Core->f.VertexAttrib1d(index, x);
-}
-
-
-
-QT_END_NAMESPACE
-
-#endif // QT_NO_OPENGL && !QT_OPENGL_ES_2
-
-#endif
diff --git a/src/gui/opengl/qopenglfunctions_2_1.cpp b/src/gui/opengl/qopenglfunctions_2_1.cpp
deleted file mode 100644
index 8a7170dd7d..0000000000
--- a/src/gui/opengl/qopenglfunctions_2_1.cpp
+++ /dev/null
@@ -1,236 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#include "qopenglfunctions_2_1.h"
-#include "qopenglcontext.h"
-
-QT_BEGIN_NAMESPACE
-
-/*!
-    \class QOpenGLFunctions_2_1
-    \inmodule QtGui
-    \since 5.1
-    \wrapper
-    \brief The QOpenGLFunctions_2_1 class provides all functions for OpenGL 2.1 specification.
-
-    This class is a wrapper for functions from OpenGL 2.1 specification.
-    See reference pages on \l {http://www.opengl.org/sdk/docs/}{opengl.org}
-    for function documentation.
-
-    \sa QAbstractOpenGLFunctions
-*/
-
-QOpenGLFunctions_2_1::QOpenGLFunctions_2_1()
- : QAbstractOpenGLFunctions()
- , d_1_0_Core(nullptr)
- , d_1_1_Core(nullptr)
- , d_1_2_Core(nullptr)
- , d_1_3_Core(nullptr)
- , d_1_4_Core(nullptr)
- , d_1_5_Core(nullptr)
- , d_2_0_Core(nullptr)
- , d_2_1_Core(nullptr)
- , d_1_0_Deprecated(nullptr)
- , d_1_1_Deprecated(nullptr)
- , d_1_2_Deprecated(nullptr)
- , d_1_3_Deprecated(nullptr)
- , d_1_4_Deprecated(nullptr)
- , m_reserved_2_0_Deprecated(nullptr)
-{
-}
-
-QOpenGLFunctions_2_1::~QOpenGLFunctions_2_1()
-{
-    if (d_1_0_Core) {
-        d_1_0_Core->refs.deref();
-        Q_ASSERT(d_1_0_Core->refs.loadRelaxed());
-    }
-    if (d_1_1_Core) {
-        d_1_1_Core->refs.deref();
-        Q_ASSERT(d_1_1_Core->refs.loadRelaxed());
-    }
-    if (d_1_2_Core) {
-        d_1_2_Core->refs.deref();
-        Q_ASSERT(d_1_2_Core->refs.loadRelaxed());
-    }
-    if (d_1_3_Core) {
-        d_1_3_Core->refs.deref();
-        Q_ASSERT(d_1_3_Core->refs.loadRelaxed());
-    }
-    if (d_1_4_Core) {
-        d_1_4_Core->refs.deref();
-        Q_ASSERT(d_1_4_Core->refs.loadRelaxed());
-    }
-    if (d_1_5_Core) {
-        d_1_5_Core->refs.deref();
-        Q_ASSERT(d_1_5_Core->refs.loadRelaxed());
-    }
-    if (d_2_0_Core) {
-        d_2_0_Core->refs.deref();
-        Q_ASSERT(d_2_0_Core->refs.loadRelaxed());
-    }
-    if (d_2_1_Core) {
-        d_2_1_Core->refs.deref();
-        Q_ASSERT(d_2_1_Core->refs.loadRelaxed());
-    }
-    if (d_1_0_Deprecated) {
-        d_1_0_Deprecated->refs.deref();
-        Q_ASSERT(d_1_0_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_1_Deprecated) {
-        d_1_1_Deprecated->refs.deref();
-        Q_ASSERT(d_1_1_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_2_Deprecated) {
-        d_1_2_Deprecated->refs.deref();
-        Q_ASSERT(d_1_2_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_3_Deprecated) {
-        d_1_3_Deprecated->refs.deref();
-        Q_ASSERT(d_1_3_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_4_Deprecated) {
-        d_1_4_Deprecated->refs.deref();
-        Q_ASSERT(d_1_4_Deprecated->refs.loadRelaxed());
-    }
-}
-
-bool QOpenGLFunctions_2_1::initializeOpenGLFunctions()
-{
-    if ( isInitialized() )
-        return true;
-
-    QOpenGLContext* context = QOpenGLContext::currentContext();
-
-    // If owned by a context object make sure it is current.
-    // Also check that current context is capable of resolving all needed functions
-    if (((owningContext() && owningContext() == context) || !owningContext())
-        && QOpenGLFunctions_2_1::isContextCompatible(context))
-    {
-        // Associate with private implementation, creating if necessary
-        // Function pointers in the backends are resolved at creation time
-        QOpenGLVersionFunctionsBackend* d = nullptr;
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        d_1_3_Core = static_cast<QOpenGLFunctions_1_3_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        d_1_4_Core = static_cast<QOpenGLFunctions_1_4_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        d_1_5_Core = static_cast<QOpenGLFunctions_1_5_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        d_2_0_Core = static_cast<QOpenGLFunctions_2_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        d_2_1_Core = static_cast<QOpenGLFunctions_2_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
-        d_1_0_Deprecated = static_cast<QOpenGLFunctions_1_0_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
-        d_1_1_Deprecated = static_cast<QOpenGLFunctions_1_1_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus());
-        d_1_2_Deprecated = static_cast<QOpenGLFunctions_1_2_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus());
-        d_1_3_Deprecated = static_cast<QOpenGLFunctions_1_3_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
-        d_1_4_Deprecated = static_cast<QOpenGLFunctions_1_4_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        QAbstractOpenGLFunctions::initializeOpenGLFunctions();
-    }
-    return isInitialized();
-}
-
-bool QOpenGLFunctions_2_1::isContextCompatible(QOpenGLContext *context)
-{
-    Q_ASSERT(context);
-    QSurfaceFormat f = context->format();
-    const QPair<int, int> v = qMakePair(f.majorVersion(), f.minorVersion());
-    if (v < qMakePair(2, 1))
-        return false;
-
-    if (f.profile() == QSurfaceFormat::CoreProfile)
-        return false;
-
-    return true;
-}
-
-QOpenGLVersionProfile QOpenGLFunctions_2_1::versionProfile()
-{
-    QOpenGLVersionProfile v;
-    v.setVersion(2, 1);
-    return v;
-}
-
-QT_END_NAMESPACE
diff --git a/src/gui/opengl/qopenglfunctions_2_1.h b/src/gui/opengl/qopenglfunctions_2_1.h
deleted file mode 100644
index f053222c71..0000000000
--- a/src/gui/opengl/qopenglfunctions_2_1.h
+++ /dev/null
@@ -1,3659 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#ifndef QOPENGLVERSIONFUNCTIONS_2_1_H
-#define QOPENGLVERSIONFUNCTIONS_2_1_H
-
-#include <QtGui/qtguiglobal.h>
-
-#if !defined(QT_NO_OPENGL) && !defined(QT_OPENGL_ES_2)
-
-#include <QtGui/QOpenGLVersionFunctions>
-#include <QtGui/qopenglcontext.h>
-
-QT_BEGIN_NAMESPACE
-
-class Q_GUI_EXPORT QOpenGLFunctions_2_1 : public QAbstractOpenGLFunctions
-{
-public:
-    QOpenGLFunctions_2_1();
-    ~QOpenGLFunctions_2_1();
-
-    bool initializeOpenGLFunctions() override;
-
-    // OpenGL 1.0 core functions
-    void glViewport(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glDepthRange(GLdouble nearVal, GLdouble farVal);
-    GLboolean glIsEnabled(GLenum cap);
-    void glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params);
-    void glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params);
-    void glGetTexParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
-    const GLubyte * glGetString(GLenum name);
-    void glGetIntegerv(GLenum pname, GLint *params);
-    void glGetFloatv(GLenum pname, GLfloat *params);
-    GLenum glGetError();
-    void glGetDoublev(GLenum pname, GLdouble *params);
-    void glGetBooleanv(GLenum pname, GLboolean *params);
-    void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
-    void glReadBuffer(GLenum mode);
-    void glPixelStorei(GLenum pname, GLint param);
-    void glPixelStoref(GLenum pname, GLfloat param);
-    void glDepthFunc(GLenum func);
-    void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass);
-    void glStencilFunc(GLenum func, GLint ref, GLuint mask);
-    void glLogicOp(GLenum opcode);
-    void glBlendFunc(GLenum sfactor, GLenum dfactor);
-    void glFlush();
-    void glFinish();
-    void glEnable(GLenum cap);
-    void glDisable(GLenum cap);
-    void glDepthMask(GLboolean flag);
-    void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
-    void glStencilMask(GLuint mask);
-    void glClearDepth(GLdouble depth);
-    void glClearStencil(GLint s);
-    void glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glClear(GLbitfield mask);
-    void glDrawBuffer(GLenum mode);
-    void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glTexParameteri(GLenum target, GLenum pname, GLint param);
-    void glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glTexParameterf(GLenum target, GLenum pname, GLfloat param);
-    void glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glPolygonMode(GLenum face, GLenum mode);
-    void glPointSize(GLfloat size);
-    void glLineWidth(GLfloat width);
-    void glHint(GLenum target, GLenum mode);
-    void glFrontFace(GLenum mode);
-    void glCullFace(GLenum mode);
-
-    // OpenGL 1.1 core functions
-    void glIndexubv(const GLubyte *c);
-    void glIndexub(GLubyte c);
-    GLboolean glIsTexture(GLuint texture);
-    void glGenTextures(GLsizei n, GLuint *textures);
-    void glDeleteTextures(GLsizei n, const GLuint *textures);
-    void glBindTexture(GLenum target, GLuint texture);
-    void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
-    void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
-    void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
-    void glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
-    void glPolygonOffset(GLfloat factor, GLfloat units);
-    void glGetPointerv(GLenum pname, GLvoid* *params);
-    void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
-    void glDrawArrays(GLenum mode, GLint first, GLsizei count);
-
-    // OpenGL 1.2 core functions
-    void glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices);
-    void glBlendEquation(GLenum mode);
-    void glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-
-    // OpenGL 1.3 core functions
-    void glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img);
-    void glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glSampleCoverage(GLfloat value, GLboolean invert);
-    void glActiveTexture(GLenum texture);
-
-    // OpenGL 1.4 core functions
-    void glPointParameteriv(GLenum pname, const GLint *params);
-    void glPointParameteri(GLenum pname, GLint param);
-    void glPointParameterfv(GLenum pname, const GLfloat *params);
-    void glPointParameterf(GLenum pname, GLfloat param);
-    void glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount);
-    void glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount);
-    void glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
-
-    // OpenGL 1.5 core functions
-    void glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params);
-    void glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params);
-    GLboolean glUnmapBuffer(GLenum target);
-    GLvoid* glMapBuffer(GLenum target, GLenum access);
-    void glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data);
-    void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data);
-    void glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage);
-    GLboolean glIsBuffer(GLuint buffer);
-    void glGenBuffers(GLsizei n, GLuint *buffers);
-    void glDeleteBuffers(GLsizei n, const GLuint *buffers);
-    void glBindBuffer(GLenum target, GLuint buffer);
-    void glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params);
-    void glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params);
-    void glGetQueryiv(GLenum target, GLenum pname, GLint *params);
-    void glEndQuery(GLenum target);
-    void glBeginQuery(GLenum target, GLuint id);
-    GLboolean glIsQuery(GLuint id);
-    void glDeleteQueries(GLsizei n, const GLuint *ids);
-    void glGenQueries(GLsizei n, GLuint *ids);
-
-    // OpenGL 2.0 core functions
-    void glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer);
-    void glValidateProgram(GLuint program);
-    void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniform4iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform3iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform2iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform1iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform4fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform3fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform2fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform1fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
-    void glUniform3i(GLint location, GLint v0, GLint v1, GLint v2);
-    void glUniform2i(GLint location, GLint v0, GLint v1);
-    void glUniform1i(GLint location, GLint v0);
-    void glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
-    void glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
-    void glUniform2f(GLint location, GLfloat v0, GLfloat v1);
-    void glUniform1f(GLint location, GLfloat v0);
-    void glUseProgram(GLuint program);
-    void glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length);
-    void glLinkProgram(GLuint program);
-    GLboolean glIsShader(GLuint shader);
-    GLboolean glIsProgram(GLuint program);
-    void glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer);
-    void glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params);
-    void glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params);
-    void glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params);
-    void glGetUniformiv(GLuint program, GLint location, GLint *params);
-    void glGetUniformfv(GLuint program, GLint location, GLfloat *params);
-    GLint glGetUniformLocation(GLuint program, const GLchar *name);
-    void glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source);
-    void glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void glGetShaderiv(GLuint shader, GLenum pname, GLint *params);
-    void glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void glGetProgramiv(GLuint program, GLenum pname, GLint *params);
-    GLint glGetAttribLocation(GLuint program, const GLchar *name);
-    void glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj);
-    void glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
-    void glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
-    void glEnableVertexAttribArray(GLuint index);
-    void glDisableVertexAttribArray(GLuint index);
-    void glDetachShader(GLuint program, GLuint shader);
-    void glDeleteShader(GLuint shader);
-    void glDeleteProgram(GLuint program);
-    GLuint glCreateShader(GLenum type);
-    GLuint glCreateProgram();
-    void glCompileShader(GLuint shader);
-    void glBindAttribLocation(GLuint program, GLuint index, const GLchar *name);
-    void glAttachShader(GLuint program, GLuint shader);
-    void glStencilMaskSeparate(GLenum face, GLuint mask);
-    void glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask);
-    void glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);
-    void glDrawBuffers(GLsizei n, const GLenum *bufs);
-    void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha);
-
-    // OpenGL 2.1 core functions
-    void glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-
-    // OpenGL 1.0 deprecated functions
-    void glTranslatef(GLfloat x, GLfloat y, GLfloat z);
-    void glTranslated(GLdouble x, GLdouble y, GLdouble z);
-    void glScalef(GLfloat x, GLfloat y, GLfloat z);
-    void glScaled(GLdouble x, GLdouble y, GLdouble z);
-    void glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
-    void glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
-    void glPushMatrix();
-    void glPopMatrix();
-    void glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
-    void glMultMatrixd(const GLdouble *m);
-    void glMultMatrixf(const GLfloat *m);
-    void glMatrixMode(GLenum mode);
-    void glLoadMatrixd(const GLdouble *m);
-    void glLoadMatrixf(const GLfloat *m);
-    void glLoadIdentity();
-    void glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
-    GLboolean glIsList(GLuint list);
-    void glGetTexGeniv(GLenum coord, GLenum pname, GLint *params);
-    void glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params);
-    void glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params);
-    void glGetTexEnviv(GLenum target, GLenum pname, GLint *params);
-    void glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetPolygonStipple(GLubyte *mask);
-    void glGetPixelMapusv(GLenum map, GLushort *values);
-    void glGetPixelMapuiv(GLenum map, GLuint *values);
-    void glGetPixelMapfv(GLenum map, GLfloat *values);
-    void glGetMaterialiv(GLenum face, GLenum pname, GLint *params);
-    void glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params);
-    void glGetMapiv(GLenum target, GLenum query, GLint *v);
-    void glGetMapfv(GLenum target, GLenum query, GLfloat *v);
-    void glGetMapdv(GLenum target, GLenum query, GLdouble *v);
-    void glGetLightiv(GLenum light, GLenum pname, GLint *params);
-    void glGetLightfv(GLenum light, GLenum pname, GLfloat *params);
-    void glGetClipPlane(GLenum plane, GLdouble *equation);
-    void glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
-    void glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
-    void glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values);
-    void glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values);
-    void glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values);
-    void glPixelTransferi(GLenum pname, GLint param);
-    void glPixelTransferf(GLenum pname, GLfloat param);
-    void glPixelZoom(GLfloat xfactor, GLfloat yfactor);
-    void glAlphaFunc(GLenum func, GLfloat ref);
-    void glEvalPoint2(GLint i, GLint j);
-    void glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
-    void glEvalPoint1(GLint i);
-    void glEvalMesh1(GLenum mode, GLint i1, GLint i2);
-    void glEvalCoord2fv(const GLfloat *u);
-    void glEvalCoord2f(GLfloat u, GLfloat v);
-    void glEvalCoord2dv(const GLdouble *u);
-    void glEvalCoord2d(GLdouble u, GLdouble v);
-    void glEvalCoord1fv(const GLfloat *u);
-    void glEvalCoord1f(GLfloat u);
-    void glEvalCoord1dv(const GLdouble *u);
-    void glEvalCoord1d(GLdouble u);
-    void glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
-    void glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
-    void glMapGrid1f(GLint un, GLfloat u1, GLfloat u2);
-    void glMapGrid1d(GLint un, GLdouble u1, GLdouble u2);
-    void glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);
-    void glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);
-    void glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);
-    void glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);
-    void glPushAttrib(GLbitfield mask);
-    void glPopAttrib();
-    void glAccum(GLenum op, GLfloat value);
-    void glIndexMask(GLuint mask);
-    void glClearIndex(GLfloat c);
-    void glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glPushName(GLuint name);
-    void glPopName();
-    void glPassThrough(GLfloat token);
-    void glLoadName(GLuint name);
-    void glInitNames();
-    GLint glRenderMode(GLenum mode);
-    void glSelectBuffer(GLsizei size, GLuint *buffer);
-    void glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer);
-    void glTexGeniv(GLenum coord, GLenum pname, const GLint *params);
-    void glTexGeni(GLenum coord, GLenum pname, GLint param);
-    void glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params);
-    void glTexGenf(GLenum coord, GLenum pname, GLfloat param);
-    void glTexGendv(GLenum coord, GLenum pname, const GLdouble *params);
-    void glTexGend(GLenum coord, GLenum pname, GLdouble param);
-    void glTexEnviv(GLenum target, GLenum pname, const GLint *params);
-    void glTexEnvi(GLenum target, GLenum pname, GLint param);
-    void glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glTexEnvf(GLenum target, GLenum pname, GLfloat param);
-    void glShadeModel(GLenum mode);
-    void glPolygonStipple(const GLubyte *mask);
-    void glMaterialiv(GLenum face, GLenum pname, const GLint *params);
-    void glMateriali(GLenum face, GLenum pname, GLint param);
-    void glMaterialfv(GLenum face, GLenum pname, const GLfloat *params);
-    void glMaterialf(GLenum face, GLenum pname, GLfloat param);
-    void glLineStipple(GLint factor, GLushort pattern);
-    void glLightModeliv(GLenum pname, const GLint *params);
-    void glLightModeli(GLenum pname, GLint param);
-    void glLightModelfv(GLenum pname, const GLfloat *params);
-    void glLightModelf(GLenum pname, GLfloat param);
-    void glLightiv(GLenum light, GLenum pname, const GLint *params);
-    void glLighti(GLenum light, GLenum pname, GLint param);
-    void glLightfv(GLenum light, GLenum pname, const GLfloat *params);
-    void glLightf(GLenum light, GLenum pname, GLfloat param);
-    void glFogiv(GLenum pname, const GLint *params);
-    void glFogi(GLenum pname, GLint param);
-    void glFogfv(GLenum pname, const GLfloat *params);
-    void glFogf(GLenum pname, GLfloat param);
-    void glColorMaterial(GLenum face, GLenum mode);
-    void glClipPlane(GLenum plane, const GLdouble *equation);
-    void glVertex4sv(const GLshort *v);
-    void glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w);
-    void glVertex4iv(const GLint *v);
-    void glVertex4i(GLint x, GLint y, GLint z, GLint w);
-    void glVertex4fv(const GLfloat *v);
-    void glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void glVertex4dv(const GLdouble *v);
-    void glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glVertex3sv(const GLshort *v);
-    void glVertex3s(GLshort x, GLshort y, GLshort z);
-    void glVertex3iv(const GLint *v);
-    void glVertex3i(GLint x, GLint y, GLint z);
-    void glVertex3fv(const GLfloat *v);
-    void glVertex3f(GLfloat x, GLfloat y, GLfloat z);
-    void glVertex3dv(const GLdouble *v);
-    void glVertex3d(GLdouble x, GLdouble y, GLdouble z);
-    void glVertex2sv(const GLshort *v);
-    void glVertex2s(GLshort x, GLshort y);
-    void glVertex2iv(const GLint *v);
-    void glVertex2i(GLint x, GLint y);
-    void glVertex2fv(const GLfloat *v);
-    void glVertex2f(GLfloat x, GLfloat y);
-    void glVertex2dv(const GLdouble *v);
-    void glVertex2d(GLdouble x, GLdouble y);
-    void glTexCoord4sv(const GLshort *v);
-    void glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q);
-    void glTexCoord4iv(const GLint *v);
-    void glTexCoord4i(GLint s, GLint t, GLint r, GLint q);
-    void glTexCoord4fv(const GLfloat *v);
-    void glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
-    void glTexCoord4dv(const GLdouble *v);
-    void glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q);
-    void glTexCoord3sv(const GLshort *v);
-    void glTexCoord3s(GLshort s, GLshort t, GLshort r);
-    void glTexCoord3iv(const GLint *v);
-    void glTexCoord3i(GLint s, GLint t, GLint r);
-    void glTexCoord3fv(const GLfloat *v);
-    void glTexCoord3f(GLfloat s, GLfloat t, GLfloat r);
-    void glTexCoord3dv(const GLdouble *v);
-    void glTexCoord3d(GLdouble s, GLdouble t, GLdouble r);
-    void glTexCoord2sv(const GLshort *v);
-    void glTexCoord2s(GLshort s, GLshort t);
-    void glTexCoord2iv(const GLint *v);
-    void glTexCoord2i(GLint s, GLint t);
-    void glTexCoord2fv(const GLfloat *v);
-    void glTexCoord2f(GLfloat s, GLfloat t);
-    void glTexCoord2dv(const GLdouble *v);
-    void glTexCoord2d(GLdouble s, GLdouble t);
-    void glTexCoord1sv(const GLshort *v);
-    void glTexCoord1s(GLshort s);
-    void glTexCoord1iv(const GLint *v);
-    void glTexCoord1i(GLint s);
-    void glTexCoord1fv(const GLfloat *v);
-    void glTexCoord1f(GLfloat s);
-    void glTexCoord1dv(const GLdouble *v);
-    void glTexCoord1d(GLdouble s);
-    void glRectsv(const GLshort *v1, const GLshort *v2);
-    void glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
-    void glRectiv(const GLint *v1, const GLint *v2);
-    void glRecti(GLint x1, GLint y1, GLint x2, GLint y2);
-    void glRectfv(const GLfloat *v1, const GLfloat *v2);
-    void glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
-    void glRectdv(const GLdouble *v1, const GLdouble *v2);
-    void glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
-    void glRasterPos4sv(const GLshort *v);
-    void glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w);
-    void glRasterPos4iv(const GLint *v);
-    void glRasterPos4i(GLint x, GLint y, GLint z, GLint w);
-    void glRasterPos4fv(const GLfloat *v);
-    void glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void glRasterPos4dv(const GLdouble *v);
-    void glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glRasterPos3sv(const GLshort *v);
-    void glRasterPos3s(GLshort x, GLshort y, GLshort z);
-    void glRasterPos3iv(const GLint *v);
-    void glRasterPos3i(GLint x, GLint y, GLint z);
-    void glRasterPos3fv(const GLfloat *v);
-    void glRasterPos3f(GLfloat x, GLfloat y, GLfloat z);
-    void glRasterPos3dv(const GLdouble *v);
-    void glRasterPos3d(GLdouble x, GLdouble y, GLdouble z);
-    void glRasterPos2sv(const GLshort *v);
-    void glRasterPos2s(GLshort x, GLshort y);
-    void glRasterPos2iv(const GLint *v);
-    void glRasterPos2i(GLint x, GLint y);
-    void glRasterPos2fv(const GLfloat *v);
-    void glRasterPos2f(GLfloat x, GLfloat y);
-    void glRasterPos2dv(const GLdouble *v);
-    void glRasterPos2d(GLdouble x, GLdouble y);
-    void glNormal3sv(const GLshort *v);
-    void glNormal3s(GLshort nx, GLshort ny, GLshort nz);
-    void glNormal3iv(const GLint *v);
-    void glNormal3i(GLint nx, GLint ny, GLint nz);
-    void glNormal3fv(const GLfloat *v);
-    void glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz);
-    void glNormal3dv(const GLdouble *v);
-    void glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz);
-    void glNormal3bv(const GLbyte *v);
-    void glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz);
-    void glIndexsv(const GLshort *c);
-    void glIndexs(GLshort c);
-    void glIndexiv(const GLint *c);
-    void glIndexi(GLint c);
-    void glIndexfv(const GLfloat *c);
-    void glIndexf(GLfloat c);
-    void glIndexdv(const GLdouble *c);
-    void glIndexd(GLdouble c);
-    void glEnd();
-    void glEdgeFlagv(const GLboolean *flag);
-    void glEdgeFlag(GLboolean flag);
-    void glColor4usv(const GLushort *v);
-    void glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha);
-    void glColor4uiv(const GLuint *v);
-    void glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha);
-    void glColor4ubv(const GLubyte *v);
-    void glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
-    void glColor4sv(const GLshort *v);
-    void glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha);
-    void glColor4iv(const GLint *v);
-    void glColor4i(GLint red, GLint green, GLint blue, GLint alpha);
-    void glColor4fv(const GLfloat *v);
-    void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glColor4dv(const GLdouble *v);
-    void glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
-    void glColor4bv(const GLbyte *v);
-    void glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
-    void glColor3usv(const GLushort *v);
-    void glColor3us(GLushort red, GLushort green, GLushort blue);
-    void glColor3uiv(const GLuint *v);
-    void glColor3ui(GLuint red, GLuint green, GLuint blue);
-    void glColor3ubv(const GLubyte *v);
-    void glColor3ub(GLubyte red, GLubyte green, GLubyte blue);
-    void glColor3sv(const GLshort *v);
-    void glColor3s(GLshort red, GLshort green, GLshort blue);
-    void glColor3iv(const GLint *v);
-    void glColor3i(GLint red, GLint green, GLint blue);
-    void glColor3fv(const GLfloat *v);
-    void glColor3f(GLfloat red, GLfloat green, GLfloat blue);
-    void glColor3dv(const GLdouble *v);
-    void glColor3d(GLdouble red, GLdouble green, GLdouble blue);
-    void glColor3bv(const GLbyte *v);
-    void glColor3b(GLbyte red, GLbyte green, GLbyte blue);
-    void glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap);
-    void glBegin(GLenum mode);
-    void glListBase(GLuint base);
-    GLuint glGenLists(GLsizei range);
-    void glDeleteLists(GLuint list, GLsizei range);
-    void glCallLists(GLsizei n, GLenum type, const GLvoid *lists);
-    void glCallList(GLuint list);
-    void glEndList();
-    void glNewList(GLuint list, GLenum mode);
-
-    // OpenGL 1.1 deprecated functions
-    void glPushClientAttrib(GLbitfield mask);
-    void glPopClientAttrib();
-    void glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities);
-    GLboolean glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences);
-    void glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer);
-    void glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glEnableClientState(GLenum array);
-    void glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer);
-    void glDisableClientState(GLenum array);
-    void glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glArrayElement(GLint i);
-
-    // OpenGL 1.2 deprecated functions
-    void glResetMinmax(GLenum target);
-    void glResetHistogram(GLenum target);
-    void glMinmax(GLenum target, GLenum internalformat, GLboolean sink);
-    void glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink);
-    void glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
-    void glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
-    void glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column);
-    void glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span);
-    void glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image);
-    void glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
-    void glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glConvolutionParameteri(GLenum target, GLenum pname, GLint params);
-    void glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params);
-    void glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image);
-    void glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image);
-    void glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width);
-    void glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data);
-    void glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table);
-    void glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
-    void glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table);
-
-    // OpenGL 1.3 deprecated functions
-    void glMultTransposeMatrixd(const GLdouble *m);
-    void glMultTransposeMatrixf(const GLfloat *m);
-    void glLoadTransposeMatrixd(const GLdouble *m);
-    void glLoadTransposeMatrixf(const GLfloat *m);
-    void glMultiTexCoord4sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);
-    void glMultiTexCoord4iv(GLenum target, const GLint *v);
-    void glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q);
-    void glMultiTexCoord4fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
-    void glMultiTexCoord4dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
-    void glMultiTexCoord3sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r);
-    void glMultiTexCoord3iv(GLenum target, const GLint *v);
-    void glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r);
-    void glMultiTexCoord3fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r);
-    void glMultiTexCoord3dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r);
-    void glMultiTexCoord2sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord2s(GLenum target, GLshort s, GLshort t);
-    void glMultiTexCoord2iv(GLenum target, const GLint *v);
-    void glMultiTexCoord2i(GLenum target, GLint s, GLint t);
-    void glMultiTexCoord2fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t);
-    void glMultiTexCoord2dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t);
-    void glMultiTexCoord1sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord1s(GLenum target, GLshort s);
-    void glMultiTexCoord1iv(GLenum target, const GLint *v);
-    void glMultiTexCoord1i(GLenum target, GLint s);
-    void glMultiTexCoord1fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord1f(GLenum target, GLfloat s);
-    void glMultiTexCoord1dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord1d(GLenum target, GLdouble s);
-    void glClientActiveTexture(GLenum texture);
-
-    // OpenGL 1.4 deprecated functions
-    void glWindowPos3sv(const GLshort *v);
-    void glWindowPos3s(GLshort x, GLshort y, GLshort z);
-    void glWindowPos3iv(const GLint *v);
-    void glWindowPos3i(GLint x, GLint y, GLint z);
-    void glWindowPos3fv(const GLfloat *v);
-    void glWindowPos3f(GLfloat x, GLfloat y, GLfloat z);
-    void glWindowPos3dv(const GLdouble *v);
-    void glWindowPos3d(GLdouble x, GLdouble y, GLdouble z);
-    void glWindowPos2sv(const GLshort *v);
-    void glWindowPos2s(GLshort x, GLshort y);
-    void glWindowPos2iv(const GLint *v);
-    void glWindowPos2i(GLint x, GLint y);
-    void glWindowPos2fv(const GLfloat *v);
-    void glWindowPos2f(GLfloat x, GLfloat y);
-    void glWindowPos2dv(const GLdouble *v);
-    void glWindowPos2d(GLdouble x, GLdouble y);
-    void glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glSecondaryColor3usv(const GLushort *v);
-    void glSecondaryColor3us(GLushort red, GLushort green, GLushort blue);
-    void glSecondaryColor3uiv(const GLuint *v);
-    void glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue);
-    void glSecondaryColor3ubv(const GLubyte *v);
-    void glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue);
-    void glSecondaryColor3sv(const GLshort *v);
-    void glSecondaryColor3s(GLshort red, GLshort green, GLshort blue);
-    void glSecondaryColor3iv(const GLint *v);
-    void glSecondaryColor3i(GLint red, GLint green, GLint blue);
-    void glSecondaryColor3fv(const GLfloat *v);
-    void glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue);
-    void glSecondaryColor3dv(const GLdouble *v);
-    void glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue);
-    void glSecondaryColor3bv(const GLbyte *v);
-    void glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue);
-    void glFogCoordPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glFogCoorddv(const GLdouble *coord);
-    void glFogCoordd(GLdouble coord);
-    void glFogCoordfv(const GLfloat *coord);
-    void glFogCoordf(GLfloat coord);
-
-    // OpenGL 1.5 deprecated functions
-
-    // OpenGL 2.0 deprecated functions
-    void glVertexAttrib4usv(GLuint index, const GLushort *v);
-    void glVertexAttrib4uiv(GLuint index, const GLuint *v);
-    void glVertexAttrib4ubv(GLuint index, const GLubyte *v);
-    void glVertexAttrib4sv(GLuint index, const GLshort *v);
-    void glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
-    void glVertexAttrib4iv(GLuint index, const GLint *v);
-    void glVertexAttrib4fv(GLuint index, const GLfloat *v);
-    void glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void glVertexAttrib4dv(GLuint index, const GLdouble *v);
-    void glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glVertexAttrib4bv(GLuint index, const GLbyte *v);
-    void glVertexAttrib4Nusv(GLuint index, const GLushort *v);
-    void glVertexAttrib4Nuiv(GLuint index, const GLuint *v);
-    void glVertexAttrib4Nubv(GLuint index, const GLubyte *v);
-    void glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
-    void glVertexAttrib4Nsv(GLuint index, const GLshort *v);
-    void glVertexAttrib4Niv(GLuint index, const GLint *v);
-    void glVertexAttrib4Nbv(GLuint index, const GLbyte *v);
-    void glVertexAttrib3sv(GLuint index, const GLshort *v);
-    void glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z);
-    void glVertexAttrib3fv(GLuint index, const GLfloat *v);
-    void glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z);
-    void glVertexAttrib3dv(GLuint index, const GLdouble *v);
-    void glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z);
-    void glVertexAttrib2sv(GLuint index, const GLshort *v);
-    void glVertexAttrib2s(GLuint index, GLshort x, GLshort y);
-    void glVertexAttrib2fv(GLuint index, const GLfloat *v);
-    void glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y);
-    void glVertexAttrib2dv(GLuint index, const GLdouble *v);
-    void glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y);
-    void glVertexAttrib1sv(GLuint index, const GLshort *v);
-    void glVertexAttrib1s(GLuint index, GLshort x);
-    void glVertexAttrib1fv(GLuint index, const GLfloat *v);
-    void glVertexAttrib1f(GLuint index, GLfloat x);
-    void glVertexAttrib1dv(GLuint index, const GLdouble *v);
-    void glVertexAttrib1d(GLuint index, GLdouble x);
-
-    // OpenGL 2.1 deprecated functions
-
-private:
-    friend class QOpenGLContext;
-
-    static bool isContextCompatible(QOpenGLContext *context);
-    static QOpenGLVersionProfile versionProfile();
-
-    QOpenGLFunctions_1_0_CoreBackend* d_1_0_Core;
-    QOpenGLFunctions_1_1_CoreBackend* d_1_1_Core;
-    QOpenGLFunctions_1_2_CoreBackend* d_1_2_Core;
-    QOpenGLFunctions_1_3_CoreBackend* d_1_3_Core;
-    QOpenGLFunctions_1_4_CoreBackend* d_1_4_Core;
-    QOpenGLFunctions_1_5_CoreBackend* d_1_5_Core;
-    QOpenGLFunctions_2_0_CoreBackend* d_2_0_Core;
-    QOpenGLFunctions_2_1_CoreBackend* d_2_1_Core;
-    QOpenGLFunctions_1_0_DeprecatedBackend* d_1_0_Deprecated;
-    QOpenGLFunctions_1_1_DeprecatedBackend* d_1_1_Deprecated;
-    QOpenGLFunctions_1_2_DeprecatedBackend* d_1_2_Deprecated;
-    QOpenGLFunctions_1_3_DeprecatedBackend* d_1_3_Deprecated;
-    QOpenGLFunctions_1_4_DeprecatedBackend* d_1_4_Deprecated;
-    void *m_reserved_2_0_Deprecated; // To maintain BC
-};
-
-// OpenGL 1.0 core functions
-inline void QOpenGLFunctions_2_1::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_0_Core->f.Viewport(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_2_1::glDepthRange(GLdouble nearVal, GLdouble farVal)
-{
-    d_1_0_Core->f.DepthRange(nearVal, farVal);
-}
-
-inline GLboolean QOpenGLFunctions_2_1::glIsEnabled(GLenum cap)
-{
-    return d_1_0_Core->f.IsEnabled(cap);
-}
-
-inline void QOpenGLFunctions_2_1::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetTexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetTexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
-{
-    d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
-}
-
-inline const GLubyte * QOpenGLFunctions_2_1::glGetString(GLenum name)
-{
-    return d_1_0_Core->f.GetString(name);
-}
-
-inline void QOpenGLFunctions_2_1::glGetIntegerv(GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetIntegerv(pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glGetFloatv(GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetFloatv(pname, params);
-}
-
-inline GLenum QOpenGLFunctions_2_1::glGetError()
-{
-    return d_1_0_Core->f.GetError();
-}
-
-inline void QOpenGLFunctions_2_1::glGetDoublev(GLenum pname, GLdouble *params)
-{
-    d_1_0_Core->f.GetDoublev(pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glGetBooleanv(GLenum pname, GLboolean *params)
-{
-    d_1_0_Core->f.GetBooleanv(pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
-{
-    d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_2_1::glReadBuffer(GLenum mode)
-{
-    d_1_0_Core->f.ReadBuffer(mode);
-}
-
-inline void QOpenGLFunctions_2_1::glPixelStorei(GLenum pname, GLint param)
-{
-    d_1_0_Core->f.PixelStorei(pname, param);
-}
-
-inline void QOpenGLFunctions_2_1::glPixelStoref(GLenum pname, GLfloat param)
-{
-    d_1_0_Core->f.PixelStoref(pname, param);
-}
-
-inline void QOpenGLFunctions_2_1::glDepthFunc(GLenum func)
-{
-    d_1_0_Core->f.DepthFunc(func);
-}
-
-inline void QOpenGLFunctions_2_1::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
-{
-    d_1_0_Core->f.StencilOp(fail, zfail, zpass);
-}
-
-inline void QOpenGLFunctions_2_1::glStencilFunc(GLenum func, GLint ref, GLuint mask)
-{
-    d_1_0_Core->f.StencilFunc(func, ref, mask);
-}
-
-inline void QOpenGLFunctions_2_1::glLogicOp(GLenum opcode)
-{
-    d_1_0_Core->f.LogicOp(opcode);
-}
-
-inline void QOpenGLFunctions_2_1::glBlendFunc(GLenum sfactor, GLenum dfactor)
-{
-    d_1_0_Core->f.BlendFunc(sfactor, dfactor);
-}
-
-inline void QOpenGLFunctions_2_1::glFlush()
-{
-    d_1_0_Core->f.Flush();
-}
-
-inline void QOpenGLFunctions_2_1::glFinish()
-{
-    d_1_0_Core->f.Finish();
-}
-
-inline void QOpenGLFunctions_2_1::glEnable(GLenum cap)
-{
-    d_1_0_Core->f.Enable(cap);
-}
-
-inline void QOpenGLFunctions_2_1::glDisable(GLenum cap)
-{
-    d_1_0_Core->f.Disable(cap);
-}
-
-inline void QOpenGLFunctions_2_1::glDepthMask(GLboolean flag)
-{
-    d_1_0_Core->f.DepthMask(flag);
-}
-
-inline void QOpenGLFunctions_2_1::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
-{
-    d_1_0_Core->f.ColorMask(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_2_1::glStencilMask(GLuint mask)
-{
-    d_1_0_Core->f.StencilMask(mask);
-}
-
-inline void QOpenGLFunctions_2_1::glClearDepth(GLdouble depth)
-{
-    d_1_0_Core->f.ClearDepth(depth);
-}
-
-inline void QOpenGLFunctions_2_1::glClearStencil(GLint s)
-{
-    d_1_0_Core->f.ClearStencil(s);
-}
-
-inline void QOpenGLFunctions_2_1::glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Core->f.ClearColor(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_2_1::glClear(GLbitfield mask)
-{
-    d_1_0_Core->f.Clear(mask);
-}
-
-inline void QOpenGLFunctions_2_1::glDrawBuffer(GLenum mode)
-{
-    d_1_0_Core->f.DrawBuffer(mode);
-}
-
-inline void QOpenGLFunctions_2_1::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Core->f.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_2_1::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Core->f.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_2_1::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_0_Core->f.TexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glTexParameteri(GLenum target, GLenum pname, GLint param)
-{
-    d_1_0_Core->f.TexParameteri(target, pname, param);
-}
-
-inline void QOpenGLFunctions_2_1::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Core->f.TexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
-{
-    d_1_0_Core->f.TexParameterf(target, pname, param);
-}
-
-inline void QOpenGLFunctions_2_1::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_0_Core->f.Scissor(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_2_1::glPolygonMode(GLenum face, GLenum mode)
-{
-    d_1_0_Core->f.PolygonMode(face, mode);
-}
-
-inline void QOpenGLFunctions_2_1::glPointSize(GLfloat size)
-{
-    d_1_0_Core->f.PointSize(size);
-}
-
-inline void QOpenGLFunctions_2_1::glLineWidth(GLfloat width)
-{
-    d_1_0_Core->f.LineWidth(width);
-}
-
-inline void QOpenGLFunctions_2_1::glHint(GLenum target, GLenum mode)
-{
-    d_1_0_Core->f.Hint(target, mode);
-}
-
-inline void QOpenGLFunctions_2_1::glFrontFace(GLenum mode)
-{
-    d_1_0_Core->f.FrontFace(mode);
-}
-
-inline void QOpenGLFunctions_2_1::glCullFace(GLenum mode)
-{
-    d_1_0_Core->f.CullFace(mode);
-}
-
-
-// OpenGL 1.1 core functions
-inline void QOpenGLFunctions_2_1::glIndexubv(const GLubyte *c)
-{
-    d_1_1_Deprecated->f.Indexubv(c);
-}
-
-inline void QOpenGLFunctions_2_1::glIndexub(GLubyte c)
-{
-    d_1_1_Deprecated->f.Indexub(c);
-}
-
-inline GLboolean QOpenGLFunctions_2_1::glIsTexture(GLuint texture)
-{
-    return d_1_1_Core->f.IsTexture(texture);
-}
-
-inline void QOpenGLFunctions_2_1::glGenTextures(GLsizei n, GLuint *textures)
-{
-    d_1_1_Core->f.GenTextures(n, textures);
-}
-
-inline void QOpenGLFunctions_2_1::glDeleteTextures(GLsizei n, const GLuint *textures)
-{
-    d_1_1_Core->f.DeleteTextures(n, textures);
-}
-
-inline void QOpenGLFunctions_2_1::glBindTexture(GLenum target, GLuint texture)
-{
-    d_1_1_Core->f.BindTexture(target, texture);
-}
-
-inline void QOpenGLFunctions_2_1::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_1_Core->f.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_2_1::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_1_Core->f.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_2_1::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_1_Core->f.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_2_1::glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
-{
-    d_1_1_Core->f.CopyTexSubImage1D(target, level, xoffset, x, y, width);
-}
-
-inline void QOpenGLFunctions_2_1::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
-{
-    d_1_1_Core->f.CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
-}
-
-inline void QOpenGLFunctions_2_1::glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
-{
-    d_1_1_Core->f.CopyTexImage1D(target, level, internalformat, x, y, width, border);
-}
-
-inline void QOpenGLFunctions_2_1::glPolygonOffset(GLfloat factor, GLfloat units)
-{
-    d_1_1_Core->f.PolygonOffset(factor, units);
-}
-
-inline void QOpenGLFunctions_2_1::glGetPointerv(GLenum pname, GLvoid* *params)
-{
-    d_1_1_Deprecated->f.GetPointerv(pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
-{
-    d_1_1_Core->f.DrawElements(mode, count, type, indices);
-}
-
-inline void QOpenGLFunctions_2_1::glDrawArrays(GLenum mode, GLint first, GLsizei count)
-{
-    d_1_1_Core->f.DrawArrays(mode, first, count);
-}
-
-
-// OpenGL 1.2 core functions
-inline void QOpenGLFunctions_2_1::glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_2_Core->f.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_2_1::glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_2_Core->f.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_2_1::glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_2_Core->f.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_2_1::glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
-{
-    d_1_2_Core->f.DrawRangeElements(mode, start, end, count, type, indices);
-}
-
-inline void QOpenGLFunctions_2_1::glBlendEquation(GLenum mode)
-{
-    d_1_2_Core->f.BlendEquation(mode);
-}
-
-inline void QOpenGLFunctions_2_1::glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_2_Core->f.BlendColor(red, green, blue, alpha);
-}
-
-
-// OpenGL 1.3 core functions
-inline void QOpenGLFunctions_2_1::glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img)
-{
-    d_1_3_Core->f.GetCompressedTexImage(target, level, img);
-}
-
-inline void QOpenGLFunctions_2_1::glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_2_1::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_2_1::glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_2_1::glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_2_1::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_2_1::glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_2_1::glSampleCoverage(GLfloat value, GLboolean invert)
-{
-    d_1_3_Core->f.SampleCoverage(value, invert);
-}
-
-inline void QOpenGLFunctions_2_1::glActiveTexture(GLenum texture)
-{
-    d_1_3_Core->f.ActiveTexture(texture);
-}
-
-
-// OpenGL 1.4 core functions
-inline void QOpenGLFunctions_2_1::glPointParameteriv(GLenum pname, const GLint *params)
-{
-    d_1_4_Core->f.PointParameteriv(pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glPointParameteri(GLenum pname, GLint param)
-{
-    d_1_4_Core->f.PointParameteri(pname, param);
-}
-
-inline void QOpenGLFunctions_2_1::glPointParameterfv(GLenum pname, const GLfloat *params)
-{
-    d_1_4_Core->f.PointParameterfv(pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glPointParameterf(GLenum pname, GLfloat param)
-{
-    d_1_4_Core->f.PointParameterf(pname, param);
-}
-
-inline void QOpenGLFunctions_2_1::glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount)
-{
-    d_1_4_Core->f.MultiDrawElements(mode, count, type, indices, drawcount);
-}
-
-inline void QOpenGLFunctions_2_1::glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
-{
-    d_1_4_Core->f.MultiDrawArrays(mode, first, count, drawcount);
-}
-
-inline void QOpenGLFunctions_2_1::glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
-{
-    d_1_4_Core->f.BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
-}
-
-
-// OpenGL 1.5 core functions
-inline void QOpenGLFunctions_2_1::glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params)
-{
-    d_1_5_Core->f.GetBufferPointerv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetBufferParameteriv(target, pname, params);
-}
-
-inline GLboolean QOpenGLFunctions_2_1::glUnmapBuffer(GLenum target)
-{
-    return d_1_5_Core->f.UnmapBuffer(target);
-}
-
-inline GLvoid* QOpenGLFunctions_2_1::glMapBuffer(GLenum target, GLenum access)
-{
-    return d_1_5_Core->f.MapBuffer(target, access);
-}
-
-inline void QOpenGLFunctions_2_1::glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data)
-{
-    d_1_5_Core->f.GetBufferSubData(target, offset, size, data);
-}
-
-inline void QOpenGLFunctions_2_1::glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data)
-{
-    d_1_5_Core->f.BufferSubData(target, offset, size, data);
-}
-
-inline void QOpenGLFunctions_2_1::glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)
-{
-    d_1_5_Core->f.BufferData(target, size, data, usage);
-}
-
-inline GLboolean QOpenGLFunctions_2_1::glIsBuffer(GLuint buffer)
-{
-    return d_1_5_Core->f.IsBuffer(buffer);
-}
-
-inline void QOpenGLFunctions_2_1::glGenBuffers(GLsizei n, GLuint *buffers)
-{
-    d_1_5_Core->f.GenBuffers(n, buffers);
-}
-
-inline void QOpenGLFunctions_2_1::glDeleteBuffers(GLsizei n, const GLuint *buffers)
-{
-    d_1_5_Core->f.DeleteBuffers(n, buffers);
-}
-
-inline void QOpenGLFunctions_2_1::glBindBuffer(GLenum target, GLuint buffer)
-{
-    d_1_5_Core->f.BindBuffer(target, buffer);
-}
-
-inline void QOpenGLFunctions_2_1::glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
-{
-    d_1_5_Core->f.GetQueryObjectuiv(id, pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetQueryObjectiv(id, pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glGetQueryiv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetQueryiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glEndQuery(GLenum target)
-{
-    d_1_5_Core->f.EndQuery(target);
-}
-
-inline void QOpenGLFunctions_2_1::glBeginQuery(GLenum target, GLuint id)
-{
-    d_1_5_Core->f.BeginQuery(target, id);
-}
-
-inline GLboolean QOpenGLFunctions_2_1::glIsQuery(GLuint id)
-{
-    return d_1_5_Core->f.IsQuery(id);
-}
-
-inline void QOpenGLFunctions_2_1::glDeleteQueries(GLsizei n, const GLuint *ids)
-{
-    d_1_5_Core->f.DeleteQueries(n, ids);
-}
-
-inline void QOpenGLFunctions_2_1::glGenQueries(GLsizei n, GLuint *ids)
-{
-    d_1_5_Core->f.GenQueries(n, ids);
-}
-
-
-// OpenGL 2.0 core functions
-inline void QOpenGLFunctions_2_1::glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer)
-{
-    d_2_0_Core->f.VertexAttribPointer(index, size, type, normalized, stride, pointer);
-}
-
-inline void QOpenGLFunctions_2_1::glValidateProgram(GLuint program)
-{
-    d_2_0_Core->f.ValidateProgram(program);
-}
-
-inline void QOpenGLFunctions_2_1::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_2_1::glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix3fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_2_1::glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_2_1::glUniform4iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform4iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_2_1::glUniform3iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform3iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_2_1::glUniform2iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform2iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_2_1::glUniform1iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform1iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_2_1::glUniform4fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform4fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_2_1::glUniform3fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform3fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_2_1::glUniform2fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform2fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_2_1::glUniform1fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform1fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_2_1::glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
-{
-    d_2_0_Core->f.Uniform4i(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_2_1::glUniform3i(GLint location, GLint v0, GLint v1, GLint v2)
-{
-    d_2_0_Core->f.Uniform3i(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_2_1::glUniform2i(GLint location, GLint v0, GLint v1)
-{
-    d_2_0_Core->f.Uniform2i(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_2_1::glUniform1i(GLint location, GLint v0)
-{
-    d_2_0_Core->f.Uniform1i(location, v0);
-}
-
-inline void QOpenGLFunctions_2_1::glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
-{
-    d_2_0_Core->f.Uniform4f(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_2_1::glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
-{
-    d_2_0_Core->f.Uniform3f(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_2_1::glUniform2f(GLint location, GLfloat v0, GLfloat v1)
-{
-    d_2_0_Core->f.Uniform2f(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_2_1::glUniform1f(GLint location, GLfloat v0)
-{
-    d_2_0_Core->f.Uniform1f(location, v0);
-}
-
-inline void QOpenGLFunctions_2_1::glUseProgram(GLuint program)
-{
-    d_2_0_Core->f.UseProgram(program);
-}
-
-inline void QOpenGLFunctions_2_1::glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length)
-{
-    d_2_0_Core->f.ShaderSource(shader, count, string, length);
-}
-
-inline void QOpenGLFunctions_2_1::glLinkProgram(GLuint program)
-{
-    d_2_0_Core->f.LinkProgram(program);
-}
-
-inline GLboolean QOpenGLFunctions_2_1::glIsShader(GLuint shader)
-{
-    return d_2_0_Core->f.IsShader(shader);
-}
-
-inline GLboolean QOpenGLFunctions_2_1::glIsProgram(GLuint program)
-{
-    return d_2_0_Core->f.IsProgram(program);
-}
-
-inline void QOpenGLFunctions_2_1::glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer)
-{
-    d_2_0_Core->f.GetVertexAttribPointerv(index, pname, pointer);
-}
-
-inline void QOpenGLFunctions_2_1::glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetVertexAttribiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
-{
-    d_2_0_Core->f.GetVertexAttribfv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
-{
-    d_2_0_Core->f.GetVertexAttribdv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glGetUniformiv(GLuint program, GLint location, GLint *params)
-{
-    d_2_0_Core->f.GetUniformiv(program, location, params);
-}
-
-inline void QOpenGLFunctions_2_1::glGetUniformfv(GLuint program, GLint location, GLfloat *params)
-{
-    d_2_0_Core->f.GetUniformfv(program, location, params);
-}
-
-inline GLint QOpenGLFunctions_2_1::glGetUniformLocation(GLuint program, const GLchar *name)
-{
-    return d_2_0_Core->f.GetUniformLocation(program, name);
-}
-
-inline void QOpenGLFunctions_2_1::glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
-{
-    d_2_0_Core->f.GetShaderSource(shader, bufSize, length, source);
-}
-
-inline void QOpenGLFunctions_2_1::glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-{
-    d_2_0_Core->f.GetShaderInfoLog(shader, bufSize, length, infoLog);
-}
-
-inline void QOpenGLFunctions_2_1::glGetShaderiv(GLuint shader, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetShaderiv(shader, pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-{
-    d_2_0_Core->f.GetProgramInfoLog(program, bufSize, length, infoLog);
-}
-
-inline void QOpenGLFunctions_2_1::glGetProgramiv(GLuint program, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetProgramiv(program, pname, params);
-}
-
-inline GLint QOpenGLFunctions_2_1::glGetAttribLocation(GLuint program, const GLchar *name)
-{
-    return d_2_0_Core->f.GetAttribLocation(program, name);
-}
-
-inline void QOpenGLFunctions_2_1::glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj)
-{
-    d_2_0_Core->f.GetAttachedShaders(program, maxCount, count, obj);
-}
-
-inline void QOpenGLFunctions_2_1::glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
-{
-    d_2_0_Core->f.GetActiveUniform(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_2_1::glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
-{
-    d_2_0_Core->f.GetActiveAttrib(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_2_1::glEnableVertexAttribArray(GLuint index)
-{
-    d_2_0_Core->f.EnableVertexAttribArray(index);
-}
-
-inline void QOpenGLFunctions_2_1::glDisableVertexAttribArray(GLuint index)
-{
-    d_2_0_Core->f.DisableVertexAttribArray(index);
-}
-
-inline void QOpenGLFunctions_2_1::glDetachShader(GLuint program, GLuint shader)
-{
-    d_2_0_Core->f.DetachShader(program, shader);
-}
-
-inline void QOpenGLFunctions_2_1::glDeleteShader(GLuint shader)
-{
-    d_2_0_Core->f.DeleteShader(shader);
-}
-
-inline void QOpenGLFunctions_2_1::glDeleteProgram(GLuint program)
-{
-    d_2_0_Core->f.DeleteProgram(program);
-}
-
-inline GLuint QOpenGLFunctions_2_1::glCreateShader(GLenum type)
-{
-    return d_2_0_Core->f.CreateShader(type);
-}
-
-inline GLuint QOpenGLFunctions_2_1::glCreateProgram()
-{
-    return d_2_0_Core->f.CreateProgram();
-}
-
-inline void QOpenGLFunctions_2_1::glCompileShader(GLuint shader)
-{
-    d_2_0_Core->f.CompileShader(shader);
-}
-
-inline void QOpenGLFunctions_2_1::glBindAttribLocation(GLuint program, GLuint index, const GLchar *name)
-{
-    d_2_0_Core->f.BindAttribLocation(program, index, name);
-}
-
-inline void QOpenGLFunctions_2_1::glAttachShader(GLuint program, GLuint shader)
-{
-    d_2_0_Core->f.AttachShader(program, shader);
-}
-
-inline void QOpenGLFunctions_2_1::glStencilMaskSeparate(GLenum face, GLuint mask)
-{
-    d_2_0_Core->f.StencilMaskSeparate(face, mask);
-}
-
-inline void QOpenGLFunctions_2_1::glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
-{
-    d_2_0_Core->f.StencilFuncSeparate(face, func, ref, mask);
-}
-
-inline void QOpenGLFunctions_2_1::glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
-{
-    d_2_0_Core->f.StencilOpSeparate(face, sfail, dpfail, dppass);
-}
-
-inline void QOpenGLFunctions_2_1::glDrawBuffers(GLsizei n, const GLenum *bufs)
-{
-    d_2_0_Core->f.DrawBuffers(n, bufs);
-}
-
-inline void QOpenGLFunctions_2_1::glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
-{
-    d_2_0_Core->f.BlendEquationSeparate(modeRGB, modeAlpha);
-}
-
-
-// OpenGL 2.1 core functions
-inline void QOpenGLFunctions_2_1::glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix4x3fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_2_1::glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix3x4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_2_1::glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix4x2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_2_1::glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix2x4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_2_1::glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix3x2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_2_1::glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix2x3fv(location, count, transpose, value);
-}
-
-
-// OpenGL 1.0 deprecated functions
-inline void QOpenGLFunctions_2_1::glTranslatef(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Translatef(x, y, z);
-}
-
-inline void QOpenGLFunctions_2_1::glTranslated(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Translated(x, y, z);
-}
-
-inline void QOpenGLFunctions_2_1::glScalef(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Scalef(x, y, z);
-}
-
-inline void QOpenGLFunctions_2_1::glScaled(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Scaled(x, y, z);
-}
-
-inline void QOpenGLFunctions_2_1::glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Rotatef(angle, x, y, z);
-}
-
-inline void QOpenGLFunctions_2_1::glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Rotated(angle, x, y, z);
-}
-
-inline void QOpenGLFunctions_2_1::glPushMatrix()
-{
-    d_1_0_Deprecated->f.PushMatrix();
-}
-
-inline void QOpenGLFunctions_2_1::glPopMatrix()
-{
-    d_1_0_Deprecated->f.PopMatrix();
-}
-
-inline void QOpenGLFunctions_2_1::glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
-{
-    d_1_0_Deprecated->f.Ortho(left, right, bottom, top, zNear, zFar);
-}
-
-inline void QOpenGLFunctions_2_1::glMultMatrixd(const GLdouble *m)
-{
-    d_1_0_Deprecated->f.MultMatrixd(m);
-}
-
-inline void QOpenGLFunctions_2_1::glMultMatrixf(const GLfloat *m)
-{
-    d_1_0_Deprecated->f.MultMatrixf(m);
-}
-
-inline void QOpenGLFunctions_2_1::glMatrixMode(GLenum mode)
-{
-    d_1_0_Deprecated->f.MatrixMode(mode);
-}
-
-inline void QOpenGLFunctions_2_1::glLoadMatrixd(const GLdouble *m)
-{
-    d_1_0_Deprecated->f.LoadMatrixd(m);
-}
-
-inline void QOpenGLFunctions_2_1::glLoadMatrixf(const GLfloat *m)
-{
-    d_1_0_Deprecated->f.LoadMatrixf(m);
-}
-
-inline void QOpenGLFunctions_2_1::glLoadIdentity()
-{
-    d_1_0_Deprecated->f.LoadIdentity();
-}
-
-inline void QOpenGLFunctions_2_1::glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
-{
-    d_1_0_Deprecated->f.Frustum(left, right, bottom, top, zNear, zFar);
-}
-
-inline GLboolean QOpenGLFunctions_2_1::glIsList(GLuint list)
-{
-    return d_1_0_Deprecated->f.IsList(list);
-}
-
-inline void QOpenGLFunctions_2_1::glGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetTexGeniv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetTexGenfv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
-{
-    d_1_0_Deprecated->f.GetTexGendv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glGetTexEnviv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetTexEnviv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetTexEnvfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glGetPolygonStipple(GLubyte *mask)
-{
-    d_1_0_Deprecated->f.GetPolygonStipple(mask);
-}
-
-inline void QOpenGLFunctions_2_1::glGetPixelMapusv(GLenum map, GLushort *values)
-{
-    d_1_0_Deprecated->f.GetPixelMapusv(map, values);
-}
-
-inline void QOpenGLFunctions_2_1::glGetPixelMapuiv(GLenum map, GLuint *values)
-{
-    d_1_0_Deprecated->f.GetPixelMapuiv(map, values);
-}
-
-inline void QOpenGLFunctions_2_1::glGetPixelMapfv(GLenum map, GLfloat *values)
-{
-    d_1_0_Deprecated->f.GetPixelMapfv(map, values);
-}
-
-inline void QOpenGLFunctions_2_1::glGetMaterialiv(GLenum face, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetMaterialiv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetMaterialfv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glGetMapiv(GLenum target, GLenum query, GLint *v)
-{
-    d_1_0_Deprecated->f.GetMapiv(target, query, v);
-}
-
-inline void QOpenGLFunctions_2_1::glGetMapfv(GLenum target, GLenum query, GLfloat *v)
-{
-    d_1_0_Deprecated->f.GetMapfv(target, query, v);
-}
-
-inline void QOpenGLFunctions_2_1::glGetMapdv(GLenum target, GLenum query, GLdouble *v)
-{
-    d_1_0_Deprecated->f.GetMapdv(target, query, v);
-}
-
-inline void QOpenGLFunctions_2_1::glGetLightiv(GLenum light, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetLightiv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glGetLightfv(GLenum light, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetLightfv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glGetClipPlane(GLenum plane, GLdouble *equation)
-{
-    d_1_0_Deprecated->f.GetClipPlane(plane, equation);
-}
-
-inline void QOpenGLFunctions_2_1::glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Deprecated->f.DrawPixels(width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_2_1::glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
-{
-    d_1_0_Deprecated->f.CopyPixels(x, y, width, height, type);
-}
-
-inline void QOpenGLFunctions_2_1::glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values)
-{
-    d_1_0_Deprecated->f.PixelMapusv(map, mapsize, values);
-}
-
-inline void QOpenGLFunctions_2_1::glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values)
-{
-    d_1_0_Deprecated->f.PixelMapuiv(map, mapsize, values);
-}
-
-inline void QOpenGLFunctions_2_1::glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values)
-{
-    d_1_0_Deprecated->f.PixelMapfv(map, mapsize, values);
-}
-
-inline void QOpenGLFunctions_2_1::glPixelTransferi(GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.PixelTransferi(pname, param);
-}
-
-inline void QOpenGLFunctions_2_1::glPixelTransferf(GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.PixelTransferf(pname, param);
-}
-
-inline void QOpenGLFunctions_2_1::glPixelZoom(GLfloat xfactor, GLfloat yfactor)
-{
-    d_1_0_Deprecated->f.PixelZoom(xfactor, yfactor);
-}
-
-inline void QOpenGLFunctions_2_1::glAlphaFunc(GLenum func, GLfloat ref)
-{
-    d_1_0_Deprecated->f.AlphaFunc(func, ref);
-}
-
-inline void QOpenGLFunctions_2_1::glEvalPoint2(GLint i, GLint j)
-{
-    d_1_0_Deprecated->f.EvalPoint2(i, j);
-}
-
-inline void QOpenGLFunctions_2_1::glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
-{
-    d_1_0_Deprecated->f.EvalMesh2(mode, i1, i2, j1, j2);
-}
-
-inline void QOpenGLFunctions_2_1::glEvalPoint1(GLint i)
-{
-    d_1_0_Deprecated->f.EvalPoint1(i);
-}
-
-inline void QOpenGLFunctions_2_1::glEvalMesh1(GLenum mode, GLint i1, GLint i2)
-{
-    d_1_0_Deprecated->f.EvalMesh1(mode, i1, i2);
-}
-
-inline void QOpenGLFunctions_2_1::glEvalCoord2fv(const GLfloat *u)
-{
-    d_1_0_Deprecated->f.EvalCoord2fv(u);
-}
-
-inline void QOpenGLFunctions_2_1::glEvalCoord2f(GLfloat u, GLfloat v)
-{
-    d_1_0_Deprecated->f.EvalCoord2f(u, v);
-}
-
-inline void QOpenGLFunctions_2_1::glEvalCoord2dv(const GLdouble *u)
-{
-    d_1_0_Deprecated->f.EvalCoord2dv(u);
-}
-
-inline void QOpenGLFunctions_2_1::glEvalCoord2d(GLdouble u, GLdouble v)
-{
-    d_1_0_Deprecated->f.EvalCoord2d(u, v);
-}
-
-inline void QOpenGLFunctions_2_1::glEvalCoord1fv(const GLfloat *u)
-{
-    d_1_0_Deprecated->f.EvalCoord1fv(u);
-}
-
-inline void QOpenGLFunctions_2_1::glEvalCoord1f(GLfloat u)
-{
-    d_1_0_Deprecated->f.EvalCoord1f(u);
-}
-
-inline void QOpenGLFunctions_2_1::glEvalCoord1dv(const GLdouble *u)
-{
-    d_1_0_Deprecated->f.EvalCoord1dv(u);
-}
-
-inline void QOpenGLFunctions_2_1::glEvalCoord1d(GLdouble u)
-{
-    d_1_0_Deprecated->f.EvalCoord1d(u);
-}
-
-inline void QOpenGLFunctions_2_1::glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
-{
-    d_1_0_Deprecated->f.MapGrid2f(un, u1, u2, vn, v1, v2);
-}
-
-inline void QOpenGLFunctions_2_1::glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
-{
-    d_1_0_Deprecated->f.MapGrid2d(un, u1, u2, vn, v1, v2);
-}
-
-inline void QOpenGLFunctions_2_1::glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
-{
-    d_1_0_Deprecated->f.MapGrid1f(un, u1, u2);
-}
-
-inline void QOpenGLFunctions_2_1::glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
-{
-    d_1_0_Deprecated->f.MapGrid1d(un, u1, u2);
-}
-
-inline void QOpenGLFunctions_2_1::glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
-{
-    d_1_0_Deprecated->f.Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
-}
-
-inline void QOpenGLFunctions_2_1::glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
-{
-    d_1_0_Deprecated->f.Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
-}
-
-inline void QOpenGLFunctions_2_1::glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
-{
-    d_1_0_Deprecated->f.Map1f(target, u1, u2, stride, order, points);
-}
-
-inline void QOpenGLFunctions_2_1::glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
-{
-    d_1_0_Deprecated->f.Map1d(target, u1, u2, stride, order, points);
-}
-
-inline void QOpenGLFunctions_2_1::glPushAttrib(GLbitfield mask)
-{
-    d_1_0_Deprecated->f.PushAttrib(mask);
-}
-
-inline void QOpenGLFunctions_2_1::glPopAttrib()
-{
-    d_1_0_Deprecated->f.PopAttrib();
-}
-
-inline void QOpenGLFunctions_2_1::glAccum(GLenum op, GLfloat value)
-{
-    d_1_0_Deprecated->f.Accum(op, value);
-}
-
-inline void QOpenGLFunctions_2_1::glIndexMask(GLuint mask)
-{
-    d_1_0_Deprecated->f.IndexMask(mask);
-}
-
-inline void QOpenGLFunctions_2_1::glClearIndex(GLfloat c)
-{
-    d_1_0_Deprecated->f.ClearIndex(c);
-}
-
-inline void QOpenGLFunctions_2_1::glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Deprecated->f.ClearAccum(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_2_1::glPushName(GLuint name)
-{
-    d_1_0_Deprecated->f.PushName(name);
-}
-
-inline void QOpenGLFunctions_2_1::glPopName()
-{
-    d_1_0_Deprecated->f.PopName();
-}
-
-inline void QOpenGLFunctions_2_1::glPassThrough(GLfloat token)
-{
-    d_1_0_Deprecated->f.PassThrough(token);
-}
-
-inline void QOpenGLFunctions_2_1::glLoadName(GLuint name)
-{
-    d_1_0_Deprecated->f.LoadName(name);
-}
-
-inline void QOpenGLFunctions_2_1::glInitNames()
-{
-    d_1_0_Deprecated->f.InitNames();
-}
-
-inline GLint QOpenGLFunctions_2_1::glRenderMode(GLenum mode)
-{
-    return d_1_0_Deprecated->f.RenderMode(mode);
-}
-
-inline void QOpenGLFunctions_2_1::glSelectBuffer(GLsizei size, GLuint *buffer)
-{
-    d_1_0_Deprecated->f.SelectBuffer(size, buffer);
-}
-
-inline void QOpenGLFunctions_2_1::glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
-{
-    d_1_0_Deprecated->f.FeedbackBuffer(size, type, buffer);
-}
-
-inline void QOpenGLFunctions_2_1::glTexGeniv(GLenum coord, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.TexGeniv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glTexGeni(GLenum coord, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.TexGeni(coord, pname, param);
-}
-
-inline void QOpenGLFunctions_2_1::glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.TexGenfv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glTexGenf(GLenum coord, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.TexGenf(coord, pname, param);
-}
-
-inline void QOpenGLFunctions_2_1::glTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
-{
-    d_1_0_Deprecated->f.TexGendv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glTexGend(GLenum coord, GLenum pname, GLdouble param)
-{
-    d_1_0_Deprecated->f.TexGend(coord, pname, param);
-}
-
-inline void QOpenGLFunctions_2_1::glTexEnviv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.TexEnviv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glTexEnvi(GLenum target, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.TexEnvi(target, pname, param);
-}
-
-inline void QOpenGLFunctions_2_1::glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.TexEnvfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glTexEnvf(GLenum target, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.TexEnvf(target, pname, param);
-}
-
-inline void QOpenGLFunctions_2_1::glShadeModel(GLenum mode)
-{
-    d_1_0_Deprecated->f.ShadeModel(mode);
-}
-
-inline void QOpenGLFunctions_2_1::glPolygonStipple(const GLubyte *mask)
-{
-    d_1_0_Deprecated->f.PolygonStipple(mask);
-}
-
-inline void QOpenGLFunctions_2_1::glMaterialiv(GLenum face, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.Materialiv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glMateriali(GLenum face, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.Materiali(face, pname, param);
-}
-
-inline void QOpenGLFunctions_2_1::glMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.Materialfv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glMaterialf(GLenum face, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.Materialf(face, pname, param);
-}
-
-inline void QOpenGLFunctions_2_1::glLineStipple(GLint factor, GLushort pattern)
-{
-    d_1_0_Deprecated->f.LineStipple(factor, pattern);
-}
-
-inline void QOpenGLFunctions_2_1::glLightModeliv(GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.LightModeliv(pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glLightModeli(GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.LightModeli(pname, param);
-}
-
-inline void QOpenGLFunctions_2_1::glLightModelfv(GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.LightModelfv(pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glLightModelf(GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.LightModelf(pname, param);
-}
-
-inline void QOpenGLFunctions_2_1::glLightiv(GLenum light, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.Lightiv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glLighti(GLenum light, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.Lighti(light, pname, param);
-}
-
-inline void QOpenGLFunctions_2_1::glLightfv(GLenum light, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.Lightfv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glLightf(GLenum light, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.Lightf(light, pname, param);
-}
-
-inline void QOpenGLFunctions_2_1::glFogiv(GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.Fogiv(pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glFogi(GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.Fogi(pname, param);
-}
-
-inline void QOpenGLFunctions_2_1::glFogfv(GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.Fogfv(pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glFogf(GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.Fogf(pname, param);
-}
-
-inline void QOpenGLFunctions_2_1::glColorMaterial(GLenum face, GLenum mode)
-{
-    d_1_0_Deprecated->f.ColorMaterial(face, mode);
-}
-
-inline void QOpenGLFunctions_2_1::glClipPlane(GLenum plane, const GLdouble *equation)
-{
-    d_1_0_Deprecated->f.ClipPlane(plane, equation);
-}
-
-inline void QOpenGLFunctions_2_1::glVertex4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Vertex4sv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
-{
-    d_1_0_Deprecated->f.Vertex4s(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_2_1::glVertex4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Vertex4iv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glVertex4i(GLint x, GLint y, GLint z, GLint w)
-{
-    d_1_0_Deprecated->f.Vertex4i(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_2_1::glVertex4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Vertex4fv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    d_1_0_Deprecated->f.Vertex4f(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_2_1::glVertex4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Vertex4dv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_1_0_Deprecated->f.Vertex4d(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_2_1::glVertex3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Vertex3sv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glVertex3s(GLshort x, GLshort y, GLshort z)
-{
-    d_1_0_Deprecated->f.Vertex3s(x, y, z);
-}
-
-inline void QOpenGLFunctions_2_1::glVertex3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Vertex3iv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glVertex3i(GLint x, GLint y, GLint z)
-{
-    d_1_0_Deprecated->f.Vertex3i(x, y, z);
-}
-
-inline void QOpenGLFunctions_2_1::glVertex3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Vertex3fv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glVertex3f(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Vertex3f(x, y, z);
-}
-
-inline void QOpenGLFunctions_2_1::glVertex3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Vertex3dv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glVertex3d(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Vertex3d(x, y, z);
-}
-
-inline void QOpenGLFunctions_2_1::glVertex2sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Vertex2sv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glVertex2s(GLshort x, GLshort y)
-{
-    d_1_0_Deprecated->f.Vertex2s(x, y);
-}
-
-inline void QOpenGLFunctions_2_1::glVertex2iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Vertex2iv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glVertex2i(GLint x, GLint y)
-{
-    d_1_0_Deprecated->f.Vertex2i(x, y);
-}
-
-inline void QOpenGLFunctions_2_1::glVertex2fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Vertex2fv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glVertex2f(GLfloat x, GLfloat y)
-{
-    d_1_0_Deprecated->f.Vertex2f(x, y);
-}
-
-inline void QOpenGLFunctions_2_1::glVertex2dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Vertex2dv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glVertex2d(GLdouble x, GLdouble y)
-{
-    d_1_0_Deprecated->f.Vertex2d(x, y);
-}
-
-inline void QOpenGLFunctions_2_1::glTexCoord4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord4sv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
-{
-    d_1_0_Deprecated->f.TexCoord4s(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_2_1::glTexCoord4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord4iv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
-{
-    d_1_0_Deprecated->f.TexCoord4i(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_2_1::glTexCoord4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord4fv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
-{
-    d_1_0_Deprecated->f.TexCoord4f(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_2_1::glTexCoord4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord4dv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
-{
-    d_1_0_Deprecated->f.TexCoord4d(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_2_1::glTexCoord3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord3sv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glTexCoord3s(GLshort s, GLshort t, GLshort r)
-{
-    d_1_0_Deprecated->f.TexCoord3s(s, t, r);
-}
-
-inline void QOpenGLFunctions_2_1::glTexCoord3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord3iv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glTexCoord3i(GLint s, GLint t, GLint r)
-{
-    d_1_0_Deprecated->f.TexCoord3i(s, t, r);
-}
-
-inline void QOpenGLFunctions_2_1::glTexCoord3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord3fv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
-{
-    d_1_0_Deprecated->f.TexCoord3f(s, t, r);
-}
-
-inline void QOpenGLFunctions_2_1::glTexCoord3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord3dv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
-{
-    d_1_0_Deprecated->f.TexCoord3d(s, t, r);
-}
-
-inline void QOpenGLFunctions_2_1::glTexCoord2sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord2sv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glTexCoord2s(GLshort s, GLshort t)
-{
-    d_1_0_Deprecated->f.TexCoord2s(s, t);
-}
-
-inline void QOpenGLFunctions_2_1::glTexCoord2iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord2iv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glTexCoord2i(GLint s, GLint t)
-{
-    d_1_0_Deprecated->f.TexCoord2i(s, t);
-}
-
-inline void QOpenGLFunctions_2_1::glTexCoord2fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord2fv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glTexCoord2f(GLfloat s, GLfloat t)
-{
-    d_1_0_Deprecated->f.TexCoord2f(s, t);
-}
-
-inline void QOpenGLFunctions_2_1::glTexCoord2dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord2dv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glTexCoord2d(GLdouble s, GLdouble t)
-{
-    d_1_0_Deprecated->f.TexCoord2d(s, t);
-}
-
-inline void QOpenGLFunctions_2_1::glTexCoord1sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord1sv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glTexCoord1s(GLshort s)
-{
-    d_1_0_Deprecated->f.TexCoord1s(s);
-}
-
-inline void QOpenGLFunctions_2_1::glTexCoord1iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord1iv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glTexCoord1i(GLint s)
-{
-    d_1_0_Deprecated->f.TexCoord1i(s);
-}
-
-inline void QOpenGLFunctions_2_1::glTexCoord1fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord1fv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glTexCoord1f(GLfloat s)
-{
-    d_1_0_Deprecated->f.TexCoord1f(s);
-}
-
-inline void QOpenGLFunctions_2_1::glTexCoord1dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord1dv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glTexCoord1d(GLdouble s)
-{
-    d_1_0_Deprecated->f.TexCoord1d(s);
-}
-
-inline void QOpenGLFunctions_2_1::glRectsv(const GLshort *v1, const GLshort *v2)
-{
-    d_1_0_Deprecated->f.Rectsv(v1, v2);
-}
-
-inline void QOpenGLFunctions_2_1::glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
-{
-    d_1_0_Deprecated->f.Rects(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_2_1::glRectiv(const GLint *v1, const GLint *v2)
-{
-    d_1_0_Deprecated->f.Rectiv(v1, v2);
-}
-
-inline void QOpenGLFunctions_2_1::glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
-{
-    d_1_0_Deprecated->f.Recti(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_2_1::glRectfv(const GLfloat *v1, const GLfloat *v2)
-{
-    d_1_0_Deprecated->f.Rectfv(v1, v2);
-}
-
-inline void QOpenGLFunctions_2_1::glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
-{
-    d_1_0_Deprecated->f.Rectf(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_2_1::glRectdv(const GLdouble *v1, const GLdouble *v2)
-{
-    d_1_0_Deprecated->f.Rectdv(v1, v2);
-}
-
-inline void QOpenGLFunctions_2_1::glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
-{
-    d_1_0_Deprecated->f.Rectd(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_2_1::glRasterPos4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.RasterPos4sv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
-{
-    d_1_0_Deprecated->f.RasterPos4s(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_2_1::glRasterPos4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.RasterPos4iv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
-{
-    d_1_0_Deprecated->f.RasterPos4i(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_2_1::glRasterPos4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.RasterPos4fv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    d_1_0_Deprecated->f.RasterPos4f(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_2_1::glRasterPos4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.RasterPos4dv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_1_0_Deprecated->f.RasterPos4d(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_2_1::glRasterPos3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.RasterPos3sv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glRasterPos3s(GLshort x, GLshort y, GLshort z)
-{
-    d_1_0_Deprecated->f.RasterPos3s(x, y, z);
-}
-
-inline void QOpenGLFunctions_2_1::glRasterPos3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.RasterPos3iv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glRasterPos3i(GLint x, GLint y, GLint z)
-{
-    d_1_0_Deprecated->f.RasterPos3i(x, y, z);
-}
-
-inline void QOpenGLFunctions_2_1::glRasterPos3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.RasterPos3fv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.RasterPos3f(x, y, z);
-}
-
-inline void QOpenGLFunctions_2_1::glRasterPos3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.RasterPos3dv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.RasterPos3d(x, y, z);
-}
-
-inline void QOpenGLFunctions_2_1::glRasterPos2sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.RasterPos2sv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glRasterPos2s(GLshort x, GLshort y)
-{
-    d_1_0_Deprecated->f.RasterPos2s(x, y);
-}
-
-inline void QOpenGLFunctions_2_1::glRasterPos2iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.RasterPos2iv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glRasterPos2i(GLint x, GLint y)
-{
-    d_1_0_Deprecated->f.RasterPos2i(x, y);
-}
-
-inline void QOpenGLFunctions_2_1::glRasterPos2fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.RasterPos2fv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glRasterPos2f(GLfloat x, GLfloat y)
-{
-    d_1_0_Deprecated->f.RasterPos2f(x, y);
-}
-
-inline void QOpenGLFunctions_2_1::glRasterPos2dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.RasterPos2dv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glRasterPos2d(GLdouble x, GLdouble y)
-{
-    d_1_0_Deprecated->f.RasterPos2d(x, y);
-}
-
-inline void QOpenGLFunctions_2_1::glNormal3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Normal3sv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glNormal3s(GLshort nx, GLshort ny, GLshort nz)
-{
-    d_1_0_Deprecated->f.Normal3s(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_2_1::glNormal3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Normal3iv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glNormal3i(GLint nx, GLint ny, GLint nz)
-{
-    d_1_0_Deprecated->f.Normal3i(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_2_1::glNormal3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Normal3fv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
-{
-    d_1_0_Deprecated->f.Normal3f(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_2_1::glNormal3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Normal3dv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
-{
-    d_1_0_Deprecated->f.Normal3d(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_2_1::glNormal3bv(const GLbyte *v)
-{
-    d_1_0_Deprecated->f.Normal3bv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
-{
-    d_1_0_Deprecated->f.Normal3b(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_2_1::glIndexsv(const GLshort *c)
-{
-    d_1_0_Deprecated->f.Indexsv(c);
-}
-
-inline void QOpenGLFunctions_2_1::glIndexs(GLshort c)
-{
-    d_1_0_Deprecated->f.Indexs(c);
-}
-
-inline void QOpenGLFunctions_2_1::glIndexiv(const GLint *c)
-{
-    d_1_0_Deprecated->f.Indexiv(c);
-}
-
-inline void QOpenGLFunctions_2_1::glIndexi(GLint c)
-{
-    d_1_0_Deprecated->f.Indexi(c);
-}
-
-inline void QOpenGLFunctions_2_1::glIndexfv(const GLfloat *c)
-{
-    d_1_0_Deprecated->f.Indexfv(c);
-}
-
-inline void QOpenGLFunctions_2_1::glIndexf(GLfloat c)
-{
-    d_1_0_Deprecated->f.Indexf(c);
-}
-
-inline void QOpenGLFunctions_2_1::glIndexdv(const GLdouble *c)
-{
-    d_1_0_Deprecated->f.Indexdv(c);
-}
-
-inline void QOpenGLFunctions_2_1::glIndexd(GLdouble c)
-{
-    d_1_0_Deprecated->f.Indexd(c);
-}
-
-inline void QOpenGLFunctions_2_1::glEnd()
-{
-    d_1_0_Deprecated->f.End();
-}
-
-inline void QOpenGLFunctions_2_1::glEdgeFlagv(const GLboolean *flag)
-{
-    d_1_0_Deprecated->f.EdgeFlagv(flag);
-}
-
-inline void QOpenGLFunctions_2_1::glEdgeFlag(GLboolean flag)
-{
-    d_1_0_Deprecated->f.EdgeFlag(flag);
-}
-
-inline void QOpenGLFunctions_2_1::glColor4usv(const GLushort *v)
-{
-    d_1_0_Deprecated->f.Color4usv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
-{
-    d_1_0_Deprecated->f.Color4us(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_2_1::glColor4uiv(const GLuint *v)
-{
-    d_1_0_Deprecated->f.Color4uiv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
-{
-    d_1_0_Deprecated->f.Color4ui(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_2_1::glColor4ubv(const GLubyte *v)
-{
-    d_1_0_Deprecated->f.Color4ubv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
-{
-    d_1_0_Deprecated->f.Color4ub(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_2_1::glColor4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Color4sv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
-{
-    d_1_0_Deprecated->f.Color4s(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_2_1::glColor4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Color4iv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
-{
-    d_1_0_Deprecated->f.Color4i(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_2_1::glColor4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Color4fv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Deprecated->f.Color4f(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_2_1::glColor4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Color4dv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
-{
-    d_1_0_Deprecated->f.Color4d(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_2_1::glColor4bv(const GLbyte *v)
-{
-    d_1_0_Deprecated->f.Color4bv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
-{
-    d_1_0_Deprecated->f.Color4b(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_2_1::glColor3usv(const GLushort *v)
-{
-    d_1_0_Deprecated->f.Color3usv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glColor3us(GLushort red, GLushort green, GLushort blue)
-{
-    d_1_0_Deprecated->f.Color3us(red, green, blue);
-}
-
-inline void QOpenGLFunctions_2_1::glColor3uiv(const GLuint *v)
-{
-    d_1_0_Deprecated->f.Color3uiv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glColor3ui(GLuint red, GLuint green, GLuint blue)
-{
-    d_1_0_Deprecated->f.Color3ui(red, green, blue);
-}
-
-inline void QOpenGLFunctions_2_1::glColor3ubv(const GLubyte *v)
-{
-    d_1_0_Deprecated->f.Color3ubv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
-{
-    d_1_0_Deprecated->f.Color3ub(red, green, blue);
-}
-
-inline void QOpenGLFunctions_2_1::glColor3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Color3sv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glColor3s(GLshort red, GLshort green, GLshort blue)
-{
-    d_1_0_Deprecated->f.Color3s(red, green, blue);
-}
-
-inline void QOpenGLFunctions_2_1::glColor3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Color3iv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glColor3i(GLint red, GLint green, GLint blue)
-{
-    d_1_0_Deprecated->f.Color3i(red, green, blue);
-}
-
-inline void QOpenGLFunctions_2_1::glColor3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Color3fv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glColor3f(GLfloat red, GLfloat green, GLfloat blue)
-{
-    d_1_0_Deprecated->f.Color3f(red, green, blue);
-}
-
-inline void QOpenGLFunctions_2_1::glColor3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Color3dv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glColor3d(GLdouble red, GLdouble green, GLdouble blue)
-{
-    d_1_0_Deprecated->f.Color3d(red, green, blue);
-}
-
-inline void QOpenGLFunctions_2_1::glColor3bv(const GLbyte *v)
-{
-    d_1_0_Deprecated->f.Color3bv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glColor3b(GLbyte red, GLbyte green, GLbyte blue)
-{
-    d_1_0_Deprecated->f.Color3b(red, green, blue);
-}
-
-inline void QOpenGLFunctions_2_1::glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
-{
-    d_1_0_Deprecated->f.Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
-}
-
-inline void QOpenGLFunctions_2_1::glBegin(GLenum mode)
-{
-    d_1_0_Deprecated->f.Begin(mode);
-}
-
-inline void QOpenGLFunctions_2_1::glListBase(GLuint base)
-{
-    d_1_0_Deprecated->f.ListBase(base);
-}
-
-inline GLuint QOpenGLFunctions_2_1::glGenLists(GLsizei range)
-{
-    return d_1_0_Deprecated->f.GenLists(range);
-}
-
-inline void QOpenGLFunctions_2_1::glDeleteLists(GLuint list, GLsizei range)
-{
-    d_1_0_Deprecated->f.DeleteLists(list, range);
-}
-
-inline void QOpenGLFunctions_2_1::glCallLists(GLsizei n, GLenum type, const GLvoid *lists)
-{
-    d_1_0_Deprecated->f.CallLists(n, type, lists);
-}
-
-inline void QOpenGLFunctions_2_1::glCallList(GLuint list)
-{
-    d_1_0_Deprecated->f.CallList(list);
-}
-
-inline void QOpenGLFunctions_2_1::glEndList()
-{
-    d_1_0_Deprecated->f.EndList();
-}
-
-inline void QOpenGLFunctions_2_1::glNewList(GLuint list, GLenum mode)
-{
-    d_1_0_Deprecated->f.NewList(list, mode);
-}
-
-
-// OpenGL 1.1 deprecated functions
-inline void QOpenGLFunctions_2_1::glPushClientAttrib(GLbitfield mask)
-{
-    d_1_1_Deprecated->f.PushClientAttrib(mask);
-}
-
-inline void QOpenGLFunctions_2_1::glPopClientAttrib()
-{
-    d_1_1_Deprecated->f.PopClientAttrib();
-}
-
-inline void QOpenGLFunctions_2_1::glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities)
-{
-    d_1_1_Deprecated->f.PrioritizeTextures(n, textures, priorities);
-}
-
-inline GLboolean QOpenGLFunctions_2_1::glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
-{
-    return d_1_1_Deprecated->f.AreTexturesResident(n, textures, residences);
-}
-
-inline void QOpenGLFunctions_2_1::glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.VertexPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_2_1::glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.TexCoordPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_2_1::glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.NormalPointer(type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_2_1::glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.InterleavedArrays(format, stride, pointer);
-}
-
-inline void QOpenGLFunctions_2_1::glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.IndexPointer(type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_2_1::glEnableClientState(GLenum array)
-{
-    d_1_1_Deprecated->f.EnableClientState(array);
-}
-
-inline void QOpenGLFunctions_2_1::glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.EdgeFlagPointer(stride, pointer);
-}
-
-inline void QOpenGLFunctions_2_1::glDisableClientState(GLenum array)
-{
-    d_1_1_Deprecated->f.DisableClientState(array);
-}
-
-inline void QOpenGLFunctions_2_1::glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.ColorPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_2_1::glArrayElement(GLint i)
-{
-    d_1_1_Deprecated->f.ArrayElement(i);
-}
-
-
-// OpenGL 1.2 deprecated functions
-inline void QOpenGLFunctions_2_1::glResetMinmax(GLenum target)
-{
-    d_1_2_Deprecated->f.ResetMinmax(target);
-}
-
-inline void QOpenGLFunctions_2_1::glResetHistogram(GLenum target)
-{
-    d_1_2_Deprecated->f.ResetHistogram(target);
-}
-
-inline void QOpenGLFunctions_2_1::glMinmax(GLenum target, GLenum internalformat, GLboolean sink)
-{
-    d_1_2_Deprecated->f.Minmax(target, internalformat, sink);
-}
-
-inline void QOpenGLFunctions_2_1::glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
-{
-    d_1_2_Deprecated->f.Histogram(target, width, internalformat, sink);
-}
-
-inline void QOpenGLFunctions_2_1::glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetMinmaxParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetMinmaxParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
-{
-    d_1_2_Deprecated->f.GetMinmax(target, reset, format, type, values);
-}
-
-inline void QOpenGLFunctions_2_1::glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetHistogramParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetHistogramParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
-{
-    d_1_2_Deprecated->f.GetHistogram(target, reset, format, type, values);
-}
-
-inline void QOpenGLFunctions_2_1::glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column)
-{
-    d_1_2_Deprecated->f.SeparableFilter2D(target, internalformat, width, height, format, type, row, column);
-}
-
-inline void QOpenGLFunctions_2_1::glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span)
-{
-    d_1_2_Deprecated->f.GetSeparableFilter(target, format, type, row, column, span);
-}
-
-inline void QOpenGLFunctions_2_1::glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetConvolutionParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetConvolutionParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image)
-{
-    d_1_2_Deprecated->f.GetConvolutionFilter(target, format, type, image);
-}
-
-inline void QOpenGLFunctions_2_1::glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_2_Deprecated->f.CopyConvolutionFilter2D(target, internalformat, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_2_1::glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
-{
-    d_1_2_Deprecated->f.CopyConvolutionFilter1D(target, internalformat, x, y, width);
-}
-
-inline void QOpenGLFunctions_2_1::glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glConvolutionParameteri(GLenum target, GLenum pname, GLint params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameteri(target, pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameterf(target, pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image)
-{
-    d_1_2_Deprecated->f.ConvolutionFilter2D(target, internalformat, width, height, format, type, image);
-}
-
-inline void QOpenGLFunctions_2_1::glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image)
-{
-    d_1_2_Deprecated->f.ConvolutionFilter1D(target, internalformat, width, format, type, image);
-}
-
-inline void QOpenGLFunctions_2_1::glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
-{
-    d_1_2_Deprecated->f.CopyColorSubTable(target, start, x, y, width);
-}
-
-inline void QOpenGLFunctions_2_1::glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data)
-{
-    d_1_2_Deprecated->f.ColorSubTable(target, start, count, format, type, data);
-}
-
-inline void QOpenGLFunctions_2_1::glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetColorTableParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetColorTableParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table)
-{
-    d_1_2_Deprecated->f.GetColorTable(target, format, type, table);
-}
-
-inline void QOpenGLFunctions_2_1::glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
-{
-    d_1_2_Deprecated->f.CopyColorTable(target, internalformat, x, y, width);
-}
-
-inline void QOpenGLFunctions_2_1::glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_2_Deprecated->f.ColorTableParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_2_Deprecated->f.ColorTableParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_2_1::glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table)
-{
-    d_1_2_Deprecated->f.ColorTable(target, internalformat, width, format, type, table);
-}
-
-
-// OpenGL 1.3 deprecated functions
-inline void QOpenGLFunctions_2_1::glMultTransposeMatrixd(const GLdouble *m)
-{
-    d_1_3_Deprecated->f.MultTransposeMatrixd(m);
-}
-
-inline void QOpenGLFunctions_2_1::glMultTransposeMatrixf(const GLfloat *m)
-{
-    d_1_3_Deprecated->f.MultTransposeMatrixf(m);
-}
-
-inline void QOpenGLFunctions_2_1::glLoadTransposeMatrixd(const GLdouble *m)
-{
-    d_1_3_Deprecated->f.LoadTransposeMatrixd(m);
-}
-
-inline void QOpenGLFunctions_2_1::glLoadTransposeMatrixf(const GLfloat *m)
-{
-    d_1_3_Deprecated->f.LoadTransposeMatrixf(m);
-}
-
-inline void QOpenGLFunctions_2_1::glMultiTexCoord4sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4sv(target, v);
-}
-
-inline void QOpenGLFunctions_2_1::glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4s(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_2_1::glMultiTexCoord4iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4iv(target, v);
-}
-
-inline void QOpenGLFunctions_2_1::glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4i(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_2_1::glMultiTexCoord4fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4fv(target, v);
-}
-
-inline void QOpenGLFunctions_2_1::glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4f(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_2_1::glMultiTexCoord4dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4dv(target, v);
-}
-
-inline void QOpenGLFunctions_2_1::glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4d(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_2_1::glMultiTexCoord3sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3sv(target, v);
-}
-
-inline void QOpenGLFunctions_2_1::glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3s(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_2_1::glMultiTexCoord3iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3iv(target, v);
-}
-
-inline void QOpenGLFunctions_2_1::glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3i(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_2_1::glMultiTexCoord3fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3fv(target, v);
-}
-
-inline void QOpenGLFunctions_2_1::glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3f(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_2_1::glMultiTexCoord3dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3dv(target, v);
-}
-
-inline void QOpenGLFunctions_2_1::glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3d(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_2_1::glMultiTexCoord2sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2sv(target, v);
-}
-
-inline void QOpenGLFunctions_2_1::glMultiTexCoord2s(GLenum target, GLshort s, GLshort t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2s(target, s, t);
-}
-
-inline void QOpenGLFunctions_2_1::glMultiTexCoord2iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2iv(target, v);
-}
-
-inline void QOpenGLFunctions_2_1::glMultiTexCoord2i(GLenum target, GLint s, GLint t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2i(target, s, t);
-}
-
-inline void QOpenGLFunctions_2_1::glMultiTexCoord2fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2fv(target, v);
-}
-
-inline void QOpenGLFunctions_2_1::glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2f(target, s, t);
-}
-
-inline void QOpenGLFunctions_2_1::glMultiTexCoord2dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2dv(target, v);
-}
-
-inline void QOpenGLFunctions_2_1::glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2d(target, s, t);
-}
-
-inline void QOpenGLFunctions_2_1::glMultiTexCoord1sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1sv(target, v);
-}
-
-inline void QOpenGLFunctions_2_1::glMultiTexCoord1s(GLenum target, GLshort s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1s(target, s);
-}
-
-inline void QOpenGLFunctions_2_1::glMultiTexCoord1iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1iv(target, v);
-}
-
-inline void QOpenGLFunctions_2_1::glMultiTexCoord1i(GLenum target, GLint s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1i(target, s);
-}
-
-inline void QOpenGLFunctions_2_1::glMultiTexCoord1fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1fv(target, v);
-}
-
-inline void QOpenGLFunctions_2_1::glMultiTexCoord1f(GLenum target, GLfloat s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1f(target, s);
-}
-
-inline void QOpenGLFunctions_2_1::glMultiTexCoord1dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1dv(target, v);
-}
-
-inline void QOpenGLFunctions_2_1::glMultiTexCoord1d(GLenum target, GLdouble s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1d(target, s);
-}
-
-inline void QOpenGLFunctions_2_1::glClientActiveTexture(GLenum texture)
-{
-    d_1_3_Deprecated->f.ClientActiveTexture(texture);
-}
-
-
-// OpenGL 1.4 deprecated functions
-inline void QOpenGLFunctions_2_1::glWindowPos3sv(const GLshort *v)
-{
-    d_1_4_Deprecated->f.WindowPos3sv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glWindowPos3s(GLshort x, GLshort y, GLshort z)
-{
-    d_1_4_Deprecated->f.WindowPos3s(x, y, z);
-}
-
-inline void QOpenGLFunctions_2_1::glWindowPos3iv(const GLint *v)
-{
-    d_1_4_Deprecated->f.WindowPos3iv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glWindowPos3i(GLint x, GLint y, GLint z)
-{
-    d_1_4_Deprecated->f.WindowPos3i(x, y, z);
-}
-
-inline void QOpenGLFunctions_2_1::glWindowPos3fv(const GLfloat *v)
-{
-    d_1_4_Deprecated->f.WindowPos3fv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glWindowPos3f(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_4_Deprecated->f.WindowPos3f(x, y, z);
-}
-
-inline void QOpenGLFunctions_2_1::glWindowPos3dv(const GLdouble *v)
-{
-    d_1_4_Deprecated->f.WindowPos3dv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glWindowPos3d(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_4_Deprecated->f.WindowPos3d(x, y, z);
-}
-
-inline void QOpenGLFunctions_2_1::glWindowPos2sv(const GLshort *v)
-{
-    d_1_4_Deprecated->f.WindowPos2sv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glWindowPos2s(GLshort x, GLshort y)
-{
-    d_1_4_Deprecated->f.WindowPos2s(x, y);
-}
-
-inline void QOpenGLFunctions_2_1::glWindowPos2iv(const GLint *v)
-{
-    d_1_4_Deprecated->f.WindowPos2iv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glWindowPos2i(GLint x, GLint y)
-{
-    d_1_4_Deprecated->f.WindowPos2i(x, y);
-}
-
-inline void QOpenGLFunctions_2_1::glWindowPos2fv(const GLfloat *v)
-{
-    d_1_4_Deprecated->f.WindowPos2fv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glWindowPos2f(GLfloat x, GLfloat y)
-{
-    d_1_4_Deprecated->f.WindowPos2f(x, y);
-}
-
-inline void QOpenGLFunctions_2_1::glWindowPos2dv(const GLdouble *v)
-{
-    d_1_4_Deprecated->f.WindowPos2dv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glWindowPos2d(GLdouble x, GLdouble y)
-{
-    d_1_4_Deprecated->f.WindowPos2d(x, y);
-}
-
-inline void QOpenGLFunctions_2_1::glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_4_Deprecated->f.SecondaryColorPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_2_1::glSecondaryColor3usv(const GLushort *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3usv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glSecondaryColor3us(GLushort red, GLushort green, GLushort blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3us(red, green, blue);
-}
-
-inline void QOpenGLFunctions_2_1::glSecondaryColor3uiv(const GLuint *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3uiv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3ui(red, green, blue);
-}
-
-inline void QOpenGLFunctions_2_1::glSecondaryColor3ubv(const GLubyte *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3ubv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3ub(red, green, blue);
-}
-
-inline void QOpenGLFunctions_2_1::glSecondaryColor3sv(const GLshort *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3sv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glSecondaryColor3s(GLshort red, GLshort green, GLshort blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3s(red, green, blue);
-}
-
-inline void QOpenGLFunctions_2_1::glSecondaryColor3iv(const GLint *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3iv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glSecondaryColor3i(GLint red, GLint green, GLint blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3i(red, green, blue);
-}
-
-inline void QOpenGLFunctions_2_1::glSecondaryColor3fv(const GLfloat *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3fv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3f(red, green, blue);
-}
-
-inline void QOpenGLFunctions_2_1::glSecondaryColor3dv(const GLdouble *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3dv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3d(red, green, blue);
-}
-
-inline void QOpenGLFunctions_2_1::glSecondaryColor3bv(const GLbyte *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3bv(v);
-}
-
-inline void QOpenGLFunctions_2_1::glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3b(red, green, blue);
-}
-
-inline void QOpenGLFunctions_2_1::glFogCoordPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_4_Deprecated->f.FogCoordPointer(type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_2_1::glFogCoorddv(const GLdouble *coord)
-{
-    d_1_4_Deprecated->f.FogCoorddv(coord);
-}
-
-inline void QOpenGLFunctions_2_1::glFogCoordd(GLdouble coord)
-{
-    d_1_4_Deprecated->f.FogCoordd(coord);
-}
-
-inline void QOpenGLFunctions_2_1::glFogCoordfv(const GLfloat *coord)
-{
-    d_1_4_Deprecated->f.FogCoordfv(coord);
-}
-
-inline void QOpenGLFunctions_2_1::glFogCoordf(GLfloat coord)
-{
-    d_1_4_Deprecated->f.FogCoordf(coord);
-}
-
-
-// OpenGL 1.5 deprecated functions
-
-// OpenGL 2.0 deprecated functions
-inline void QOpenGLFunctions_2_1::glVertexAttrib4usv(GLuint index, const GLushort *v)
-{
-    d_2_0_Core->f.VertexAttrib4usv(index, v);
-}
-
-inline void QOpenGLFunctions_2_1::glVertexAttrib4uiv(GLuint index, const GLuint *v)
-{
-    d_2_0_Core->f.VertexAttrib4uiv(index, v);
-}
-
-inline void QOpenGLFunctions_2_1::glVertexAttrib4ubv(GLuint index, const GLubyte *v)
-{
-    d_2_0_Core->f.VertexAttrib4ubv(index, v);
-}
-
-inline void QOpenGLFunctions_2_1::glVertexAttrib4sv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib4sv(index, v);
-}
-
-inline void QOpenGLFunctions_2_1::glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
-{
-    d_2_0_Core->f.VertexAttrib4s(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_2_1::glVertexAttrib4iv(GLuint index, const GLint *v)
-{
-    d_2_0_Core->f.VertexAttrib4iv(index, v);
-}
-
-inline void QOpenGLFunctions_2_1::glVertexAttrib4fv(GLuint index, const GLfloat *v)
-{
-    d_2_0_Core->f.VertexAttrib4fv(index, v);
-}
-
-inline void QOpenGLFunctions_2_1::glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    d_2_0_Core->f.VertexAttrib4f(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_2_1::glVertexAttrib4dv(GLuint index, const GLdouble *v)
-{
-    d_2_0_Core->f.VertexAttrib4dv(index, v);
-}
-
-inline void QOpenGLFunctions_2_1::glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_2_0_Core->f.VertexAttrib4d(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_2_1::glVertexAttrib4bv(GLuint index, const GLbyte *v)
-{
-    d_2_0_Core->f.VertexAttrib4bv(index, v);
-}
-
-inline void QOpenGLFunctions_2_1::glVertexAttrib4Nusv(GLuint index, const GLushort *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nusv(index, v);
-}
-
-inline void QOpenGLFunctions_2_1::glVertexAttrib4Nuiv(GLuint index, const GLuint *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nuiv(index, v);
-}
-
-inline void QOpenGLFunctions_2_1::glVertexAttrib4Nubv(GLuint index, const GLubyte *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nubv(index, v);
-}
-
-inline void QOpenGLFunctions_2_1::glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
-{
-    d_2_0_Core->f.VertexAttrib4Nub(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_2_1::glVertexAttrib4Nsv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nsv(index, v);
-}
-
-inline void QOpenGLFunctions_2_1::glVertexAttrib4Niv(GLuint index, const GLint *v)
-{
-    d_2_0_Core->f.VertexAttrib4Niv(index, v);
-}
-
-inline void QOpenGLFunctions_2_1::glVertexAttrib4Nbv(GLuint index, const GLbyte *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nbv(index, v);
-}
-
-inline void QOpenGLFunctions_2_1::glVertexAttrib3sv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib3sv(index, v);
-}
-
-inline void QOpenGLFunctions_2_1::glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
-{
-    d_2_0_Core->f.VertexAttrib3s(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_2_1::glVertexAttrib3fv(GLuint index, const GLfloat *v)
-{
-    d_2_0_Core->f.VertexAttrib3fv(index, v);
-}
-
-inline void QOpenGLFunctions_2_1::glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
-{
-    d_2_0_Core->f.VertexAttrib3f(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_2_1::glVertexAttrib3dv(GLuint index, const GLdouble *v)
-{
-    d_2_0_Core->f.VertexAttrib3dv(index, v);
-}
-
-inline void QOpenGLFunctions_2_1::glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
-{
-    d_2_0_Core->f.VertexAttrib3d(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_2_1::glVertexAttrib2sv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib2sv(index, v);
-}
-
-inline void QOpenGLFunctions_2_1::glVertexAttrib2s(GLuint index, GLshort x, GLshort y)
-{
-    d_2_0_Core->f.VertexAttrib2s(index, x, y);
-}
-
-inline void QOpenGLFunctions_2_1::glVertexAttrib2fv(GLuint index, const GLfloat *v)
-{
-    d_2_0_Core->f.VertexAttrib2fv(index, v);
-}
-
-inline void QOpenGLFunctions_2_1::glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
-{
-    d_2_0_Core->f.VertexAttrib2f(index, x, y);
-}
-
-inline void QOpenGLFunctions_2_1::glVertexAttrib2dv(GLuint index, const GLdouble *v)
-{
-    d_2_0_Core->f.VertexAttrib2dv(index, v);
-}
-
-inline void QOpenGLFunctions_2_1::glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
-{
-    d_2_0_Core->f.VertexAttrib2d(index, x, y);
-}
-
-inline void QOpenGLFunctions_2_1::glVertexAttrib1sv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib1sv(index, v);
-}
-
-inline void QOpenGLFunctions_2_1::glVertexAttrib1s(GLuint index, GLshort x)
-{
-    d_2_0_Core->f.VertexAttrib1s(index, x);
-}
-
-inline void QOpenGLFunctions_2_1::glVertexAttrib1fv(GLuint index, const GLfloat *v)
-{
-    d_2_0_Core->f.VertexAttrib1fv(index, v);
-}
-
-inline void QOpenGLFunctions_2_1::glVertexAttrib1f(GLuint index, GLfloat x)
-{
-    d_2_0_Core->f.VertexAttrib1f(index, x);
-}
-
-inline void QOpenGLFunctions_2_1::glVertexAttrib1dv(GLuint index, const GLdouble *v)
-{
-    d_2_0_Core->f.VertexAttrib1dv(index, v);
-}
-
-inline void QOpenGLFunctions_2_1::glVertexAttrib1d(GLuint index, GLdouble x)
-{
-    d_2_0_Core->f.VertexAttrib1d(index, x);
-}
-
-
-// OpenGL 2.1 deprecated functions
-
-
-QT_END_NAMESPACE
-
-#endif // QT_NO_OPENGL && !QT_OPENGL_ES_2
-
-#endif
diff --git a/src/gui/opengl/qopenglfunctions_3_0.cpp b/src/gui/opengl/qopenglfunctions_3_0.cpp
deleted file mode 100644
index 7d0e900659..0000000000
--- a/src/gui/opengl/qopenglfunctions_3_0.cpp
+++ /dev/null
@@ -1,246 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#include "qopenglfunctions_3_0.h"
-#include "qopenglcontext.h"
-
-QT_BEGIN_NAMESPACE
-
-/*!
-    \class QOpenGLFunctions_3_0
-    \inmodule QtGui
-    \since 5.1
-    \wrapper
-    \brief The QOpenGLFunctions_3_0 class provides all functions for OpenGL 3.0 specification.
-
-    This class is a wrapper for functions from OpenGL 3.0 specification.
-    See reference pages on \l {http://www.opengl.org/sdk/docs/}{opengl.org}
-    for function documentation.
-
-    \sa QAbstractOpenGLFunctions
-*/
-
-QOpenGLFunctions_3_0::QOpenGLFunctions_3_0()
- : QAbstractOpenGLFunctions()
- , d_1_0_Core(nullptr)
- , d_1_1_Core(nullptr)
- , d_1_2_Core(nullptr)
- , d_1_3_Core(nullptr)
- , d_1_4_Core(nullptr)
- , d_1_5_Core(nullptr)
- , d_2_0_Core(nullptr)
- , d_2_1_Core(nullptr)
- , d_3_0_Core(nullptr)
- , d_1_0_Deprecated(nullptr)
- , d_1_1_Deprecated(nullptr)
- , d_1_2_Deprecated(nullptr)
- , d_1_3_Deprecated(nullptr)
- , d_1_4_Deprecated(nullptr)
- , m_reserved_2_0_Deprecated(nullptr)
- , m_reserved_3_0_Deprecated(nullptr)
-{
-}
-
-QOpenGLFunctions_3_0::~QOpenGLFunctions_3_0()
-{
-    if (d_1_0_Core) {
-        d_1_0_Core->refs.deref();
-        Q_ASSERT(d_1_0_Core->refs.loadRelaxed());
-    }
-    if (d_1_1_Core) {
-        d_1_1_Core->refs.deref();
-        Q_ASSERT(d_1_1_Core->refs.loadRelaxed());
-    }
-    if (d_1_2_Core) {
-        d_1_2_Core->refs.deref();
-        Q_ASSERT(d_1_2_Core->refs.loadRelaxed());
-    }
-    if (d_1_3_Core) {
-        d_1_3_Core->refs.deref();
-        Q_ASSERT(d_1_3_Core->refs.loadRelaxed());
-    }
-    if (d_1_4_Core) {
-        d_1_4_Core->refs.deref();
-        Q_ASSERT(d_1_4_Core->refs.loadRelaxed());
-    }
-    if (d_1_5_Core) {
-        d_1_5_Core->refs.deref();
-        Q_ASSERT(d_1_5_Core->refs.loadRelaxed());
-    }
-    if (d_2_0_Core) {
-        d_2_0_Core->refs.deref();
-        Q_ASSERT(d_2_0_Core->refs.loadRelaxed());
-    }
-    if (d_2_1_Core) {
-        d_2_1_Core->refs.deref();
-        Q_ASSERT(d_2_1_Core->refs.loadRelaxed());
-    }
-    if (d_3_0_Core) {
-        d_3_0_Core->refs.deref();
-        Q_ASSERT(d_3_0_Core->refs.loadRelaxed());
-    }
-    if (d_1_0_Deprecated) {
-        d_1_0_Deprecated->refs.deref();
-        Q_ASSERT(d_1_0_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_1_Deprecated) {
-        d_1_1_Deprecated->refs.deref();
-        Q_ASSERT(d_1_1_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_2_Deprecated) {
-        d_1_2_Deprecated->refs.deref();
-        Q_ASSERT(d_1_2_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_3_Deprecated) {
-        d_1_3_Deprecated->refs.deref();
-        Q_ASSERT(d_1_3_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_4_Deprecated) {
-        d_1_4_Deprecated->refs.deref();
-        Q_ASSERT(d_1_4_Deprecated->refs.loadRelaxed());
-    }
-}
-
-bool QOpenGLFunctions_3_0::initializeOpenGLFunctions()
-{
-    if ( isInitialized() )
-        return true;
-
-    QOpenGLContext* context = QOpenGLContext::currentContext();
-
-    // If owned by a context object make sure it is current.
-    // Also check that current context is capable of resolving all needed functions
-    if (((owningContext() && owningContext() == context) || !owningContext())
-        && QOpenGLFunctions_3_0::isContextCompatible(context))
-    {
-        // Associate with private implementation, creating if necessary
-        // Function pointers in the backends are resolved at creation time
-        QOpenGLVersionFunctionsBackend* d = nullptr;
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        d_1_3_Core = static_cast<QOpenGLFunctions_1_3_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        d_1_4_Core = static_cast<QOpenGLFunctions_1_4_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        d_1_5_Core = static_cast<QOpenGLFunctions_1_5_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        d_2_0_Core = static_cast<QOpenGLFunctions_2_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        d_2_1_Core = static_cast<QOpenGLFunctions_2_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        d_3_0_Core = static_cast<QOpenGLFunctions_3_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
-        d_1_0_Deprecated = static_cast<QOpenGLFunctions_1_0_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
-        d_1_1_Deprecated = static_cast<QOpenGLFunctions_1_1_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus());
-        d_1_2_Deprecated = static_cast<QOpenGLFunctions_1_2_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus());
-        d_1_3_Deprecated = static_cast<QOpenGLFunctions_1_3_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
-        d_1_4_Deprecated = static_cast<QOpenGLFunctions_1_4_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        QAbstractOpenGLFunctions::initializeOpenGLFunctions();
-    }
-    return isInitialized();
-}
-
-bool QOpenGLFunctions_3_0::isContextCompatible(QOpenGLContext *context)
-{
-    Q_ASSERT(context);
-    QSurfaceFormat f = context->format();
-    const QPair<int, int> v = qMakePair(f.majorVersion(), f.minorVersion());
-    if (v < qMakePair(3, 0))
-        return false;
-
-    if (f.profile() == QSurfaceFormat::CoreProfile)
-        return false;
-
-    return true;
-}
-
-QOpenGLVersionProfile QOpenGLFunctions_3_0::versionProfile()
-{
-    QOpenGLVersionProfile v;
-    v.setVersion(3, 0);
-    return v;
-}
-
-QT_END_NAMESPACE
diff --git a/src/gui/opengl/qopenglfunctions_3_0.h b/src/gui/opengl/qopenglfunctions_3_0.h
deleted file mode 100644
index c592050c24..0000000000
--- a/src/gui/opengl/qopenglfunctions_3_0.h
+++ /dev/null
@@ -1,4173 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#ifndef QOPENGLVERSIONFUNCTIONS_3_0_H
-#define QOPENGLVERSIONFUNCTIONS_3_0_H
-
-#include <QtGui/qtguiglobal.h>
-
-#if !defined(QT_NO_OPENGL) && !defined(QT_OPENGL_ES_2)
-
-#include <QtGui/QOpenGLVersionFunctions>
-#include <QtGui/qopenglcontext.h>
-
-QT_BEGIN_NAMESPACE
-
-class Q_GUI_EXPORT QOpenGLFunctions_3_0 : public QAbstractOpenGLFunctions
-{
-public:
-    QOpenGLFunctions_3_0();
-    ~QOpenGLFunctions_3_0();
-
-    bool initializeOpenGLFunctions() override;
-
-    // OpenGL 1.0 core functions
-    void glViewport(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glDepthRange(GLdouble nearVal, GLdouble farVal);
-    GLboolean glIsEnabled(GLenum cap);
-    void glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params);
-    void glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params);
-    void glGetTexParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
-    const GLubyte * glGetString(GLenum name);
-    void glGetIntegerv(GLenum pname, GLint *params);
-    void glGetFloatv(GLenum pname, GLfloat *params);
-    GLenum glGetError();
-    void glGetDoublev(GLenum pname, GLdouble *params);
-    void glGetBooleanv(GLenum pname, GLboolean *params);
-    void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
-    void glReadBuffer(GLenum mode);
-    void glPixelStorei(GLenum pname, GLint param);
-    void glPixelStoref(GLenum pname, GLfloat param);
-    void glDepthFunc(GLenum func);
-    void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass);
-    void glStencilFunc(GLenum func, GLint ref, GLuint mask);
-    void glLogicOp(GLenum opcode);
-    void glBlendFunc(GLenum sfactor, GLenum dfactor);
-    void glFlush();
-    void glFinish();
-    void glEnable(GLenum cap);
-    void glDisable(GLenum cap);
-    void glDepthMask(GLboolean flag);
-    void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
-    void glStencilMask(GLuint mask);
-    void glClearDepth(GLdouble depth);
-    void glClearStencil(GLint s);
-    void glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glClear(GLbitfield mask);
-    void glDrawBuffer(GLenum mode);
-    void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glTexParameteri(GLenum target, GLenum pname, GLint param);
-    void glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glTexParameterf(GLenum target, GLenum pname, GLfloat param);
-    void glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glPolygonMode(GLenum face, GLenum mode);
-    void glPointSize(GLfloat size);
-    void glLineWidth(GLfloat width);
-    void glHint(GLenum target, GLenum mode);
-    void glFrontFace(GLenum mode);
-    void glCullFace(GLenum mode);
-
-    // OpenGL 1.1 core functions
-    void glIndexubv(const GLubyte *c);
-    void glIndexub(GLubyte c);
-    GLboolean glIsTexture(GLuint texture);
-    void glGenTextures(GLsizei n, GLuint *textures);
-    void glDeleteTextures(GLsizei n, const GLuint *textures);
-    void glBindTexture(GLenum target, GLuint texture);
-    void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
-    void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
-    void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
-    void glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
-    void glPolygonOffset(GLfloat factor, GLfloat units);
-    void glGetPointerv(GLenum pname, GLvoid* *params);
-    void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
-    void glDrawArrays(GLenum mode, GLint first, GLsizei count);
-
-    // OpenGL 1.2 core functions
-    void glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices);
-    void glBlendEquation(GLenum mode);
-    void glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-
-    // OpenGL 1.3 core functions
-    void glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img);
-    void glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glSampleCoverage(GLfloat value, GLboolean invert);
-    void glActiveTexture(GLenum texture);
-
-    // OpenGL 1.4 core functions
-    void glPointParameteriv(GLenum pname, const GLint *params);
-    void glPointParameteri(GLenum pname, GLint param);
-    void glPointParameterfv(GLenum pname, const GLfloat *params);
-    void glPointParameterf(GLenum pname, GLfloat param);
-    void glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount);
-    void glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount);
-    void glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
-
-    // OpenGL 1.5 core functions
-    void glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params);
-    void glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params);
-    GLboolean glUnmapBuffer(GLenum target);
-    GLvoid* glMapBuffer(GLenum target, GLenum access);
-    void glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data);
-    void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data);
-    void glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage);
-    GLboolean glIsBuffer(GLuint buffer);
-    void glGenBuffers(GLsizei n, GLuint *buffers);
-    void glDeleteBuffers(GLsizei n, const GLuint *buffers);
-    void glBindBuffer(GLenum target, GLuint buffer);
-    void glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params);
-    void glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params);
-    void glGetQueryiv(GLenum target, GLenum pname, GLint *params);
-    void glEndQuery(GLenum target);
-    void glBeginQuery(GLenum target, GLuint id);
-    GLboolean glIsQuery(GLuint id);
-    void glDeleteQueries(GLsizei n, const GLuint *ids);
-    void glGenQueries(GLsizei n, GLuint *ids);
-
-    // OpenGL 2.0 core functions
-    void glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer);
-    void glValidateProgram(GLuint program);
-    void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniform4iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform3iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform2iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform1iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform4fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform3fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform2fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform1fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
-    void glUniform3i(GLint location, GLint v0, GLint v1, GLint v2);
-    void glUniform2i(GLint location, GLint v0, GLint v1);
-    void glUniform1i(GLint location, GLint v0);
-    void glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
-    void glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
-    void glUniform2f(GLint location, GLfloat v0, GLfloat v1);
-    void glUniform1f(GLint location, GLfloat v0);
-    void glUseProgram(GLuint program);
-    void glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length);
-    void glLinkProgram(GLuint program);
-    GLboolean glIsShader(GLuint shader);
-    GLboolean glIsProgram(GLuint program);
-    void glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer);
-    void glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params);
-    void glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params);
-    void glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params);
-    void glGetUniformiv(GLuint program, GLint location, GLint *params);
-    void glGetUniformfv(GLuint program, GLint location, GLfloat *params);
-    GLint glGetUniformLocation(GLuint program, const GLchar *name);
-    void glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source);
-    void glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void glGetShaderiv(GLuint shader, GLenum pname, GLint *params);
-    void glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void glGetProgramiv(GLuint program, GLenum pname, GLint *params);
-    GLint glGetAttribLocation(GLuint program, const GLchar *name);
-    void glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj);
-    void glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
-    void glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
-    void glEnableVertexAttribArray(GLuint index);
-    void glDisableVertexAttribArray(GLuint index);
-    void glDetachShader(GLuint program, GLuint shader);
-    void glDeleteShader(GLuint shader);
-    void glDeleteProgram(GLuint program);
-    GLuint glCreateShader(GLenum type);
-    GLuint glCreateProgram();
-    void glCompileShader(GLuint shader);
-    void glBindAttribLocation(GLuint program, GLuint index, const GLchar *name);
-    void glAttachShader(GLuint program, GLuint shader);
-    void glStencilMaskSeparate(GLenum face, GLuint mask);
-    void glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask);
-    void glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);
-    void glDrawBuffers(GLsizei n, const GLenum *bufs);
-    void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha);
-
-    // OpenGL 2.1 core functions
-    void glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-
-    // OpenGL 3.0 core functions
-    GLboolean glIsVertexArray(GLuint array);
-    void glGenVertexArrays(GLsizei n, GLuint *arrays);
-    void glDeleteVertexArrays(GLsizei n, const GLuint *arrays);
-    void glBindVertexArray(GLuint array);
-    void glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length);
-    GLvoid* glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
-    void glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
-    void glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
-    void glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
-    void glGenerateMipmap(GLenum target);
-    void glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params);
-    void glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
-    void glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset);
-    void glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
-    void glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
-    GLenum glCheckFramebufferStatus(GLenum target);
-    void glGenFramebuffers(GLsizei n, GLuint *framebuffers);
-    void glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers);
-    void glBindFramebuffer(GLenum target, GLuint framebuffer);
-    GLboolean glIsFramebuffer(GLuint framebuffer);
-    void glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
-    void glGenRenderbuffers(GLsizei n, GLuint *renderbuffers);
-    void glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers);
-    void glBindRenderbuffer(GLenum target, GLuint renderbuffer);
-    GLboolean glIsRenderbuffer(GLuint renderbuffer);
-    const GLubyte * glGetStringi(GLenum name, GLuint index);
-    void glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
-    void glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value);
-    void glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value);
-    void glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value);
-    void glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params);
-    void glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params);
-    void glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params);
-    void glTexParameterIiv(GLenum target, GLenum pname, const GLint *params);
-    void glUniform4uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform3uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform2uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform1uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
-    void glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2);
-    void glUniform2ui(GLint location, GLuint v0, GLuint v1);
-    void glUniform1ui(GLint location, GLuint v0);
-    GLint glGetFragDataLocation(GLuint program, const GLchar *name);
-    void glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name);
-    void glGetUniformuiv(GLuint program, GLint location, GLuint *params);
-    void glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params);
-    void glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params);
-    void glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glEndConditionalRender();
-    void glBeginConditionalRender(GLuint id, GLenum mode);
-    void glClampColor(GLenum target, GLenum clamp);
-    void glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name);
-    void glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode);
-    void glBindBufferBase(GLenum target, GLuint index, GLuint buffer);
-    void glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
-    void glEndTransformFeedback();
-    void glBeginTransformFeedback(GLenum primitiveMode);
-    GLboolean glIsEnabledi(GLenum target, GLuint index);
-    void glDisablei(GLenum target, GLuint index);
-    void glEnablei(GLenum target, GLuint index);
-    void glGetIntegeri_v(GLenum target, GLuint index, GLint *data);
-    void glGetBooleani_v(GLenum target, GLuint index, GLboolean *data);
-    void glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a);
-
-    // OpenGL 1.0 deprecated functions
-    void glTranslatef(GLfloat x, GLfloat y, GLfloat z);
-    void glTranslated(GLdouble x, GLdouble y, GLdouble z);
-    void glScalef(GLfloat x, GLfloat y, GLfloat z);
-    void glScaled(GLdouble x, GLdouble y, GLdouble z);
-    void glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
-    void glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
-    void glPushMatrix();
-    void glPopMatrix();
-    void glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
-    void glMultMatrixd(const GLdouble *m);
-    void glMultMatrixf(const GLfloat *m);
-    void glMatrixMode(GLenum mode);
-    void glLoadMatrixd(const GLdouble *m);
-    void glLoadMatrixf(const GLfloat *m);
-    void glLoadIdentity();
-    void glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
-    GLboolean glIsList(GLuint list);
-    void glGetTexGeniv(GLenum coord, GLenum pname, GLint *params);
-    void glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params);
-    void glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params);
-    void glGetTexEnviv(GLenum target, GLenum pname, GLint *params);
-    void glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetPolygonStipple(GLubyte *mask);
-    void glGetPixelMapusv(GLenum map, GLushort *values);
-    void glGetPixelMapuiv(GLenum map, GLuint *values);
-    void glGetPixelMapfv(GLenum map, GLfloat *values);
-    void glGetMaterialiv(GLenum face, GLenum pname, GLint *params);
-    void glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params);
-    void glGetMapiv(GLenum target, GLenum query, GLint *v);
-    void glGetMapfv(GLenum target, GLenum query, GLfloat *v);
-    void glGetMapdv(GLenum target, GLenum query, GLdouble *v);
-    void glGetLightiv(GLenum light, GLenum pname, GLint *params);
-    void glGetLightfv(GLenum light, GLenum pname, GLfloat *params);
-    void glGetClipPlane(GLenum plane, GLdouble *equation);
-    void glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
-    void glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
-    void glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values);
-    void glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values);
-    void glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values);
-    void glPixelTransferi(GLenum pname, GLint param);
-    void glPixelTransferf(GLenum pname, GLfloat param);
-    void glPixelZoom(GLfloat xfactor, GLfloat yfactor);
-    void glAlphaFunc(GLenum func, GLfloat ref);
-    void glEvalPoint2(GLint i, GLint j);
-    void glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
-    void glEvalPoint1(GLint i);
-    void glEvalMesh1(GLenum mode, GLint i1, GLint i2);
-    void glEvalCoord2fv(const GLfloat *u);
-    void glEvalCoord2f(GLfloat u, GLfloat v);
-    void glEvalCoord2dv(const GLdouble *u);
-    void glEvalCoord2d(GLdouble u, GLdouble v);
-    void glEvalCoord1fv(const GLfloat *u);
-    void glEvalCoord1f(GLfloat u);
-    void glEvalCoord1dv(const GLdouble *u);
-    void glEvalCoord1d(GLdouble u);
-    void glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
-    void glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
-    void glMapGrid1f(GLint un, GLfloat u1, GLfloat u2);
-    void glMapGrid1d(GLint un, GLdouble u1, GLdouble u2);
-    void glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);
-    void glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);
-    void glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);
-    void glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);
-    void glPushAttrib(GLbitfield mask);
-    void glPopAttrib();
-    void glAccum(GLenum op, GLfloat value);
-    void glIndexMask(GLuint mask);
-    void glClearIndex(GLfloat c);
-    void glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glPushName(GLuint name);
-    void glPopName();
-    void glPassThrough(GLfloat token);
-    void glLoadName(GLuint name);
-    void glInitNames();
-    GLint glRenderMode(GLenum mode);
-    void glSelectBuffer(GLsizei size, GLuint *buffer);
-    void glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer);
-    void glTexGeniv(GLenum coord, GLenum pname, const GLint *params);
-    void glTexGeni(GLenum coord, GLenum pname, GLint param);
-    void glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params);
-    void glTexGenf(GLenum coord, GLenum pname, GLfloat param);
-    void glTexGendv(GLenum coord, GLenum pname, const GLdouble *params);
-    void glTexGend(GLenum coord, GLenum pname, GLdouble param);
-    void glTexEnviv(GLenum target, GLenum pname, const GLint *params);
-    void glTexEnvi(GLenum target, GLenum pname, GLint param);
-    void glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glTexEnvf(GLenum target, GLenum pname, GLfloat param);
-    void glShadeModel(GLenum mode);
-    void glPolygonStipple(const GLubyte *mask);
-    void glMaterialiv(GLenum face, GLenum pname, const GLint *params);
-    void glMateriali(GLenum face, GLenum pname, GLint param);
-    void glMaterialfv(GLenum face, GLenum pname, const GLfloat *params);
-    void glMaterialf(GLenum face, GLenum pname, GLfloat param);
-    void glLineStipple(GLint factor, GLushort pattern);
-    void glLightModeliv(GLenum pname, const GLint *params);
-    void glLightModeli(GLenum pname, GLint param);
-    void glLightModelfv(GLenum pname, const GLfloat *params);
-    void glLightModelf(GLenum pname, GLfloat param);
-    void glLightiv(GLenum light, GLenum pname, const GLint *params);
-    void glLighti(GLenum light, GLenum pname, GLint param);
-    void glLightfv(GLenum light, GLenum pname, const GLfloat *params);
-    void glLightf(GLenum light, GLenum pname, GLfloat param);
-    void glFogiv(GLenum pname, const GLint *params);
-    void glFogi(GLenum pname, GLint param);
-    void glFogfv(GLenum pname, const GLfloat *params);
-    void glFogf(GLenum pname, GLfloat param);
-    void glColorMaterial(GLenum face, GLenum mode);
-    void glClipPlane(GLenum plane, const GLdouble *equation);
-    void glVertex4sv(const GLshort *v);
-    void glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w);
-    void glVertex4iv(const GLint *v);
-    void glVertex4i(GLint x, GLint y, GLint z, GLint w);
-    void glVertex4fv(const GLfloat *v);
-    void glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void glVertex4dv(const GLdouble *v);
-    void glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glVertex3sv(const GLshort *v);
-    void glVertex3s(GLshort x, GLshort y, GLshort z);
-    void glVertex3iv(const GLint *v);
-    void glVertex3i(GLint x, GLint y, GLint z);
-    void glVertex3fv(const GLfloat *v);
-    void glVertex3f(GLfloat x, GLfloat y, GLfloat z);
-    void glVertex3dv(const GLdouble *v);
-    void glVertex3d(GLdouble x, GLdouble y, GLdouble z);
-    void glVertex2sv(const GLshort *v);
-    void glVertex2s(GLshort x, GLshort y);
-    void glVertex2iv(const GLint *v);
-    void glVertex2i(GLint x, GLint y);
-    void glVertex2fv(const GLfloat *v);
-    void glVertex2f(GLfloat x, GLfloat y);
-    void glVertex2dv(const GLdouble *v);
-    void glVertex2d(GLdouble x, GLdouble y);
-    void glTexCoord4sv(const GLshort *v);
-    void glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q);
-    void glTexCoord4iv(const GLint *v);
-    void glTexCoord4i(GLint s, GLint t, GLint r, GLint q);
-    void glTexCoord4fv(const GLfloat *v);
-    void glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
-    void glTexCoord4dv(const GLdouble *v);
-    void glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q);
-    void glTexCoord3sv(const GLshort *v);
-    void glTexCoord3s(GLshort s, GLshort t, GLshort r);
-    void glTexCoord3iv(const GLint *v);
-    void glTexCoord3i(GLint s, GLint t, GLint r);
-    void glTexCoord3fv(const GLfloat *v);
-    void glTexCoord3f(GLfloat s, GLfloat t, GLfloat r);
-    void glTexCoord3dv(const GLdouble *v);
-    void glTexCoord3d(GLdouble s, GLdouble t, GLdouble r);
-    void glTexCoord2sv(const GLshort *v);
-    void glTexCoord2s(GLshort s, GLshort t);
-    void glTexCoord2iv(const GLint *v);
-    void glTexCoord2i(GLint s, GLint t);
-    void glTexCoord2fv(const GLfloat *v);
-    void glTexCoord2f(GLfloat s, GLfloat t);
-    void glTexCoord2dv(const GLdouble *v);
-    void glTexCoord2d(GLdouble s, GLdouble t);
-    void glTexCoord1sv(const GLshort *v);
-    void glTexCoord1s(GLshort s);
-    void glTexCoord1iv(const GLint *v);
-    void glTexCoord1i(GLint s);
-    void glTexCoord1fv(const GLfloat *v);
-    void glTexCoord1f(GLfloat s);
-    void glTexCoord1dv(const GLdouble *v);
-    void glTexCoord1d(GLdouble s);
-    void glRectsv(const GLshort *v1, const GLshort *v2);
-    void glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
-    void glRectiv(const GLint *v1, const GLint *v2);
-    void glRecti(GLint x1, GLint y1, GLint x2, GLint y2);
-    void glRectfv(const GLfloat *v1, const GLfloat *v2);
-    void glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
-    void glRectdv(const GLdouble *v1, const GLdouble *v2);
-    void glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
-    void glRasterPos4sv(const GLshort *v);
-    void glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w);
-    void glRasterPos4iv(const GLint *v);
-    void glRasterPos4i(GLint x, GLint y, GLint z, GLint w);
-    void glRasterPos4fv(const GLfloat *v);
-    void glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void glRasterPos4dv(const GLdouble *v);
-    void glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glRasterPos3sv(const GLshort *v);
-    void glRasterPos3s(GLshort x, GLshort y, GLshort z);
-    void glRasterPos3iv(const GLint *v);
-    void glRasterPos3i(GLint x, GLint y, GLint z);
-    void glRasterPos3fv(const GLfloat *v);
-    void glRasterPos3f(GLfloat x, GLfloat y, GLfloat z);
-    void glRasterPos3dv(const GLdouble *v);
-    void glRasterPos3d(GLdouble x, GLdouble y, GLdouble z);
-    void glRasterPos2sv(const GLshort *v);
-    void glRasterPos2s(GLshort x, GLshort y);
-    void glRasterPos2iv(const GLint *v);
-    void glRasterPos2i(GLint x, GLint y);
-    void glRasterPos2fv(const GLfloat *v);
-    void glRasterPos2f(GLfloat x, GLfloat y);
-    void glRasterPos2dv(const GLdouble *v);
-    void glRasterPos2d(GLdouble x, GLdouble y);
-    void glNormal3sv(const GLshort *v);
-    void glNormal3s(GLshort nx, GLshort ny, GLshort nz);
-    void glNormal3iv(const GLint *v);
-    void glNormal3i(GLint nx, GLint ny, GLint nz);
-    void glNormal3fv(const GLfloat *v);
-    void glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz);
-    void glNormal3dv(const GLdouble *v);
-    void glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz);
-    void glNormal3bv(const GLbyte *v);
-    void glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz);
-    void glIndexsv(const GLshort *c);
-    void glIndexs(GLshort c);
-    void glIndexiv(const GLint *c);
-    void glIndexi(GLint c);
-    void glIndexfv(const GLfloat *c);
-    void glIndexf(GLfloat c);
-    void glIndexdv(const GLdouble *c);
-    void glIndexd(GLdouble c);
-    void glEnd();
-    void glEdgeFlagv(const GLboolean *flag);
-    void glEdgeFlag(GLboolean flag);
-    void glColor4usv(const GLushort *v);
-    void glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha);
-    void glColor4uiv(const GLuint *v);
-    void glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha);
-    void glColor4ubv(const GLubyte *v);
-    void glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
-    void glColor4sv(const GLshort *v);
-    void glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha);
-    void glColor4iv(const GLint *v);
-    void glColor4i(GLint red, GLint green, GLint blue, GLint alpha);
-    void glColor4fv(const GLfloat *v);
-    void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glColor4dv(const GLdouble *v);
-    void glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
-    void glColor4bv(const GLbyte *v);
-    void glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
-    void glColor3usv(const GLushort *v);
-    void glColor3us(GLushort red, GLushort green, GLushort blue);
-    void glColor3uiv(const GLuint *v);
-    void glColor3ui(GLuint red, GLuint green, GLuint blue);
-    void glColor3ubv(const GLubyte *v);
-    void glColor3ub(GLubyte red, GLubyte green, GLubyte blue);
-    void glColor3sv(const GLshort *v);
-    void glColor3s(GLshort red, GLshort green, GLshort blue);
-    void glColor3iv(const GLint *v);
-    void glColor3i(GLint red, GLint green, GLint blue);
-    void glColor3fv(const GLfloat *v);
-    void glColor3f(GLfloat red, GLfloat green, GLfloat blue);
-    void glColor3dv(const GLdouble *v);
-    void glColor3d(GLdouble red, GLdouble green, GLdouble blue);
-    void glColor3bv(const GLbyte *v);
-    void glColor3b(GLbyte red, GLbyte green, GLbyte blue);
-    void glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap);
-    void glBegin(GLenum mode);
-    void glListBase(GLuint base);
-    GLuint glGenLists(GLsizei range);
-    void glDeleteLists(GLuint list, GLsizei range);
-    void glCallLists(GLsizei n, GLenum type, const GLvoid *lists);
-    void glCallList(GLuint list);
-    void glEndList();
-    void glNewList(GLuint list, GLenum mode);
-
-    // OpenGL 1.1 deprecated functions
-    void glPushClientAttrib(GLbitfield mask);
-    void glPopClientAttrib();
-    void glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities);
-    GLboolean glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences);
-    void glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer);
-    void glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glEnableClientState(GLenum array);
-    void glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer);
-    void glDisableClientState(GLenum array);
-    void glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glArrayElement(GLint i);
-
-    // OpenGL 1.2 deprecated functions
-    void glResetMinmax(GLenum target);
-    void glResetHistogram(GLenum target);
-    void glMinmax(GLenum target, GLenum internalformat, GLboolean sink);
-    void glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink);
-    void glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
-    void glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
-    void glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column);
-    void glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span);
-    void glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image);
-    void glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
-    void glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glConvolutionParameteri(GLenum target, GLenum pname, GLint params);
-    void glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params);
-    void glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image);
-    void glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image);
-    void glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width);
-    void glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data);
-    void glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table);
-    void glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
-    void glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table);
-
-    // OpenGL 1.3 deprecated functions
-    void glMultTransposeMatrixd(const GLdouble *m);
-    void glMultTransposeMatrixf(const GLfloat *m);
-    void glLoadTransposeMatrixd(const GLdouble *m);
-    void glLoadTransposeMatrixf(const GLfloat *m);
-    void glMultiTexCoord4sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);
-    void glMultiTexCoord4iv(GLenum target, const GLint *v);
-    void glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q);
-    void glMultiTexCoord4fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
-    void glMultiTexCoord4dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
-    void glMultiTexCoord3sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r);
-    void glMultiTexCoord3iv(GLenum target, const GLint *v);
-    void glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r);
-    void glMultiTexCoord3fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r);
-    void glMultiTexCoord3dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r);
-    void glMultiTexCoord2sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord2s(GLenum target, GLshort s, GLshort t);
-    void glMultiTexCoord2iv(GLenum target, const GLint *v);
-    void glMultiTexCoord2i(GLenum target, GLint s, GLint t);
-    void glMultiTexCoord2fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t);
-    void glMultiTexCoord2dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t);
-    void glMultiTexCoord1sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord1s(GLenum target, GLshort s);
-    void glMultiTexCoord1iv(GLenum target, const GLint *v);
-    void glMultiTexCoord1i(GLenum target, GLint s);
-    void glMultiTexCoord1fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord1f(GLenum target, GLfloat s);
-    void glMultiTexCoord1dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord1d(GLenum target, GLdouble s);
-    void glClientActiveTexture(GLenum texture);
-
-    // OpenGL 1.4 deprecated functions
-    void glWindowPos3sv(const GLshort *v);
-    void glWindowPos3s(GLshort x, GLshort y, GLshort z);
-    void glWindowPos3iv(const GLint *v);
-    void glWindowPos3i(GLint x, GLint y, GLint z);
-    void glWindowPos3fv(const GLfloat *v);
-    void glWindowPos3f(GLfloat x, GLfloat y, GLfloat z);
-    void glWindowPos3dv(const GLdouble *v);
-    void glWindowPos3d(GLdouble x, GLdouble y, GLdouble z);
-    void glWindowPos2sv(const GLshort *v);
-    void glWindowPos2s(GLshort x, GLshort y);
-    void glWindowPos2iv(const GLint *v);
-    void glWindowPos2i(GLint x, GLint y);
-    void glWindowPos2fv(const GLfloat *v);
-    void glWindowPos2f(GLfloat x, GLfloat y);
-    void glWindowPos2dv(const GLdouble *v);
-    void glWindowPos2d(GLdouble x, GLdouble y);
-    void glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glSecondaryColor3usv(const GLushort *v);
-    void glSecondaryColor3us(GLushort red, GLushort green, GLushort blue);
-    void glSecondaryColor3uiv(const GLuint *v);
-    void glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue);
-    void glSecondaryColor3ubv(const GLubyte *v);
-    void glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue);
-    void glSecondaryColor3sv(const GLshort *v);
-    void glSecondaryColor3s(GLshort red, GLshort green, GLshort blue);
-    void glSecondaryColor3iv(const GLint *v);
-    void glSecondaryColor3i(GLint red, GLint green, GLint blue);
-    void glSecondaryColor3fv(const GLfloat *v);
-    void glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue);
-    void glSecondaryColor3dv(const GLdouble *v);
-    void glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue);
-    void glSecondaryColor3bv(const GLbyte *v);
-    void glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue);
-    void glFogCoordPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glFogCoorddv(const GLdouble *coord);
-    void glFogCoordd(GLdouble coord);
-    void glFogCoordfv(const GLfloat *coord);
-    void glFogCoordf(GLfloat coord);
-
-    // OpenGL 1.5 deprecated functions
-
-    // OpenGL 2.0 deprecated functions
-    void glVertexAttrib4usv(GLuint index, const GLushort *v);
-    void glVertexAttrib4uiv(GLuint index, const GLuint *v);
-    void glVertexAttrib4ubv(GLuint index, const GLubyte *v);
-    void glVertexAttrib4sv(GLuint index, const GLshort *v);
-    void glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
-    void glVertexAttrib4iv(GLuint index, const GLint *v);
-    void glVertexAttrib4fv(GLuint index, const GLfloat *v);
-    void glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void glVertexAttrib4dv(GLuint index, const GLdouble *v);
-    void glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glVertexAttrib4bv(GLuint index, const GLbyte *v);
-    void glVertexAttrib4Nusv(GLuint index, const GLushort *v);
-    void glVertexAttrib4Nuiv(GLuint index, const GLuint *v);
-    void glVertexAttrib4Nubv(GLuint index, const GLubyte *v);
-    void glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
-    void glVertexAttrib4Nsv(GLuint index, const GLshort *v);
-    void glVertexAttrib4Niv(GLuint index, const GLint *v);
-    void glVertexAttrib4Nbv(GLuint index, const GLbyte *v);
-    void glVertexAttrib3sv(GLuint index, const GLshort *v);
-    void glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z);
-    void glVertexAttrib3fv(GLuint index, const GLfloat *v);
-    void glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z);
-    void glVertexAttrib3dv(GLuint index, const GLdouble *v);
-    void glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z);
-    void glVertexAttrib2sv(GLuint index, const GLshort *v);
-    void glVertexAttrib2s(GLuint index, GLshort x, GLshort y);
-    void glVertexAttrib2fv(GLuint index, const GLfloat *v);
-    void glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y);
-    void glVertexAttrib2dv(GLuint index, const GLdouble *v);
-    void glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y);
-    void glVertexAttrib1sv(GLuint index, const GLshort *v);
-    void glVertexAttrib1s(GLuint index, GLshort x);
-    void glVertexAttrib1fv(GLuint index, const GLfloat *v);
-    void glVertexAttrib1f(GLuint index, GLfloat x);
-    void glVertexAttrib1dv(GLuint index, const GLdouble *v);
-    void glVertexAttrib1d(GLuint index, GLdouble x);
-
-    // OpenGL 2.1 deprecated functions
-
-    // OpenGL 3.0 deprecated functions
-    void glVertexAttribI4usv(GLuint index, const GLushort *v);
-    void glVertexAttribI4ubv(GLuint index, const GLubyte *v);
-    void glVertexAttribI4sv(GLuint index, const GLshort *v);
-    void glVertexAttribI4bv(GLuint index, const GLbyte *v);
-    void glVertexAttribI4uiv(GLuint index, const GLuint *v);
-    void glVertexAttribI3uiv(GLuint index, const GLuint *v);
-    void glVertexAttribI2uiv(GLuint index, const GLuint *v);
-    void glVertexAttribI1uiv(GLuint index, const GLuint *v);
-    void glVertexAttribI4iv(GLuint index, const GLint *v);
-    void glVertexAttribI3iv(GLuint index, const GLint *v);
-    void glVertexAttribI2iv(GLuint index, const GLint *v);
-    void glVertexAttribI1iv(GLuint index, const GLint *v);
-    void glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
-    void glVertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z);
-    void glVertexAttribI2ui(GLuint index, GLuint x, GLuint y);
-    void glVertexAttribI1ui(GLuint index, GLuint x);
-    void glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w);
-    void glVertexAttribI3i(GLuint index, GLint x, GLint y, GLint z);
-    void glVertexAttribI2i(GLuint index, GLint x, GLint y);
-    void glVertexAttribI1i(GLuint index, GLint x);
-
-private:
-    friend class QOpenGLContext;
-
-    static bool isContextCompatible(QOpenGLContext *context);
-    static QOpenGLVersionProfile versionProfile();
-
-    QOpenGLFunctions_1_0_CoreBackend* d_1_0_Core;
-    QOpenGLFunctions_1_1_CoreBackend* d_1_1_Core;
-    QOpenGLFunctions_1_2_CoreBackend* d_1_2_Core;
-    QOpenGLFunctions_1_3_CoreBackend* d_1_3_Core;
-    QOpenGLFunctions_1_4_CoreBackend* d_1_4_Core;
-    QOpenGLFunctions_1_5_CoreBackend* d_1_5_Core;
-    QOpenGLFunctions_2_0_CoreBackend* d_2_0_Core;
-    QOpenGLFunctions_2_1_CoreBackend* d_2_1_Core;
-    QOpenGLFunctions_3_0_CoreBackend* d_3_0_Core;
-    QOpenGLFunctions_1_0_DeprecatedBackend* d_1_0_Deprecated;
-    QOpenGLFunctions_1_1_DeprecatedBackend* d_1_1_Deprecated;
-    QOpenGLFunctions_1_2_DeprecatedBackend* d_1_2_Deprecated;
-    QOpenGLFunctions_1_3_DeprecatedBackend* d_1_3_Deprecated;
-    QOpenGLFunctions_1_4_DeprecatedBackend* d_1_4_Deprecated;
-    void *m_reserved_2_0_Deprecated; // To maintain BC
-    void *m_reserved_3_0_Deprecated; // To maintain BC
-};
-
-// OpenGL 1.0 core functions
-inline void QOpenGLFunctions_3_0::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_0_Core->f.Viewport(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_3_0::glDepthRange(GLdouble nearVal, GLdouble farVal)
-{
-    d_1_0_Core->f.DepthRange(nearVal, farVal);
-}
-
-inline GLboolean QOpenGLFunctions_3_0::glIsEnabled(GLenum cap)
-{
-    return d_1_0_Core->f.IsEnabled(cap);
-}
-
-inline void QOpenGLFunctions_3_0::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetTexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetTexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
-{
-    d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
-}
-
-inline const GLubyte * QOpenGLFunctions_3_0::glGetString(GLenum name)
-{
-    return d_1_0_Core->f.GetString(name);
-}
-
-inline void QOpenGLFunctions_3_0::glGetIntegerv(GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetIntegerv(pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glGetFloatv(GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetFloatv(pname, params);
-}
-
-inline GLenum QOpenGLFunctions_3_0::glGetError()
-{
-    return d_1_0_Core->f.GetError();
-}
-
-inline void QOpenGLFunctions_3_0::glGetDoublev(GLenum pname, GLdouble *params)
-{
-    d_1_0_Core->f.GetDoublev(pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glGetBooleanv(GLenum pname, GLboolean *params)
-{
-    d_1_0_Core->f.GetBooleanv(pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
-{
-    d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_3_0::glReadBuffer(GLenum mode)
-{
-    d_1_0_Core->f.ReadBuffer(mode);
-}
-
-inline void QOpenGLFunctions_3_0::glPixelStorei(GLenum pname, GLint param)
-{
-    d_1_0_Core->f.PixelStorei(pname, param);
-}
-
-inline void QOpenGLFunctions_3_0::glPixelStoref(GLenum pname, GLfloat param)
-{
-    d_1_0_Core->f.PixelStoref(pname, param);
-}
-
-inline void QOpenGLFunctions_3_0::glDepthFunc(GLenum func)
-{
-    d_1_0_Core->f.DepthFunc(func);
-}
-
-inline void QOpenGLFunctions_3_0::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
-{
-    d_1_0_Core->f.StencilOp(fail, zfail, zpass);
-}
-
-inline void QOpenGLFunctions_3_0::glStencilFunc(GLenum func, GLint ref, GLuint mask)
-{
-    d_1_0_Core->f.StencilFunc(func, ref, mask);
-}
-
-inline void QOpenGLFunctions_3_0::glLogicOp(GLenum opcode)
-{
-    d_1_0_Core->f.LogicOp(opcode);
-}
-
-inline void QOpenGLFunctions_3_0::glBlendFunc(GLenum sfactor, GLenum dfactor)
-{
-    d_1_0_Core->f.BlendFunc(sfactor, dfactor);
-}
-
-inline void QOpenGLFunctions_3_0::glFlush()
-{
-    d_1_0_Core->f.Flush();
-}
-
-inline void QOpenGLFunctions_3_0::glFinish()
-{
-    d_1_0_Core->f.Finish();
-}
-
-inline void QOpenGLFunctions_3_0::glEnable(GLenum cap)
-{
-    d_1_0_Core->f.Enable(cap);
-}
-
-inline void QOpenGLFunctions_3_0::glDisable(GLenum cap)
-{
-    d_1_0_Core->f.Disable(cap);
-}
-
-inline void QOpenGLFunctions_3_0::glDepthMask(GLboolean flag)
-{
-    d_1_0_Core->f.DepthMask(flag);
-}
-
-inline void QOpenGLFunctions_3_0::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
-{
-    d_1_0_Core->f.ColorMask(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_3_0::glStencilMask(GLuint mask)
-{
-    d_1_0_Core->f.StencilMask(mask);
-}
-
-inline void QOpenGLFunctions_3_0::glClearDepth(GLdouble depth)
-{
-    d_1_0_Core->f.ClearDepth(depth);
-}
-
-inline void QOpenGLFunctions_3_0::glClearStencil(GLint s)
-{
-    d_1_0_Core->f.ClearStencil(s);
-}
-
-inline void QOpenGLFunctions_3_0::glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Core->f.ClearColor(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_3_0::glClear(GLbitfield mask)
-{
-    d_1_0_Core->f.Clear(mask);
-}
-
-inline void QOpenGLFunctions_3_0::glDrawBuffer(GLenum mode)
-{
-    d_1_0_Core->f.DrawBuffer(mode);
-}
-
-inline void QOpenGLFunctions_3_0::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Core->f.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_3_0::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Core->f.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_3_0::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_0_Core->f.TexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glTexParameteri(GLenum target, GLenum pname, GLint param)
-{
-    d_1_0_Core->f.TexParameteri(target, pname, param);
-}
-
-inline void QOpenGLFunctions_3_0::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Core->f.TexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
-{
-    d_1_0_Core->f.TexParameterf(target, pname, param);
-}
-
-inline void QOpenGLFunctions_3_0::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_0_Core->f.Scissor(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_3_0::glPolygonMode(GLenum face, GLenum mode)
-{
-    d_1_0_Core->f.PolygonMode(face, mode);
-}
-
-inline void QOpenGLFunctions_3_0::glPointSize(GLfloat size)
-{
-    d_1_0_Core->f.PointSize(size);
-}
-
-inline void QOpenGLFunctions_3_0::glLineWidth(GLfloat width)
-{
-    d_1_0_Core->f.LineWidth(width);
-}
-
-inline void QOpenGLFunctions_3_0::glHint(GLenum target, GLenum mode)
-{
-    d_1_0_Core->f.Hint(target, mode);
-}
-
-inline void QOpenGLFunctions_3_0::glFrontFace(GLenum mode)
-{
-    d_1_0_Core->f.FrontFace(mode);
-}
-
-inline void QOpenGLFunctions_3_0::glCullFace(GLenum mode)
-{
-    d_1_0_Core->f.CullFace(mode);
-}
-
-
-// OpenGL 1.1 core functions
-inline void QOpenGLFunctions_3_0::glIndexubv(const GLubyte *c)
-{
-    d_1_1_Deprecated->f.Indexubv(c);
-}
-
-inline void QOpenGLFunctions_3_0::glIndexub(GLubyte c)
-{
-    d_1_1_Deprecated->f.Indexub(c);
-}
-
-inline GLboolean QOpenGLFunctions_3_0::glIsTexture(GLuint texture)
-{
-    return d_1_1_Core->f.IsTexture(texture);
-}
-
-inline void QOpenGLFunctions_3_0::glGenTextures(GLsizei n, GLuint *textures)
-{
-    d_1_1_Core->f.GenTextures(n, textures);
-}
-
-inline void QOpenGLFunctions_3_0::glDeleteTextures(GLsizei n, const GLuint *textures)
-{
-    d_1_1_Core->f.DeleteTextures(n, textures);
-}
-
-inline void QOpenGLFunctions_3_0::glBindTexture(GLenum target, GLuint texture)
-{
-    d_1_1_Core->f.BindTexture(target, texture);
-}
-
-inline void QOpenGLFunctions_3_0::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_1_Core->f.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_3_0::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_1_Core->f.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_3_0::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_1_Core->f.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_3_0::glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
-{
-    d_1_1_Core->f.CopyTexSubImage1D(target, level, xoffset, x, y, width);
-}
-
-inline void QOpenGLFunctions_3_0::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
-{
-    d_1_1_Core->f.CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
-}
-
-inline void QOpenGLFunctions_3_0::glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
-{
-    d_1_1_Core->f.CopyTexImage1D(target, level, internalformat, x, y, width, border);
-}
-
-inline void QOpenGLFunctions_3_0::glPolygonOffset(GLfloat factor, GLfloat units)
-{
-    d_1_1_Core->f.PolygonOffset(factor, units);
-}
-
-inline void QOpenGLFunctions_3_0::glGetPointerv(GLenum pname, GLvoid* *params)
-{
-    d_1_1_Deprecated->f.GetPointerv(pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
-{
-    d_1_1_Core->f.DrawElements(mode, count, type, indices);
-}
-
-inline void QOpenGLFunctions_3_0::glDrawArrays(GLenum mode, GLint first, GLsizei count)
-{
-    d_1_1_Core->f.DrawArrays(mode, first, count);
-}
-
-
-// OpenGL 1.2 core functions
-inline void QOpenGLFunctions_3_0::glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_2_Core->f.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_3_0::glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_2_Core->f.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_3_0::glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_2_Core->f.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_3_0::glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
-{
-    d_1_2_Core->f.DrawRangeElements(mode, start, end, count, type, indices);
-}
-
-inline void QOpenGLFunctions_3_0::glBlendEquation(GLenum mode)
-{
-    d_1_2_Core->f.BlendEquation(mode);
-}
-
-inline void QOpenGLFunctions_3_0::glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_2_Core->f.BlendColor(red, green, blue, alpha);
-}
-
-
-// OpenGL 1.3 core functions
-inline void QOpenGLFunctions_3_0::glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img)
-{
-    d_1_3_Core->f.GetCompressedTexImage(target, level, img);
-}
-
-inline void QOpenGLFunctions_3_0::glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_3_0::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_3_0::glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_3_0::glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_3_0::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_3_0::glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_3_0::glSampleCoverage(GLfloat value, GLboolean invert)
-{
-    d_1_3_Core->f.SampleCoverage(value, invert);
-}
-
-inline void QOpenGLFunctions_3_0::glActiveTexture(GLenum texture)
-{
-    d_1_3_Core->f.ActiveTexture(texture);
-}
-
-
-// OpenGL 1.4 core functions
-inline void QOpenGLFunctions_3_0::glPointParameteriv(GLenum pname, const GLint *params)
-{
-    d_1_4_Core->f.PointParameteriv(pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glPointParameteri(GLenum pname, GLint param)
-{
-    d_1_4_Core->f.PointParameteri(pname, param);
-}
-
-inline void QOpenGLFunctions_3_0::glPointParameterfv(GLenum pname, const GLfloat *params)
-{
-    d_1_4_Core->f.PointParameterfv(pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glPointParameterf(GLenum pname, GLfloat param)
-{
-    d_1_4_Core->f.PointParameterf(pname, param);
-}
-
-inline void QOpenGLFunctions_3_0::glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount)
-{
-    d_1_4_Core->f.MultiDrawElements(mode, count, type, indices, drawcount);
-}
-
-inline void QOpenGLFunctions_3_0::glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
-{
-    d_1_4_Core->f.MultiDrawArrays(mode, first, count, drawcount);
-}
-
-inline void QOpenGLFunctions_3_0::glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
-{
-    d_1_4_Core->f.BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
-}
-
-
-// OpenGL 1.5 core functions
-inline void QOpenGLFunctions_3_0::glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params)
-{
-    d_1_5_Core->f.GetBufferPointerv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetBufferParameteriv(target, pname, params);
-}
-
-inline GLboolean QOpenGLFunctions_3_0::glUnmapBuffer(GLenum target)
-{
-    return d_1_5_Core->f.UnmapBuffer(target);
-}
-
-inline GLvoid* QOpenGLFunctions_3_0::glMapBuffer(GLenum target, GLenum access)
-{
-    return d_1_5_Core->f.MapBuffer(target, access);
-}
-
-inline void QOpenGLFunctions_3_0::glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data)
-{
-    d_1_5_Core->f.GetBufferSubData(target, offset, size, data);
-}
-
-inline void QOpenGLFunctions_3_0::glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data)
-{
-    d_1_5_Core->f.BufferSubData(target, offset, size, data);
-}
-
-inline void QOpenGLFunctions_3_0::glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)
-{
-    d_1_5_Core->f.BufferData(target, size, data, usage);
-}
-
-inline GLboolean QOpenGLFunctions_3_0::glIsBuffer(GLuint buffer)
-{
-    return d_1_5_Core->f.IsBuffer(buffer);
-}
-
-inline void QOpenGLFunctions_3_0::glGenBuffers(GLsizei n, GLuint *buffers)
-{
-    d_1_5_Core->f.GenBuffers(n, buffers);
-}
-
-inline void QOpenGLFunctions_3_0::glDeleteBuffers(GLsizei n, const GLuint *buffers)
-{
-    d_1_5_Core->f.DeleteBuffers(n, buffers);
-}
-
-inline void QOpenGLFunctions_3_0::glBindBuffer(GLenum target, GLuint buffer)
-{
-    d_1_5_Core->f.BindBuffer(target, buffer);
-}
-
-inline void QOpenGLFunctions_3_0::glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
-{
-    d_1_5_Core->f.GetQueryObjectuiv(id, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetQueryObjectiv(id, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glGetQueryiv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetQueryiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glEndQuery(GLenum target)
-{
-    d_1_5_Core->f.EndQuery(target);
-}
-
-inline void QOpenGLFunctions_3_0::glBeginQuery(GLenum target, GLuint id)
-{
-    d_1_5_Core->f.BeginQuery(target, id);
-}
-
-inline GLboolean QOpenGLFunctions_3_0::glIsQuery(GLuint id)
-{
-    return d_1_5_Core->f.IsQuery(id);
-}
-
-inline void QOpenGLFunctions_3_0::glDeleteQueries(GLsizei n, const GLuint *ids)
-{
-    d_1_5_Core->f.DeleteQueries(n, ids);
-}
-
-inline void QOpenGLFunctions_3_0::glGenQueries(GLsizei n, GLuint *ids)
-{
-    d_1_5_Core->f.GenQueries(n, ids);
-}
-
-
-// OpenGL 2.0 core functions
-inline void QOpenGLFunctions_3_0::glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer)
-{
-    d_2_0_Core->f.VertexAttribPointer(index, size, type, normalized, stride, pointer);
-}
-
-inline void QOpenGLFunctions_3_0::glValidateProgram(GLuint program)
-{
-    d_2_0_Core->f.ValidateProgram(program);
-}
-
-inline void QOpenGLFunctions_3_0::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_3_0::glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix3fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_3_0::glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_3_0::glUniform4iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform4iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_0::glUniform3iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform3iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_0::glUniform2iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform2iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_0::glUniform1iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform1iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_0::glUniform4fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform4fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_0::glUniform3fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform3fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_0::glUniform2fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform2fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_0::glUniform1fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform1fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_0::glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
-{
-    d_2_0_Core->f.Uniform4i(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_3_0::glUniform3i(GLint location, GLint v0, GLint v1, GLint v2)
-{
-    d_2_0_Core->f.Uniform3i(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_3_0::glUniform2i(GLint location, GLint v0, GLint v1)
-{
-    d_2_0_Core->f.Uniform2i(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_3_0::glUniform1i(GLint location, GLint v0)
-{
-    d_2_0_Core->f.Uniform1i(location, v0);
-}
-
-inline void QOpenGLFunctions_3_0::glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
-{
-    d_2_0_Core->f.Uniform4f(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_3_0::glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
-{
-    d_2_0_Core->f.Uniform3f(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_3_0::glUniform2f(GLint location, GLfloat v0, GLfloat v1)
-{
-    d_2_0_Core->f.Uniform2f(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_3_0::glUniform1f(GLint location, GLfloat v0)
-{
-    d_2_0_Core->f.Uniform1f(location, v0);
-}
-
-inline void QOpenGLFunctions_3_0::glUseProgram(GLuint program)
-{
-    d_2_0_Core->f.UseProgram(program);
-}
-
-inline void QOpenGLFunctions_3_0::glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length)
-{
-    d_2_0_Core->f.ShaderSource(shader, count, string, length);
-}
-
-inline void QOpenGLFunctions_3_0::glLinkProgram(GLuint program)
-{
-    d_2_0_Core->f.LinkProgram(program);
-}
-
-inline GLboolean QOpenGLFunctions_3_0::glIsShader(GLuint shader)
-{
-    return d_2_0_Core->f.IsShader(shader);
-}
-
-inline GLboolean QOpenGLFunctions_3_0::glIsProgram(GLuint program)
-{
-    return d_2_0_Core->f.IsProgram(program);
-}
-
-inline void QOpenGLFunctions_3_0::glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer)
-{
-    d_2_0_Core->f.GetVertexAttribPointerv(index, pname, pointer);
-}
-
-inline void QOpenGLFunctions_3_0::glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetVertexAttribiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
-{
-    d_2_0_Core->f.GetVertexAttribfv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
-{
-    d_2_0_Core->f.GetVertexAttribdv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glGetUniformiv(GLuint program, GLint location, GLint *params)
-{
-    d_2_0_Core->f.GetUniformiv(program, location, params);
-}
-
-inline void QOpenGLFunctions_3_0::glGetUniformfv(GLuint program, GLint location, GLfloat *params)
-{
-    d_2_0_Core->f.GetUniformfv(program, location, params);
-}
-
-inline GLint QOpenGLFunctions_3_0::glGetUniformLocation(GLuint program, const GLchar *name)
-{
-    return d_2_0_Core->f.GetUniformLocation(program, name);
-}
-
-inline void QOpenGLFunctions_3_0::glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
-{
-    d_2_0_Core->f.GetShaderSource(shader, bufSize, length, source);
-}
-
-inline void QOpenGLFunctions_3_0::glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-{
-    d_2_0_Core->f.GetShaderInfoLog(shader, bufSize, length, infoLog);
-}
-
-inline void QOpenGLFunctions_3_0::glGetShaderiv(GLuint shader, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetShaderiv(shader, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-{
-    d_2_0_Core->f.GetProgramInfoLog(program, bufSize, length, infoLog);
-}
-
-inline void QOpenGLFunctions_3_0::glGetProgramiv(GLuint program, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetProgramiv(program, pname, params);
-}
-
-inline GLint QOpenGLFunctions_3_0::glGetAttribLocation(GLuint program, const GLchar *name)
-{
-    return d_2_0_Core->f.GetAttribLocation(program, name);
-}
-
-inline void QOpenGLFunctions_3_0::glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj)
-{
-    d_2_0_Core->f.GetAttachedShaders(program, maxCount, count, obj);
-}
-
-inline void QOpenGLFunctions_3_0::glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
-{
-    d_2_0_Core->f.GetActiveUniform(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_3_0::glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
-{
-    d_2_0_Core->f.GetActiveAttrib(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_3_0::glEnableVertexAttribArray(GLuint index)
-{
-    d_2_0_Core->f.EnableVertexAttribArray(index);
-}
-
-inline void QOpenGLFunctions_3_0::glDisableVertexAttribArray(GLuint index)
-{
-    d_2_0_Core->f.DisableVertexAttribArray(index);
-}
-
-inline void QOpenGLFunctions_3_0::glDetachShader(GLuint program, GLuint shader)
-{
-    d_2_0_Core->f.DetachShader(program, shader);
-}
-
-inline void QOpenGLFunctions_3_0::glDeleteShader(GLuint shader)
-{
-    d_2_0_Core->f.DeleteShader(shader);
-}
-
-inline void QOpenGLFunctions_3_0::glDeleteProgram(GLuint program)
-{
-    d_2_0_Core->f.DeleteProgram(program);
-}
-
-inline GLuint QOpenGLFunctions_3_0::glCreateShader(GLenum type)
-{
-    return d_2_0_Core->f.CreateShader(type);
-}
-
-inline GLuint QOpenGLFunctions_3_0::glCreateProgram()
-{
-    return d_2_0_Core->f.CreateProgram();
-}
-
-inline void QOpenGLFunctions_3_0::glCompileShader(GLuint shader)
-{
-    d_2_0_Core->f.CompileShader(shader);
-}
-
-inline void QOpenGLFunctions_3_0::glBindAttribLocation(GLuint program, GLuint index, const GLchar *name)
-{
-    d_2_0_Core->f.BindAttribLocation(program, index, name);
-}
-
-inline void QOpenGLFunctions_3_0::glAttachShader(GLuint program, GLuint shader)
-{
-    d_2_0_Core->f.AttachShader(program, shader);
-}
-
-inline void QOpenGLFunctions_3_0::glStencilMaskSeparate(GLenum face, GLuint mask)
-{
-    d_2_0_Core->f.StencilMaskSeparate(face, mask);
-}
-
-inline void QOpenGLFunctions_3_0::glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
-{
-    d_2_0_Core->f.StencilFuncSeparate(face, func, ref, mask);
-}
-
-inline void QOpenGLFunctions_3_0::glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
-{
-    d_2_0_Core->f.StencilOpSeparate(face, sfail, dpfail, dppass);
-}
-
-inline void QOpenGLFunctions_3_0::glDrawBuffers(GLsizei n, const GLenum *bufs)
-{
-    d_2_0_Core->f.DrawBuffers(n, bufs);
-}
-
-inline void QOpenGLFunctions_3_0::glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
-{
-    d_2_0_Core->f.BlendEquationSeparate(modeRGB, modeAlpha);
-}
-
-
-// OpenGL 2.1 core functions
-inline void QOpenGLFunctions_3_0::glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix4x3fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_3_0::glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix3x4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_3_0::glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix4x2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_3_0::glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix2x4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_3_0::glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix3x2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_3_0::glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix2x3fv(location, count, transpose, value);
-}
-
-
-// OpenGL 3.0 core functions
-inline GLboolean QOpenGLFunctions_3_0::glIsVertexArray(GLuint array)
-{
-    return d_3_0_Core->f.IsVertexArray(array);
-}
-
-inline void QOpenGLFunctions_3_0::glGenVertexArrays(GLsizei n, GLuint *arrays)
-{
-    d_3_0_Core->f.GenVertexArrays(n, arrays);
-}
-
-inline void QOpenGLFunctions_3_0::glDeleteVertexArrays(GLsizei n, const GLuint *arrays)
-{
-    d_3_0_Core->f.DeleteVertexArrays(n, arrays);
-}
-
-inline void QOpenGLFunctions_3_0::glBindVertexArray(GLuint array)
-{
-    d_3_0_Core->f.BindVertexArray(array);
-}
-
-inline void QOpenGLFunctions_3_0::glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
-{
-    d_3_0_Core->f.FlushMappedBufferRange(target, offset, length);
-}
-
-inline GLvoid* QOpenGLFunctions_3_0::glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
-{
-    return d_3_0_Core->f.MapBufferRange(target, offset, length, access);
-}
-
-inline void QOpenGLFunctions_3_0::glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
-{
-    d_3_0_Core->f.FramebufferTextureLayer(target, attachment, texture, level, layer);
-}
-
-inline void QOpenGLFunctions_3_0::glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    d_3_0_Core->f.RenderbufferStorageMultisample(target, samples, internalformat, width, height);
-}
-
-inline void QOpenGLFunctions_3_0::glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
-{
-    d_3_0_Core->f.BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
-}
-
-inline void QOpenGLFunctions_3_0::glGenerateMipmap(GLenum target)
-{
-    d_3_0_Core->f.GenerateMipmap(target);
-}
-
-inline void QOpenGLFunctions_3_0::glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
-{
-    d_3_0_Core->f.FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
-}
-
-inline void QOpenGLFunctions_3_0::glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
-{
-    d_3_0_Core->f.FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
-}
-
-inline void QOpenGLFunctions_3_0::glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
-{
-    d_3_0_Core->f.FramebufferTexture2D(target, attachment, textarget, texture, level);
-}
-
-inline void QOpenGLFunctions_3_0::glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
-{
-    d_3_0_Core->f.FramebufferTexture1D(target, attachment, textarget, texture, level);
-}
-
-inline GLenum QOpenGLFunctions_3_0::glCheckFramebufferStatus(GLenum target)
-{
-    return d_3_0_Core->f.CheckFramebufferStatus(target);
-}
-
-inline void QOpenGLFunctions_3_0::glGenFramebuffers(GLsizei n, GLuint *framebuffers)
-{
-    d_3_0_Core->f.GenFramebuffers(n, framebuffers);
-}
-
-inline void QOpenGLFunctions_3_0::glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
-{
-    d_3_0_Core->f.DeleteFramebuffers(n, framebuffers);
-}
-
-inline void QOpenGLFunctions_3_0::glBindFramebuffer(GLenum target, GLuint framebuffer)
-{
-    d_3_0_Core->f.BindFramebuffer(target, framebuffer);
-}
-
-inline GLboolean QOpenGLFunctions_3_0::glIsFramebuffer(GLuint framebuffer)
-{
-    return d_3_0_Core->f.IsFramebuffer(framebuffer);
-}
-
-inline void QOpenGLFunctions_3_0::glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetRenderbufferParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    d_3_0_Core->f.RenderbufferStorage(target, internalformat, width, height);
-}
-
-inline void QOpenGLFunctions_3_0::glGenRenderbuffers(GLsizei n, GLuint *renderbuffers)
-{
-    d_3_0_Core->f.GenRenderbuffers(n, renderbuffers);
-}
-
-inline void QOpenGLFunctions_3_0::glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
-{
-    d_3_0_Core->f.DeleteRenderbuffers(n, renderbuffers);
-}
-
-inline void QOpenGLFunctions_3_0::glBindRenderbuffer(GLenum target, GLuint renderbuffer)
-{
-    d_3_0_Core->f.BindRenderbuffer(target, renderbuffer);
-}
-
-inline GLboolean QOpenGLFunctions_3_0::glIsRenderbuffer(GLuint renderbuffer)
-{
-    return d_3_0_Core->f.IsRenderbuffer(renderbuffer);
-}
-
-inline const GLubyte * QOpenGLFunctions_3_0::glGetStringi(GLenum name, GLuint index)
-{
-    return d_3_0_Core->f.GetStringi(name, index);
-}
-
-inline void QOpenGLFunctions_3_0::glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
-{
-    d_3_0_Core->f.ClearBufferfi(buffer, drawbuffer, depth, stencil);
-}
-
-inline void QOpenGLFunctions_3_0::glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
-{
-    d_3_0_Core->f.ClearBufferfv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_3_0::glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
-{
-    d_3_0_Core->f.ClearBufferuiv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_3_0::glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
-{
-    d_3_0_Core->f.ClearBufferiv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_3_0::glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params)
-{
-    d_3_0_Core->f.GetTexParameterIuiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetTexParameterIiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params)
-{
-    d_3_0_Core->f.TexParameterIuiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glTexParameterIiv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_3_0_Core->f.TexParameterIiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glUniform4uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform4uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_0::glUniform3uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform3uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_0::glUniform2uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform2uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_0::glUniform1uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform1uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_0::glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
-{
-    d_3_0_Core->f.Uniform4ui(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_3_0::glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
-{
-    d_3_0_Core->f.Uniform3ui(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_3_0::glUniform2ui(GLint location, GLuint v0, GLuint v1)
-{
-    d_3_0_Core->f.Uniform2ui(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_3_0::glUniform1ui(GLint location, GLuint v0)
-{
-    d_3_0_Core->f.Uniform1ui(location, v0);
-}
-
-inline GLint QOpenGLFunctions_3_0::glGetFragDataLocation(GLuint program, const GLchar *name)
-{
-    return d_3_0_Core->f.GetFragDataLocation(program, name);
-}
-
-inline void QOpenGLFunctions_3_0::glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name)
-{
-    d_3_0_Core->f.BindFragDataLocation(program, color, name);
-}
-
-inline void QOpenGLFunctions_3_0::glGetUniformuiv(GLuint program, GLint location, GLuint *params)
-{
-    d_3_0_Core->f.GetUniformuiv(program, location, params);
-}
-
-inline void QOpenGLFunctions_3_0::glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
-{
-    d_3_0_Core->f.GetVertexAttribIuiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetVertexAttribIiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_3_0_Core->f.VertexAttribIPointer(index, size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_3_0::glEndConditionalRender()
-{
-    d_3_0_Core->f.EndConditionalRender();
-}
-
-inline void QOpenGLFunctions_3_0::glBeginConditionalRender(GLuint id, GLenum mode)
-{
-    d_3_0_Core->f.BeginConditionalRender(id, mode);
-}
-
-inline void QOpenGLFunctions_3_0::glClampColor(GLenum target, GLenum clamp)
-{
-    d_3_0_Core->f.ClampColor(target, clamp);
-}
-
-inline void QOpenGLFunctions_3_0::glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
-{
-    d_3_0_Core->f.GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_3_0::glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode)
-{
-    d_3_0_Core->f.TransformFeedbackVaryings(program, count, varyings, bufferMode);
-}
-
-inline void QOpenGLFunctions_3_0::glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
-{
-    d_3_0_Core->f.BindBufferBase(target, index, buffer);
-}
-
-inline void QOpenGLFunctions_3_0::glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
-{
-    d_3_0_Core->f.BindBufferRange(target, index, buffer, offset, size);
-}
-
-inline void QOpenGLFunctions_3_0::glEndTransformFeedback()
-{
-    d_3_0_Core->f.EndTransformFeedback();
-}
-
-inline void QOpenGLFunctions_3_0::glBeginTransformFeedback(GLenum primitiveMode)
-{
-    d_3_0_Core->f.BeginTransformFeedback(primitiveMode);
-}
-
-inline GLboolean QOpenGLFunctions_3_0::glIsEnabledi(GLenum target, GLuint index)
-{
-    return d_3_0_Core->f.IsEnabledi(target, index);
-}
-
-inline void QOpenGLFunctions_3_0::glDisablei(GLenum target, GLuint index)
-{
-    d_3_0_Core->f.Disablei(target, index);
-}
-
-inline void QOpenGLFunctions_3_0::glEnablei(GLenum target, GLuint index)
-{
-    d_3_0_Core->f.Enablei(target, index);
-}
-
-inline void QOpenGLFunctions_3_0::glGetIntegeri_v(GLenum target, GLuint index, GLint *data)
-{
-    d_3_0_Core->f.GetIntegeri_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_3_0::glGetBooleani_v(GLenum target, GLuint index, GLboolean *data)
-{
-    d_3_0_Core->f.GetBooleani_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_3_0::glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
-{
-    d_3_0_Core->f.ColorMaski(index, r, g, b, a);
-}
-
-
-// OpenGL 1.0 deprecated functions
-inline void QOpenGLFunctions_3_0::glTranslatef(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Translatef(x, y, z);
-}
-
-inline void QOpenGLFunctions_3_0::glTranslated(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Translated(x, y, z);
-}
-
-inline void QOpenGLFunctions_3_0::glScalef(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Scalef(x, y, z);
-}
-
-inline void QOpenGLFunctions_3_0::glScaled(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Scaled(x, y, z);
-}
-
-inline void QOpenGLFunctions_3_0::glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Rotatef(angle, x, y, z);
-}
-
-inline void QOpenGLFunctions_3_0::glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Rotated(angle, x, y, z);
-}
-
-inline void QOpenGLFunctions_3_0::glPushMatrix()
-{
-    d_1_0_Deprecated->f.PushMatrix();
-}
-
-inline void QOpenGLFunctions_3_0::glPopMatrix()
-{
-    d_1_0_Deprecated->f.PopMatrix();
-}
-
-inline void QOpenGLFunctions_3_0::glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
-{
-    d_1_0_Deprecated->f.Ortho(left, right, bottom, top, zNear, zFar);
-}
-
-inline void QOpenGLFunctions_3_0::glMultMatrixd(const GLdouble *m)
-{
-    d_1_0_Deprecated->f.MultMatrixd(m);
-}
-
-inline void QOpenGLFunctions_3_0::glMultMatrixf(const GLfloat *m)
-{
-    d_1_0_Deprecated->f.MultMatrixf(m);
-}
-
-inline void QOpenGLFunctions_3_0::glMatrixMode(GLenum mode)
-{
-    d_1_0_Deprecated->f.MatrixMode(mode);
-}
-
-inline void QOpenGLFunctions_3_0::glLoadMatrixd(const GLdouble *m)
-{
-    d_1_0_Deprecated->f.LoadMatrixd(m);
-}
-
-inline void QOpenGLFunctions_3_0::glLoadMatrixf(const GLfloat *m)
-{
-    d_1_0_Deprecated->f.LoadMatrixf(m);
-}
-
-inline void QOpenGLFunctions_3_0::glLoadIdentity()
-{
-    d_1_0_Deprecated->f.LoadIdentity();
-}
-
-inline void QOpenGLFunctions_3_0::glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
-{
-    d_1_0_Deprecated->f.Frustum(left, right, bottom, top, zNear, zFar);
-}
-
-inline GLboolean QOpenGLFunctions_3_0::glIsList(GLuint list)
-{
-    return d_1_0_Deprecated->f.IsList(list);
-}
-
-inline void QOpenGLFunctions_3_0::glGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetTexGeniv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetTexGenfv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
-{
-    d_1_0_Deprecated->f.GetTexGendv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glGetTexEnviv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetTexEnviv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetTexEnvfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glGetPolygonStipple(GLubyte *mask)
-{
-    d_1_0_Deprecated->f.GetPolygonStipple(mask);
-}
-
-inline void QOpenGLFunctions_3_0::glGetPixelMapusv(GLenum map, GLushort *values)
-{
-    d_1_0_Deprecated->f.GetPixelMapusv(map, values);
-}
-
-inline void QOpenGLFunctions_3_0::glGetPixelMapuiv(GLenum map, GLuint *values)
-{
-    d_1_0_Deprecated->f.GetPixelMapuiv(map, values);
-}
-
-inline void QOpenGLFunctions_3_0::glGetPixelMapfv(GLenum map, GLfloat *values)
-{
-    d_1_0_Deprecated->f.GetPixelMapfv(map, values);
-}
-
-inline void QOpenGLFunctions_3_0::glGetMaterialiv(GLenum face, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetMaterialiv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetMaterialfv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glGetMapiv(GLenum target, GLenum query, GLint *v)
-{
-    d_1_0_Deprecated->f.GetMapiv(target, query, v);
-}
-
-inline void QOpenGLFunctions_3_0::glGetMapfv(GLenum target, GLenum query, GLfloat *v)
-{
-    d_1_0_Deprecated->f.GetMapfv(target, query, v);
-}
-
-inline void QOpenGLFunctions_3_0::glGetMapdv(GLenum target, GLenum query, GLdouble *v)
-{
-    d_1_0_Deprecated->f.GetMapdv(target, query, v);
-}
-
-inline void QOpenGLFunctions_3_0::glGetLightiv(GLenum light, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetLightiv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glGetLightfv(GLenum light, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetLightfv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glGetClipPlane(GLenum plane, GLdouble *equation)
-{
-    d_1_0_Deprecated->f.GetClipPlane(plane, equation);
-}
-
-inline void QOpenGLFunctions_3_0::glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Deprecated->f.DrawPixels(width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_3_0::glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
-{
-    d_1_0_Deprecated->f.CopyPixels(x, y, width, height, type);
-}
-
-inline void QOpenGLFunctions_3_0::glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values)
-{
-    d_1_0_Deprecated->f.PixelMapusv(map, mapsize, values);
-}
-
-inline void QOpenGLFunctions_3_0::glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values)
-{
-    d_1_0_Deprecated->f.PixelMapuiv(map, mapsize, values);
-}
-
-inline void QOpenGLFunctions_3_0::glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values)
-{
-    d_1_0_Deprecated->f.PixelMapfv(map, mapsize, values);
-}
-
-inline void QOpenGLFunctions_3_0::glPixelTransferi(GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.PixelTransferi(pname, param);
-}
-
-inline void QOpenGLFunctions_3_0::glPixelTransferf(GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.PixelTransferf(pname, param);
-}
-
-inline void QOpenGLFunctions_3_0::glPixelZoom(GLfloat xfactor, GLfloat yfactor)
-{
-    d_1_0_Deprecated->f.PixelZoom(xfactor, yfactor);
-}
-
-inline void QOpenGLFunctions_3_0::glAlphaFunc(GLenum func, GLfloat ref)
-{
-    d_1_0_Deprecated->f.AlphaFunc(func, ref);
-}
-
-inline void QOpenGLFunctions_3_0::glEvalPoint2(GLint i, GLint j)
-{
-    d_1_0_Deprecated->f.EvalPoint2(i, j);
-}
-
-inline void QOpenGLFunctions_3_0::glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
-{
-    d_1_0_Deprecated->f.EvalMesh2(mode, i1, i2, j1, j2);
-}
-
-inline void QOpenGLFunctions_3_0::glEvalPoint1(GLint i)
-{
-    d_1_0_Deprecated->f.EvalPoint1(i);
-}
-
-inline void QOpenGLFunctions_3_0::glEvalMesh1(GLenum mode, GLint i1, GLint i2)
-{
-    d_1_0_Deprecated->f.EvalMesh1(mode, i1, i2);
-}
-
-inline void QOpenGLFunctions_3_0::glEvalCoord2fv(const GLfloat *u)
-{
-    d_1_0_Deprecated->f.EvalCoord2fv(u);
-}
-
-inline void QOpenGLFunctions_3_0::glEvalCoord2f(GLfloat u, GLfloat v)
-{
-    d_1_0_Deprecated->f.EvalCoord2f(u, v);
-}
-
-inline void QOpenGLFunctions_3_0::glEvalCoord2dv(const GLdouble *u)
-{
-    d_1_0_Deprecated->f.EvalCoord2dv(u);
-}
-
-inline void QOpenGLFunctions_3_0::glEvalCoord2d(GLdouble u, GLdouble v)
-{
-    d_1_0_Deprecated->f.EvalCoord2d(u, v);
-}
-
-inline void QOpenGLFunctions_3_0::glEvalCoord1fv(const GLfloat *u)
-{
-    d_1_0_Deprecated->f.EvalCoord1fv(u);
-}
-
-inline void QOpenGLFunctions_3_0::glEvalCoord1f(GLfloat u)
-{
-    d_1_0_Deprecated->f.EvalCoord1f(u);
-}
-
-inline void QOpenGLFunctions_3_0::glEvalCoord1dv(const GLdouble *u)
-{
-    d_1_0_Deprecated->f.EvalCoord1dv(u);
-}
-
-inline void QOpenGLFunctions_3_0::glEvalCoord1d(GLdouble u)
-{
-    d_1_0_Deprecated->f.EvalCoord1d(u);
-}
-
-inline void QOpenGLFunctions_3_0::glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
-{
-    d_1_0_Deprecated->f.MapGrid2f(un, u1, u2, vn, v1, v2);
-}
-
-inline void QOpenGLFunctions_3_0::glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
-{
-    d_1_0_Deprecated->f.MapGrid2d(un, u1, u2, vn, v1, v2);
-}
-
-inline void QOpenGLFunctions_3_0::glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
-{
-    d_1_0_Deprecated->f.MapGrid1f(un, u1, u2);
-}
-
-inline void QOpenGLFunctions_3_0::glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
-{
-    d_1_0_Deprecated->f.MapGrid1d(un, u1, u2);
-}
-
-inline void QOpenGLFunctions_3_0::glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
-{
-    d_1_0_Deprecated->f.Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
-}
-
-inline void QOpenGLFunctions_3_0::glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
-{
-    d_1_0_Deprecated->f.Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
-}
-
-inline void QOpenGLFunctions_3_0::glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
-{
-    d_1_0_Deprecated->f.Map1f(target, u1, u2, stride, order, points);
-}
-
-inline void QOpenGLFunctions_3_0::glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
-{
-    d_1_0_Deprecated->f.Map1d(target, u1, u2, stride, order, points);
-}
-
-inline void QOpenGLFunctions_3_0::glPushAttrib(GLbitfield mask)
-{
-    d_1_0_Deprecated->f.PushAttrib(mask);
-}
-
-inline void QOpenGLFunctions_3_0::glPopAttrib()
-{
-    d_1_0_Deprecated->f.PopAttrib();
-}
-
-inline void QOpenGLFunctions_3_0::glAccum(GLenum op, GLfloat value)
-{
-    d_1_0_Deprecated->f.Accum(op, value);
-}
-
-inline void QOpenGLFunctions_3_0::glIndexMask(GLuint mask)
-{
-    d_1_0_Deprecated->f.IndexMask(mask);
-}
-
-inline void QOpenGLFunctions_3_0::glClearIndex(GLfloat c)
-{
-    d_1_0_Deprecated->f.ClearIndex(c);
-}
-
-inline void QOpenGLFunctions_3_0::glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Deprecated->f.ClearAccum(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_3_0::glPushName(GLuint name)
-{
-    d_1_0_Deprecated->f.PushName(name);
-}
-
-inline void QOpenGLFunctions_3_0::glPopName()
-{
-    d_1_0_Deprecated->f.PopName();
-}
-
-inline void QOpenGLFunctions_3_0::glPassThrough(GLfloat token)
-{
-    d_1_0_Deprecated->f.PassThrough(token);
-}
-
-inline void QOpenGLFunctions_3_0::glLoadName(GLuint name)
-{
-    d_1_0_Deprecated->f.LoadName(name);
-}
-
-inline void QOpenGLFunctions_3_0::glInitNames()
-{
-    d_1_0_Deprecated->f.InitNames();
-}
-
-inline GLint QOpenGLFunctions_3_0::glRenderMode(GLenum mode)
-{
-    return d_1_0_Deprecated->f.RenderMode(mode);
-}
-
-inline void QOpenGLFunctions_3_0::glSelectBuffer(GLsizei size, GLuint *buffer)
-{
-    d_1_0_Deprecated->f.SelectBuffer(size, buffer);
-}
-
-inline void QOpenGLFunctions_3_0::glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
-{
-    d_1_0_Deprecated->f.FeedbackBuffer(size, type, buffer);
-}
-
-inline void QOpenGLFunctions_3_0::glTexGeniv(GLenum coord, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.TexGeniv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glTexGeni(GLenum coord, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.TexGeni(coord, pname, param);
-}
-
-inline void QOpenGLFunctions_3_0::glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.TexGenfv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glTexGenf(GLenum coord, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.TexGenf(coord, pname, param);
-}
-
-inline void QOpenGLFunctions_3_0::glTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
-{
-    d_1_0_Deprecated->f.TexGendv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glTexGend(GLenum coord, GLenum pname, GLdouble param)
-{
-    d_1_0_Deprecated->f.TexGend(coord, pname, param);
-}
-
-inline void QOpenGLFunctions_3_0::glTexEnviv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.TexEnviv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glTexEnvi(GLenum target, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.TexEnvi(target, pname, param);
-}
-
-inline void QOpenGLFunctions_3_0::glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.TexEnvfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glTexEnvf(GLenum target, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.TexEnvf(target, pname, param);
-}
-
-inline void QOpenGLFunctions_3_0::glShadeModel(GLenum mode)
-{
-    d_1_0_Deprecated->f.ShadeModel(mode);
-}
-
-inline void QOpenGLFunctions_3_0::glPolygonStipple(const GLubyte *mask)
-{
-    d_1_0_Deprecated->f.PolygonStipple(mask);
-}
-
-inline void QOpenGLFunctions_3_0::glMaterialiv(GLenum face, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.Materialiv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glMateriali(GLenum face, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.Materiali(face, pname, param);
-}
-
-inline void QOpenGLFunctions_3_0::glMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.Materialfv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glMaterialf(GLenum face, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.Materialf(face, pname, param);
-}
-
-inline void QOpenGLFunctions_3_0::glLineStipple(GLint factor, GLushort pattern)
-{
-    d_1_0_Deprecated->f.LineStipple(factor, pattern);
-}
-
-inline void QOpenGLFunctions_3_0::glLightModeliv(GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.LightModeliv(pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glLightModeli(GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.LightModeli(pname, param);
-}
-
-inline void QOpenGLFunctions_3_0::glLightModelfv(GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.LightModelfv(pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glLightModelf(GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.LightModelf(pname, param);
-}
-
-inline void QOpenGLFunctions_3_0::glLightiv(GLenum light, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.Lightiv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glLighti(GLenum light, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.Lighti(light, pname, param);
-}
-
-inline void QOpenGLFunctions_3_0::glLightfv(GLenum light, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.Lightfv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glLightf(GLenum light, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.Lightf(light, pname, param);
-}
-
-inline void QOpenGLFunctions_3_0::glFogiv(GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.Fogiv(pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glFogi(GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.Fogi(pname, param);
-}
-
-inline void QOpenGLFunctions_3_0::glFogfv(GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.Fogfv(pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glFogf(GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.Fogf(pname, param);
-}
-
-inline void QOpenGLFunctions_3_0::glColorMaterial(GLenum face, GLenum mode)
-{
-    d_1_0_Deprecated->f.ColorMaterial(face, mode);
-}
-
-inline void QOpenGLFunctions_3_0::glClipPlane(GLenum plane, const GLdouble *equation)
-{
-    d_1_0_Deprecated->f.ClipPlane(plane, equation);
-}
-
-inline void QOpenGLFunctions_3_0::glVertex4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Vertex4sv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
-{
-    d_1_0_Deprecated->f.Vertex4s(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_3_0::glVertex4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Vertex4iv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glVertex4i(GLint x, GLint y, GLint z, GLint w)
-{
-    d_1_0_Deprecated->f.Vertex4i(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_3_0::glVertex4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Vertex4fv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    d_1_0_Deprecated->f.Vertex4f(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_3_0::glVertex4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Vertex4dv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_1_0_Deprecated->f.Vertex4d(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_3_0::glVertex3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Vertex3sv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glVertex3s(GLshort x, GLshort y, GLshort z)
-{
-    d_1_0_Deprecated->f.Vertex3s(x, y, z);
-}
-
-inline void QOpenGLFunctions_3_0::glVertex3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Vertex3iv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glVertex3i(GLint x, GLint y, GLint z)
-{
-    d_1_0_Deprecated->f.Vertex3i(x, y, z);
-}
-
-inline void QOpenGLFunctions_3_0::glVertex3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Vertex3fv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glVertex3f(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Vertex3f(x, y, z);
-}
-
-inline void QOpenGLFunctions_3_0::glVertex3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Vertex3dv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glVertex3d(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Vertex3d(x, y, z);
-}
-
-inline void QOpenGLFunctions_3_0::glVertex2sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Vertex2sv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glVertex2s(GLshort x, GLshort y)
-{
-    d_1_0_Deprecated->f.Vertex2s(x, y);
-}
-
-inline void QOpenGLFunctions_3_0::glVertex2iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Vertex2iv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glVertex2i(GLint x, GLint y)
-{
-    d_1_0_Deprecated->f.Vertex2i(x, y);
-}
-
-inline void QOpenGLFunctions_3_0::glVertex2fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Vertex2fv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glVertex2f(GLfloat x, GLfloat y)
-{
-    d_1_0_Deprecated->f.Vertex2f(x, y);
-}
-
-inline void QOpenGLFunctions_3_0::glVertex2dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Vertex2dv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glVertex2d(GLdouble x, GLdouble y)
-{
-    d_1_0_Deprecated->f.Vertex2d(x, y);
-}
-
-inline void QOpenGLFunctions_3_0::glTexCoord4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord4sv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
-{
-    d_1_0_Deprecated->f.TexCoord4s(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_3_0::glTexCoord4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord4iv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
-{
-    d_1_0_Deprecated->f.TexCoord4i(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_3_0::glTexCoord4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord4fv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
-{
-    d_1_0_Deprecated->f.TexCoord4f(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_3_0::glTexCoord4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord4dv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
-{
-    d_1_0_Deprecated->f.TexCoord4d(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_3_0::glTexCoord3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord3sv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glTexCoord3s(GLshort s, GLshort t, GLshort r)
-{
-    d_1_0_Deprecated->f.TexCoord3s(s, t, r);
-}
-
-inline void QOpenGLFunctions_3_0::glTexCoord3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord3iv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glTexCoord3i(GLint s, GLint t, GLint r)
-{
-    d_1_0_Deprecated->f.TexCoord3i(s, t, r);
-}
-
-inline void QOpenGLFunctions_3_0::glTexCoord3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord3fv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
-{
-    d_1_0_Deprecated->f.TexCoord3f(s, t, r);
-}
-
-inline void QOpenGLFunctions_3_0::glTexCoord3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord3dv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
-{
-    d_1_0_Deprecated->f.TexCoord3d(s, t, r);
-}
-
-inline void QOpenGLFunctions_3_0::glTexCoord2sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord2sv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glTexCoord2s(GLshort s, GLshort t)
-{
-    d_1_0_Deprecated->f.TexCoord2s(s, t);
-}
-
-inline void QOpenGLFunctions_3_0::glTexCoord2iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord2iv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glTexCoord2i(GLint s, GLint t)
-{
-    d_1_0_Deprecated->f.TexCoord2i(s, t);
-}
-
-inline void QOpenGLFunctions_3_0::glTexCoord2fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord2fv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glTexCoord2f(GLfloat s, GLfloat t)
-{
-    d_1_0_Deprecated->f.TexCoord2f(s, t);
-}
-
-inline void QOpenGLFunctions_3_0::glTexCoord2dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord2dv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glTexCoord2d(GLdouble s, GLdouble t)
-{
-    d_1_0_Deprecated->f.TexCoord2d(s, t);
-}
-
-inline void QOpenGLFunctions_3_0::glTexCoord1sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord1sv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glTexCoord1s(GLshort s)
-{
-    d_1_0_Deprecated->f.TexCoord1s(s);
-}
-
-inline void QOpenGLFunctions_3_0::glTexCoord1iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord1iv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glTexCoord1i(GLint s)
-{
-    d_1_0_Deprecated->f.TexCoord1i(s);
-}
-
-inline void QOpenGLFunctions_3_0::glTexCoord1fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord1fv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glTexCoord1f(GLfloat s)
-{
-    d_1_0_Deprecated->f.TexCoord1f(s);
-}
-
-inline void QOpenGLFunctions_3_0::glTexCoord1dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord1dv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glTexCoord1d(GLdouble s)
-{
-    d_1_0_Deprecated->f.TexCoord1d(s);
-}
-
-inline void QOpenGLFunctions_3_0::glRectsv(const GLshort *v1, const GLshort *v2)
-{
-    d_1_0_Deprecated->f.Rectsv(v1, v2);
-}
-
-inline void QOpenGLFunctions_3_0::glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
-{
-    d_1_0_Deprecated->f.Rects(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_3_0::glRectiv(const GLint *v1, const GLint *v2)
-{
-    d_1_0_Deprecated->f.Rectiv(v1, v2);
-}
-
-inline void QOpenGLFunctions_3_0::glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
-{
-    d_1_0_Deprecated->f.Recti(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_3_0::glRectfv(const GLfloat *v1, const GLfloat *v2)
-{
-    d_1_0_Deprecated->f.Rectfv(v1, v2);
-}
-
-inline void QOpenGLFunctions_3_0::glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
-{
-    d_1_0_Deprecated->f.Rectf(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_3_0::glRectdv(const GLdouble *v1, const GLdouble *v2)
-{
-    d_1_0_Deprecated->f.Rectdv(v1, v2);
-}
-
-inline void QOpenGLFunctions_3_0::glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
-{
-    d_1_0_Deprecated->f.Rectd(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_3_0::glRasterPos4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.RasterPos4sv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
-{
-    d_1_0_Deprecated->f.RasterPos4s(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_3_0::glRasterPos4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.RasterPos4iv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
-{
-    d_1_0_Deprecated->f.RasterPos4i(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_3_0::glRasterPos4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.RasterPos4fv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    d_1_0_Deprecated->f.RasterPos4f(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_3_0::glRasterPos4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.RasterPos4dv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_1_0_Deprecated->f.RasterPos4d(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_3_0::glRasterPos3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.RasterPos3sv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glRasterPos3s(GLshort x, GLshort y, GLshort z)
-{
-    d_1_0_Deprecated->f.RasterPos3s(x, y, z);
-}
-
-inline void QOpenGLFunctions_3_0::glRasterPos3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.RasterPos3iv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glRasterPos3i(GLint x, GLint y, GLint z)
-{
-    d_1_0_Deprecated->f.RasterPos3i(x, y, z);
-}
-
-inline void QOpenGLFunctions_3_0::glRasterPos3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.RasterPos3fv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.RasterPos3f(x, y, z);
-}
-
-inline void QOpenGLFunctions_3_0::glRasterPos3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.RasterPos3dv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.RasterPos3d(x, y, z);
-}
-
-inline void QOpenGLFunctions_3_0::glRasterPos2sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.RasterPos2sv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glRasterPos2s(GLshort x, GLshort y)
-{
-    d_1_0_Deprecated->f.RasterPos2s(x, y);
-}
-
-inline void QOpenGLFunctions_3_0::glRasterPos2iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.RasterPos2iv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glRasterPos2i(GLint x, GLint y)
-{
-    d_1_0_Deprecated->f.RasterPos2i(x, y);
-}
-
-inline void QOpenGLFunctions_3_0::glRasterPos2fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.RasterPos2fv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glRasterPos2f(GLfloat x, GLfloat y)
-{
-    d_1_0_Deprecated->f.RasterPos2f(x, y);
-}
-
-inline void QOpenGLFunctions_3_0::glRasterPos2dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.RasterPos2dv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glRasterPos2d(GLdouble x, GLdouble y)
-{
-    d_1_0_Deprecated->f.RasterPos2d(x, y);
-}
-
-inline void QOpenGLFunctions_3_0::glNormal3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Normal3sv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glNormal3s(GLshort nx, GLshort ny, GLshort nz)
-{
-    d_1_0_Deprecated->f.Normal3s(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_3_0::glNormal3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Normal3iv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glNormal3i(GLint nx, GLint ny, GLint nz)
-{
-    d_1_0_Deprecated->f.Normal3i(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_3_0::glNormal3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Normal3fv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
-{
-    d_1_0_Deprecated->f.Normal3f(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_3_0::glNormal3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Normal3dv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
-{
-    d_1_0_Deprecated->f.Normal3d(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_3_0::glNormal3bv(const GLbyte *v)
-{
-    d_1_0_Deprecated->f.Normal3bv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
-{
-    d_1_0_Deprecated->f.Normal3b(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_3_0::glIndexsv(const GLshort *c)
-{
-    d_1_0_Deprecated->f.Indexsv(c);
-}
-
-inline void QOpenGLFunctions_3_0::glIndexs(GLshort c)
-{
-    d_1_0_Deprecated->f.Indexs(c);
-}
-
-inline void QOpenGLFunctions_3_0::glIndexiv(const GLint *c)
-{
-    d_1_0_Deprecated->f.Indexiv(c);
-}
-
-inline void QOpenGLFunctions_3_0::glIndexi(GLint c)
-{
-    d_1_0_Deprecated->f.Indexi(c);
-}
-
-inline void QOpenGLFunctions_3_0::glIndexfv(const GLfloat *c)
-{
-    d_1_0_Deprecated->f.Indexfv(c);
-}
-
-inline void QOpenGLFunctions_3_0::glIndexf(GLfloat c)
-{
-    d_1_0_Deprecated->f.Indexf(c);
-}
-
-inline void QOpenGLFunctions_3_0::glIndexdv(const GLdouble *c)
-{
-    d_1_0_Deprecated->f.Indexdv(c);
-}
-
-inline void QOpenGLFunctions_3_0::glIndexd(GLdouble c)
-{
-    d_1_0_Deprecated->f.Indexd(c);
-}
-
-inline void QOpenGLFunctions_3_0::glEnd()
-{
-    d_1_0_Deprecated->f.End();
-}
-
-inline void QOpenGLFunctions_3_0::glEdgeFlagv(const GLboolean *flag)
-{
-    d_1_0_Deprecated->f.EdgeFlagv(flag);
-}
-
-inline void QOpenGLFunctions_3_0::glEdgeFlag(GLboolean flag)
-{
-    d_1_0_Deprecated->f.EdgeFlag(flag);
-}
-
-inline void QOpenGLFunctions_3_0::glColor4usv(const GLushort *v)
-{
-    d_1_0_Deprecated->f.Color4usv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
-{
-    d_1_0_Deprecated->f.Color4us(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_3_0::glColor4uiv(const GLuint *v)
-{
-    d_1_0_Deprecated->f.Color4uiv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
-{
-    d_1_0_Deprecated->f.Color4ui(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_3_0::glColor4ubv(const GLubyte *v)
-{
-    d_1_0_Deprecated->f.Color4ubv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
-{
-    d_1_0_Deprecated->f.Color4ub(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_3_0::glColor4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Color4sv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
-{
-    d_1_0_Deprecated->f.Color4s(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_3_0::glColor4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Color4iv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
-{
-    d_1_0_Deprecated->f.Color4i(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_3_0::glColor4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Color4fv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Deprecated->f.Color4f(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_3_0::glColor4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Color4dv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
-{
-    d_1_0_Deprecated->f.Color4d(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_3_0::glColor4bv(const GLbyte *v)
-{
-    d_1_0_Deprecated->f.Color4bv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
-{
-    d_1_0_Deprecated->f.Color4b(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_3_0::glColor3usv(const GLushort *v)
-{
-    d_1_0_Deprecated->f.Color3usv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glColor3us(GLushort red, GLushort green, GLushort blue)
-{
-    d_1_0_Deprecated->f.Color3us(red, green, blue);
-}
-
-inline void QOpenGLFunctions_3_0::glColor3uiv(const GLuint *v)
-{
-    d_1_0_Deprecated->f.Color3uiv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glColor3ui(GLuint red, GLuint green, GLuint blue)
-{
-    d_1_0_Deprecated->f.Color3ui(red, green, blue);
-}
-
-inline void QOpenGLFunctions_3_0::glColor3ubv(const GLubyte *v)
-{
-    d_1_0_Deprecated->f.Color3ubv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
-{
-    d_1_0_Deprecated->f.Color3ub(red, green, blue);
-}
-
-inline void QOpenGLFunctions_3_0::glColor3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Color3sv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glColor3s(GLshort red, GLshort green, GLshort blue)
-{
-    d_1_0_Deprecated->f.Color3s(red, green, blue);
-}
-
-inline void QOpenGLFunctions_3_0::glColor3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Color3iv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glColor3i(GLint red, GLint green, GLint blue)
-{
-    d_1_0_Deprecated->f.Color3i(red, green, blue);
-}
-
-inline void QOpenGLFunctions_3_0::glColor3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Color3fv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glColor3f(GLfloat red, GLfloat green, GLfloat blue)
-{
-    d_1_0_Deprecated->f.Color3f(red, green, blue);
-}
-
-inline void QOpenGLFunctions_3_0::glColor3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Color3dv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glColor3d(GLdouble red, GLdouble green, GLdouble blue)
-{
-    d_1_0_Deprecated->f.Color3d(red, green, blue);
-}
-
-inline void QOpenGLFunctions_3_0::glColor3bv(const GLbyte *v)
-{
-    d_1_0_Deprecated->f.Color3bv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glColor3b(GLbyte red, GLbyte green, GLbyte blue)
-{
-    d_1_0_Deprecated->f.Color3b(red, green, blue);
-}
-
-inline void QOpenGLFunctions_3_0::glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
-{
-    d_1_0_Deprecated->f.Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
-}
-
-inline void QOpenGLFunctions_3_0::glBegin(GLenum mode)
-{
-    d_1_0_Deprecated->f.Begin(mode);
-}
-
-inline void QOpenGLFunctions_3_0::glListBase(GLuint base)
-{
-    d_1_0_Deprecated->f.ListBase(base);
-}
-
-inline GLuint QOpenGLFunctions_3_0::glGenLists(GLsizei range)
-{
-    return d_1_0_Deprecated->f.GenLists(range);
-}
-
-inline void QOpenGLFunctions_3_0::glDeleteLists(GLuint list, GLsizei range)
-{
-    d_1_0_Deprecated->f.DeleteLists(list, range);
-}
-
-inline void QOpenGLFunctions_3_0::glCallLists(GLsizei n, GLenum type, const GLvoid *lists)
-{
-    d_1_0_Deprecated->f.CallLists(n, type, lists);
-}
-
-inline void QOpenGLFunctions_3_0::glCallList(GLuint list)
-{
-    d_1_0_Deprecated->f.CallList(list);
-}
-
-inline void QOpenGLFunctions_3_0::glEndList()
-{
-    d_1_0_Deprecated->f.EndList();
-}
-
-inline void QOpenGLFunctions_3_0::glNewList(GLuint list, GLenum mode)
-{
-    d_1_0_Deprecated->f.NewList(list, mode);
-}
-
-
-// OpenGL 1.1 deprecated functions
-inline void QOpenGLFunctions_3_0::glPushClientAttrib(GLbitfield mask)
-{
-    d_1_1_Deprecated->f.PushClientAttrib(mask);
-}
-
-inline void QOpenGLFunctions_3_0::glPopClientAttrib()
-{
-    d_1_1_Deprecated->f.PopClientAttrib();
-}
-
-inline void QOpenGLFunctions_3_0::glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities)
-{
-    d_1_1_Deprecated->f.PrioritizeTextures(n, textures, priorities);
-}
-
-inline GLboolean QOpenGLFunctions_3_0::glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
-{
-    return d_1_1_Deprecated->f.AreTexturesResident(n, textures, residences);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.VertexPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_3_0::glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.TexCoordPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_3_0::glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.NormalPointer(type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_3_0::glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.InterleavedArrays(format, stride, pointer);
-}
-
-inline void QOpenGLFunctions_3_0::glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.IndexPointer(type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_3_0::glEnableClientState(GLenum array)
-{
-    d_1_1_Deprecated->f.EnableClientState(array);
-}
-
-inline void QOpenGLFunctions_3_0::glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.EdgeFlagPointer(stride, pointer);
-}
-
-inline void QOpenGLFunctions_3_0::glDisableClientState(GLenum array)
-{
-    d_1_1_Deprecated->f.DisableClientState(array);
-}
-
-inline void QOpenGLFunctions_3_0::glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.ColorPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_3_0::glArrayElement(GLint i)
-{
-    d_1_1_Deprecated->f.ArrayElement(i);
-}
-
-
-// OpenGL 1.2 deprecated functions
-inline void QOpenGLFunctions_3_0::glResetMinmax(GLenum target)
-{
-    d_1_2_Deprecated->f.ResetMinmax(target);
-}
-
-inline void QOpenGLFunctions_3_0::glResetHistogram(GLenum target)
-{
-    d_1_2_Deprecated->f.ResetHistogram(target);
-}
-
-inline void QOpenGLFunctions_3_0::glMinmax(GLenum target, GLenum internalformat, GLboolean sink)
-{
-    d_1_2_Deprecated->f.Minmax(target, internalformat, sink);
-}
-
-inline void QOpenGLFunctions_3_0::glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
-{
-    d_1_2_Deprecated->f.Histogram(target, width, internalformat, sink);
-}
-
-inline void QOpenGLFunctions_3_0::glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetMinmaxParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetMinmaxParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
-{
-    d_1_2_Deprecated->f.GetMinmax(target, reset, format, type, values);
-}
-
-inline void QOpenGLFunctions_3_0::glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetHistogramParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetHistogramParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
-{
-    d_1_2_Deprecated->f.GetHistogram(target, reset, format, type, values);
-}
-
-inline void QOpenGLFunctions_3_0::glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column)
-{
-    d_1_2_Deprecated->f.SeparableFilter2D(target, internalformat, width, height, format, type, row, column);
-}
-
-inline void QOpenGLFunctions_3_0::glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span)
-{
-    d_1_2_Deprecated->f.GetSeparableFilter(target, format, type, row, column, span);
-}
-
-inline void QOpenGLFunctions_3_0::glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetConvolutionParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetConvolutionParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image)
-{
-    d_1_2_Deprecated->f.GetConvolutionFilter(target, format, type, image);
-}
-
-inline void QOpenGLFunctions_3_0::glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_2_Deprecated->f.CopyConvolutionFilter2D(target, internalformat, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_3_0::glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
-{
-    d_1_2_Deprecated->f.CopyConvolutionFilter1D(target, internalformat, x, y, width);
-}
-
-inline void QOpenGLFunctions_3_0::glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glConvolutionParameteri(GLenum target, GLenum pname, GLint params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameteri(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameterf(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image)
-{
-    d_1_2_Deprecated->f.ConvolutionFilter2D(target, internalformat, width, height, format, type, image);
-}
-
-inline void QOpenGLFunctions_3_0::glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image)
-{
-    d_1_2_Deprecated->f.ConvolutionFilter1D(target, internalformat, width, format, type, image);
-}
-
-inline void QOpenGLFunctions_3_0::glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
-{
-    d_1_2_Deprecated->f.CopyColorSubTable(target, start, x, y, width);
-}
-
-inline void QOpenGLFunctions_3_0::glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data)
-{
-    d_1_2_Deprecated->f.ColorSubTable(target, start, count, format, type, data);
-}
-
-inline void QOpenGLFunctions_3_0::glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetColorTableParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetColorTableParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table)
-{
-    d_1_2_Deprecated->f.GetColorTable(target, format, type, table);
-}
-
-inline void QOpenGLFunctions_3_0::glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
-{
-    d_1_2_Deprecated->f.CopyColorTable(target, internalformat, x, y, width);
-}
-
-inline void QOpenGLFunctions_3_0::glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_2_Deprecated->f.ColorTableParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_2_Deprecated->f.ColorTableParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_0::glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table)
-{
-    d_1_2_Deprecated->f.ColorTable(target, internalformat, width, format, type, table);
-}
-
-
-// OpenGL 1.3 deprecated functions
-inline void QOpenGLFunctions_3_0::glMultTransposeMatrixd(const GLdouble *m)
-{
-    d_1_3_Deprecated->f.MultTransposeMatrixd(m);
-}
-
-inline void QOpenGLFunctions_3_0::glMultTransposeMatrixf(const GLfloat *m)
-{
-    d_1_3_Deprecated->f.MultTransposeMatrixf(m);
-}
-
-inline void QOpenGLFunctions_3_0::glLoadTransposeMatrixd(const GLdouble *m)
-{
-    d_1_3_Deprecated->f.LoadTransposeMatrixd(m);
-}
-
-inline void QOpenGLFunctions_3_0::glLoadTransposeMatrixf(const GLfloat *m)
-{
-    d_1_3_Deprecated->f.LoadTransposeMatrixf(m);
-}
-
-inline void QOpenGLFunctions_3_0::glMultiTexCoord4sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4sv(target, v);
-}
-
-inline void QOpenGLFunctions_3_0::glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4s(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_3_0::glMultiTexCoord4iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4iv(target, v);
-}
-
-inline void QOpenGLFunctions_3_0::glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4i(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_3_0::glMultiTexCoord4fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4fv(target, v);
-}
-
-inline void QOpenGLFunctions_3_0::glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4f(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_3_0::glMultiTexCoord4dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4dv(target, v);
-}
-
-inline void QOpenGLFunctions_3_0::glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4d(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_3_0::glMultiTexCoord3sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3sv(target, v);
-}
-
-inline void QOpenGLFunctions_3_0::glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3s(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_3_0::glMultiTexCoord3iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3iv(target, v);
-}
-
-inline void QOpenGLFunctions_3_0::glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3i(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_3_0::glMultiTexCoord3fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3fv(target, v);
-}
-
-inline void QOpenGLFunctions_3_0::glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3f(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_3_0::glMultiTexCoord3dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3dv(target, v);
-}
-
-inline void QOpenGLFunctions_3_0::glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3d(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_3_0::glMultiTexCoord2sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2sv(target, v);
-}
-
-inline void QOpenGLFunctions_3_0::glMultiTexCoord2s(GLenum target, GLshort s, GLshort t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2s(target, s, t);
-}
-
-inline void QOpenGLFunctions_3_0::glMultiTexCoord2iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2iv(target, v);
-}
-
-inline void QOpenGLFunctions_3_0::glMultiTexCoord2i(GLenum target, GLint s, GLint t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2i(target, s, t);
-}
-
-inline void QOpenGLFunctions_3_0::glMultiTexCoord2fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2fv(target, v);
-}
-
-inline void QOpenGLFunctions_3_0::glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2f(target, s, t);
-}
-
-inline void QOpenGLFunctions_3_0::glMultiTexCoord2dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2dv(target, v);
-}
-
-inline void QOpenGLFunctions_3_0::glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2d(target, s, t);
-}
-
-inline void QOpenGLFunctions_3_0::glMultiTexCoord1sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1sv(target, v);
-}
-
-inline void QOpenGLFunctions_3_0::glMultiTexCoord1s(GLenum target, GLshort s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1s(target, s);
-}
-
-inline void QOpenGLFunctions_3_0::glMultiTexCoord1iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1iv(target, v);
-}
-
-inline void QOpenGLFunctions_3_0::glMultiTexCoord1i(GLenum target, GLint s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1i(target, s);
-}
-
-inline void QOpenGLFunctions_3_0::glMultiTexCoord1fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1fv(target, v);
-}
-
-inline void QOpenGLFunctions_3_0::glMultiTexCoord1f(GLenum target, GLfloat s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1f(target, s);
-}
-
-inline void QOpenGLFunctions_3_0::glMultiTexCoord1dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1dv(target, v);
-}
-
-inline void QOpenGLFunctions_3_0::glMultiTexCoord1d(GLenum target, GLdouble s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1d(target, s);
-}
-
-inline void QOpenGLFunctions_3_0::glClientActiveTexture(GLenum texture)
-{
-    d_1_3_Deprecated->f.ClientActiveTexture(texture);
-}
-
-
-// OpenGL 1.4 deprecated functions
-inline void QOpenGLFunctions_3_0::glWindowPos3sv(const GLshort *v)
-{
-    d_1_4_Deprecated->f.WindowPos3sv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glWindowPos3s(GLshort x, GLshort y, GLshort z)
-{
-    d_1_4_Deprecated->f.WindowPos3s(x, y, z);
-}
-
-inline void QOpenGLFunctions_3_0::glWindowPos3iv(const GLint *v)
-{
-    d_1_4_Deprecated->f.WindowPos3iv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glWindowPos3i(GLint x, GLint y, GLint z)
-{
-    d_1_4_Deprecated->f.WindowPos3i(x, y, z);
-}
-
-inline void QOpenGLFunctions_3_0::glWindowPos3fv(const GLfloat *v)
-{
-    d_1_4_Deprecated->f.WindowPos3fv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glWindowPos3f(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_4_Deprecated->f.WindowPos3f(x, y, z);
-}
-
-inline void QOpenGLFunctions_3_0::glWindowPos3dv(const GLdouble *v)
-{
-    d_1_4_Deprecated->f.WindowPos3dv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glWindowPos3d(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_4_Deprecated->f.WindowPos3d(x, y, z);
-}
-
-inline void QOpenGLFunctions_3_0::glWindowPos2sv(const GLshort *v)
-{
-    d_1_4_Deprecated->f.WindowPos2sv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glWindowPos2s(GLshort x, GLshort y)
-{
-    d_1_4_Deprecated->f.WindowPos2s(x, y);
-}
-
-inline void QOpenGLFunctions_3_0::glWindowPos2iv(const GLint *v)
-{
-    d_1_4_Deprecated->f.WindowPos2iv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glWindowPos2i(GLint x, GLint y)
-{
-    d_1_4_Deprecated->f.WindowPos2i(x, y);
-}
-
-inline void QOpenGLFunctions_3_0::glWindowPos2fv(const GLfloat *v)
-{
-    d_1_4_Deprecated->f.WindowPos2fv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glWindowPos2f(GLfloat x, GLfloat y)
-{
-    d_1_4_Deprecated->f.WindowPos2f(x, y);
-}
-
-inline void QOpenGLFunctions_3_0::glWindowPos2dv(const GLdouble *v)
-{
-    d_1_4_Deprecated->f.WindowPos2dv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glWindowPos2d(GLdouble x, GLdouble y)
-{
-    d_1_4_Deprecated->f.WindowPos2d(x, y);
-}
-
-inline void QOpenGLFunctions_3_0::glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_4_Deprecated->f.SecondaryColorPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_3_0::glSecondaryColor3usv(const GLushort *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3usv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glSecondaryColor3us(GLushort red, GLushort green, GLushort blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3us(red, green, blue);
-}
-
-inline void QOpenGLFunctions_3_0::glSecondaryColor3uiv(const GLuint *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3uiv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3ui(red, green, blue);
-}
-
-inline void QOpenGLFunctions_3_0::glSecondaryColor3ubv(const GLubyte *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3ubv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3ub(red, green, blue);
-}
-
-inline void QOpenGLFunctions_3_0::glSecondaryColor3sv(const GLshort *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3sv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glSecondaryColor3s(GLshort red, GLshort green, GLshort blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3s(red, green, blue);
-}
-
-inline void QOpenGLFunctions_3_0::glSecondaryColor3iv(const GLint *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3iv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glSecondaryColor3i(GLint red, GLint green, GLint blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3i(red, green, blue);
-}
-
-inline void QOpenGLFunctions_3_0::glSecondaryColor3fv(const GLfloat *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3fv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3f(red, green, blue);
-}
-
-inline void QOpenGLFunctions_3_0::glSecondaryColor3dv(const GLdouble *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3dv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3d(red, green, blue);
-}
-
-inline void QOpenGLFunctions_3_0::glSecondaryColor3bv(const GLbyte *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3bv(v);
-}
-
-inline void QOpenGLFunctions_3_0::glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3b(red, green, blue);
-}
-
-inline void QOpenGLFunctions_3_0::glFogCoordPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_4_Deprecated->f.FogCoordPointer(type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_3_0::glFogCoorddv(const GLdouble *coord)
-{
-    d_1_4_Deprecated->f.FogCoorddv(coord);
-}
-
-inline void QOpenGLFunctions_3_0::glFogCoordd(GLdouble coord)
-{
-    d_1_4_Deprecated->f.FogCoordd(coord);
-}
-
-inline void QOpenGLFunctions_3_0::glFogCoordfv(const GLfloat *coord)
-{
-    d_1_4_Deprecated->f.FogCoordfv(coord);
-}
-
-inline void QOpenGLFunctions_3_0::glFogCoordf(GLfloat coord)
-{
-    d_1_4_Deprecated->f.FogCoordf(coord);
-}
-
-
-// OpenGL 1.5 deprecated functions
-
-// OpenGL 2.0 deprecated functions
-inline void QOpenGLFunctions_3_0::glVertexAttrib4usv(GLuint index, const GLushort *v)
-{
-    d_2_0_Core->f.VertexAttrib4usv(index, v);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttrib4uiv(GLuint index, const GLuint *v)
-{
-    d_2_0_Core->f.VertexAttrib4uiv(index, v);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttrib4ubv(GLuint index, const GLubyte *v)
-{
-    d_2_0_Core->f.VertexAttrib4ubv(index, v);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttrib4sv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib4sv(index, v);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
-{
-    d_2_0_Core->f.VertexAttrib4s(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttrib4iv(GLuint index, const GLint *v)
-{
-    d_2_0_Core->f.VertexAttrib4iv(index, v);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttrib4fv(GLuint index, const GLfloat *v)
-{
-    d_2_0_Core->f.VertexAttrib4fv(index, v);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    d_2_0_Core->f.VertexAttrib4f(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttrib4dv(GLuint index, const GLdouble *v)
-{
-    d_2_0_Core->f.VertexAttrib4dv(index, v);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_2_0_Core->f.VertexAttrib4d(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttrib4bv(GLuint index, const GLbyte *v)
-{
-    d_2_0_Core->f.VertexAttrib4bv(index, v);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttrib4Nusv(GLuint index, const GLushort *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nusv(index, v);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttrib4Nuiv(GLuint index, const GLuint *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nuiv(index, v);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttrib4Nubv(GLuint index, const GLubyte *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nubv(index, v);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
-{
-    d_2_0_Core->f.VertexAttrib4Nub(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttrib4Nsv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nsv(index, v);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttrib4Niv(GLuint index, const GLint *v)
-{
-    d_2_0_Core->f.VertexAttrib4Niv(index, v);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttrib4Nbv(GLuint index, const GLbyte *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nbv(index, v);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttrib3sv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib3sv(index, v);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
-{
-    d_2_0_Core->f.VertexAttrib3s(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttrib3fv(GLuint index, const GLfloat *v)
-{
-    d_2_0_Core->f.VertexAttrib3fv(index, v);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
-{
-    d_2_0_Core->f.VertexAttrib3f(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttrib3dv(GLuint index, const GLdouble *v)
-{
-    d_2_0_Core->f.VertexAttrib3dv(index, v);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
-{
-    d_2_0_Core->f.VertexAttrib3d(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttrib2sv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib2sv(index, v);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttrib2s(GLuint index, GLshort x, GLshort y)
-{
-    d_2_0_Core->f.VertexAttrib2s(index, x, y);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttrib2fv(GLuint index, const GLfloat *v)
-{
-    d_2_0_Core->f.VertexAttrib2fv(index, v);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
-{
-    d_2_0_Core->f.VertexAttrib2f(index, x, y);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttrib2dv(GLuint index, const GLdouble *v)
-{
-    d_2_0_Core->f.VertexAttrib2dv(index, v);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
-{
-    d_2_0_Core->f.VertexAttrib2d(index, x, y);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttrib1sv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib1sv(index, v);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttrib1s(GLuint index, GLshort x)
-{
-    d_2_0_Core->f.VertexAttrib1s(index, x);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttrib1fv(GLuint index, const GLfloat *v)
-{
-    d_2_0_Core->f.VertexAttrib1fv(index, v);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttrib1f(GLuint index, GLfloat x)
-{
-    d_2_0_Core->f.VertexAttrib1f(index, x);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttrib1dv(GLuint index, const GLdouble *v)
-{
-    d_2_0_Core->f.VertexAttrib1dv(index, v);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttrib1d(GLuint index, GLdouble x)
-{
-    d_2_0_Core->f.VertexAttrib1d(index, x);
-}
-
-
-// OpenGL 2.1 deprecated functions
-
-// OpenGL 3.0 deprecated functions
-inline void QOpenGLFunctions_3_0::glVertexAttribI4usv(GLuint index, const GLushort *v)
-{
-    d_3_0_Core->f.VertexAttribI4usv(index, v);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttribI4ubv(GLuint index, const GLubyte *v)
-{
-    d_3_0_Core->f.VertexAttribI4ubv(index, v);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttribI4sv(GLuint index, const GLshort *v)
-{
-    d_3_0_Core->f.VertexAttribI4sv(index, v);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttribI4bv(GLuint index, const GLbyte *v)
-{
-    d_3_0_Core->f.VertexAttribI4bv(index, v);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttribI4uiv(GLuint index, const GLuint *v)
-{
-    d_3_0_Core->f.VertexAttribI4uiv(index, v);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttribI3uiv(GLuint index, const GLuint *v)
-{
-    d_3_0_Core->f.VertexAttribI3uiv(index, v);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttribI2uiv(GLuint index, const GLuint *v)
-{
-    d_3_0_Core->f.VertexAttribI2uiv(index, v);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttribI1uiv(GLuint index, const GLuint *v)
-{
-    d_3_0_Core->f.VertexAttribI1uiv(index, v);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttribI4iv(GLuint index, const GLint *v)
-{
-    d_3_0_Core->f.VertexAttribI4iv(index, v);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttribI3iv(GLuint index, const GLint *v)
-{
-    d_3_0_Core->f.VertexAttribI3iv(index, v);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttribI2iv(GLuint index, const GLint *v)
-{
-    d_3_0_Core->f.VertexAttribI2iv(index, v);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttribI1iv(GLuint index, const GLint *v)
-{
-    d_3_0_Core->f.VertexAttribI1iv(index, v);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
-{
-    d_3_0_Core->f.VertexAttribI4ui(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z)
-{
-    d_3_0_Core->f.VertexAttribI3ui(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttribI2ui(GLuint index, GLuint x, GLuint y)
-{
-    d_3_0_Core->f.VertexAttribI2ui(index, x, y);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttribI1ui(GLuint index, GLuint x)
-{
-    d_3_0_Core->f.VertexAttribI1ui(index, x);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
-{
-    d_3_0_Core->f.VertexAttribI4i(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttribI3i(GLuint index, GLint x, GLint y, GLint z)
-{
-    d_3_0_Core->f.VertexAttribI3i(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttribI2i(GLuint index, GLint x, GLint y)
-{
-    d_3_0_Core->f.VertexAttribI2i(index, x, y);
-}
-
-inline void QOpenGLFunctions_3_0::glVertexAttribI1i(GLuint index, GLint x)
-{
-    d_3_0_Core->f.VertexAttribI1i(index, x);
-}
-
-
-
-QT_END_NAMESPACE
-
-#endif // QT_NO_OPENGL && !QT_OPENGL_ES_2
-
-#endif
diff --git a/src/gui/opengl/qopenglfunctions_3_1.cpp b/src/gui/opengl/qopenglfunctions_3_1.cpp
deleted file mode 100644
index c25b124af8..0000000000
--- a/src/gui/opengl/qopenglfunctions_3_1.cpp
+++ /dev/null
@@ -1,205 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#include "qopenglfunctions_3_1.h"
-#include "qopenglcontext.h"
-
-QT_BEGIN_NAMESPACE
-
-/*!
-    \class QOpenGLFunctions_3_1
-    \inmodule QtGui
-    \since 5.1
-    \wrapper
-    \brief The QOpenGLFunctions_3_1 class provides all functions for OpenGL 3.1 specification.
-
-    This class is a wrapper for functions from OpenGL 3.1 specification.
-    See reference pages on \l {http://www.opengl.org/sdk/docs/}{opengl.org}
-    for function documentation.
-
-    \sa QAbstractOpenGLFunctions
-*/
-
-QOpenGLFunctions_3_1::QOpenGLFunctions_3_1()
- : QAbstractOpenGLFunctions()
- , d_1_0_Core(nullptr)
- , d_1_1_Core(nullptr)
- , d_1_2_Core(nullptr)
- , d_1_3_Core(nullptr)
- , d_1_4_Core(nullptr)
- , d_1_5_Core(nullptr)
- , d_2_0_Core(nullptr)
- , d_2_1_Core(nullptr)
- , d_3_0_Core(nullptr)
- , d_3_1_Core(nullptr)
-{
-}
-
-QOpenGLFunctions_3_1::~QOpenGLFunctions_3_1()
-{
-    if (d_1_0_Core) {
-        d_1_0_Core->refs.deref();
-        Q_ASSERT(d_1_0_Core->refs.loadRelaxed());
-    }
-    if (d_1_1_Core) {
-        d_1_1_Core->refs.deref();
-        Q_ASSERT(d_1_1_Core->refs.loadRelaxed());
-    }
-    if (d_1_2_Core) {
-        d_1_2_Core->refs.deref();
-        Q_ASSERT(d_1_2_Core->refs.loadRelaxed());
-    }
-    if (d_1_3_Core) {
-        d_1_3_Core->refs.deref();
-        Q_ASSERT(d_1_3_Core->refs.loadRelaxed());
-    }
-    if (d_1_4_Core) {
-        d_1_4_Core->refs.deref();
-        Q_ASSERT(d_1_4_Core->refs.loadRelaxed());
-    }
-    if (d_1_5_Core) {
-        d_1_5_Core->refs.deref();
-        Q_ASSERT(d_1_5_Core->refs.loadRelaxed());
-    }
-    if (d_2_0_Core) {
-        d_2_0_Core->refs.deref();
-        Q_ASSERT(d_2_0_Core->refs.loadRelaxed());
-    }
-    if (d_2_1_Core) {
-        d_2_1_Core->refs.deref();
-        Q_ASSERT(d_2_1_Core->refs.loadRelaxed());
-    }
-    if (d_3_0_Core) {
-        d_3_0_Core->refs.deref();
-        Q_ASSERT(d_3_0_Core->refs.loadRelaxed());
-    }
-    if (d_3_1_Core) {
-        d_3_1_Core->refs.deref();
-        Q_ASSERT(d_3_1_Core->refs.loadRelaxed());
-    }
-}
-
-bool QOpenGLFunctions_3_1::initializeOpenGLFunctions()
-{
-    if ( isInitialized() )
-        return true;
-
-    QOpenGLContext* context = QOpenGLContext::currentContext();
-
-    // If owned by a context object make sure it is current.
-    // Also check that current context is capable of resolving all needed functions
-    if (((owningContext() && owningContext() == context) || !owningContext())
-        && QOpenGLFunctions_3_1::isContextCompatible(context))
-    {
-        // Associate with private implementation, creating if necessary
-        // Function pointers in the backends are resolved at creation time
-        QOpenGLVersionFunctionsBackend* d = nullptr;
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        d_1_3_Core = static_cast<QOpenGLFunctions_1_3_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        d_1_4_Core = static_cast<QOpenGLFunctions_1_4_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        d_1_5_Core = static_cast<QOpenGLFunctions_1_5_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        d_2_0_Core = static_cast<QOpenGLFunctions_2_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        d_2_1_Core = static_cast<QOpenGLFunctions_2_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        d_3_0_Core = static_cast<QOpenGLFunctions_3_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
-        d_3_1_Core = static_cast<QOpenGLFunctions_3_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        QAbstractOpenGLFunctions::initializeOpenGLFunctions();
-    }
-    return isInitialized();
-}
-
-bool QOpenGLFunctions_3_1::isContextCompatible(QOpenGLContext *context)
-{
-    Q_ASSERT(context);
-    QSurfaceFormat f = context->format();
-    const QPair<int, int> v = qMakePair(f.majorVersion(), f.minorVersion());
-    if (v < qMakePair(3, 1))
-        return false;
-
-    return true;
-}
-
-QOpenGLVersionProfile QOpenGLFunctions_3_1::versionProfile()
-{
-    QOpenGLVersionProfile v;
-    v.setVersion(3, 1);
-    return v;
-}
-
-QT_END_NAMESPACE
diff --git a/src/gui/opengl/qopenglfunctions_3_1.h b/src/gui/opengl/qopenglfunctions_3_1.h
deleted file mode 100644
index 3a8d3891f3..0000000000
--- a/src/gui/opengl/qopenglfunctions_3_1.h
+++ /dev/null
@@ -1,1601 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#ifndef QOPENGLVERSIONFUNCTIONS_3_1_H
-#define QOPENGLVERSIONFUNCTIONS_3_1_H
-
-#include <QtGui/qtguiglobal.h>
-
-#if !defined(QT_NO_OPENGL) && !defined(QT_OPENGL_ES_2)
-
-#include <QtGui/QOpenGLVersionFunctions>
-#include <QtGui/qopenglcontext.h>
-
-QT_BEGIN_NAMESPACE
-
-class Q_GUI_EXPORT QOpenGLFunctions_3_1 : public QAbstractOpenGLFunctions
-{
-public:
-    QOpenGLFunctions_3_1();
-    ~QOpenGLFunctions_3_1();
-
-    bool initializeOpenGLFunctions() override;
-
-    // OpenGL 1.0 core functions
-    void glViewport(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glDepthRange(GLdouble nearVal, GLdouble farVal);
-    GLboolean glIsEnabled(GLenum cap);
-    void glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params);
-    void glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params);
-    void glGetTexParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
-    const GLubyte * glGetString(GLenum name);
-    void glGetIntegerv(GLenum pname, GLint *params);
-    void glGetFloatv(GLenum pname, GLfloat *params);
-    GLenum glGetError();
-    void glGetDoublev(GLenum pname, GLdouble *params);
-    void glGetBooleanv(GLenum pname, GLboolean *params);
-    void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
-    void glReadBuffer(GLenum mode);
-    void glPixelStorei(GLenum pname, GLint param);
-    void glPixelStoref(GLenum pname, GLfloat param);
-    void glDepthFunc(GLenum func);
-    void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass);
-    void glStencilFunc(GLenum func, GLint ref, GLuint mask);
-    void glLogicOp(GLenum opcode);
-    void glBlendFunc(GLenum sfactor, GLenum dfactor);
-    void glFlush();
-    void glFinish();
-    void glEnable(GLenum cap);
-    void glDisable(GLenum cap);
-    void glDepthMask(GLboolean flag);
-    void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
-    void glStencilMask(GLuint mask);
-    void glClearDepth(GLdouble depth);
-    void glClearStencil(GLint s);
-    void glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glClear(GLbitfield mask);
-    void glDrawBuffer(GLenum mode);
-    void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glTexParameteri(GLenum target, GLenum pname, GLint param);
-    void glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glTexParameterf(GLenum target, GLenum pname, GLfloat param);
-    void glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glPolygonMode(GLenum face, GLenum mode);
-    void glPointSize(GLfloat size);
-    void glLineWidth(GLfloat width);
-    void glHint(GLenum target, GLenum mode);
-    void glFrontFace(GLenum mode);
-    void glCullFace(GLenum mode);
-
-    // OpenGL 1.1 core functions
-    void glIndexubv(const GLubyte *c);
-    void glIndexub(GLubyte c);
-    GLboolean glIsTexture(GLuint texture);
-    void glGenTextures(GLsizei n, GLuint *textures);
-    void glDeleteTextures(GLsizei n, const GLuint *textures);
-    void glBindTexture(GLenum target, GLuint texture);
-    void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
-    void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
-    void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
-    void glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
-    void glPolygonOffset(GLfloat factor, GLfloat units);
-    void glGetPointerv(GLenum pname, GLvoid* *params);
-    void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
-    void glDrawArrays(GLenum mode, GLint first, GLsizei count);
-
-    // OpenGL 1.2 core functions
-    void glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices);
-    void glBlendEquation(GLenum mode);
-    void glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-
-    // OpenGL 1.3 core functions
-    void glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img);
-    void glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glSampleCoverage(GLfloat value, GLboolean invert);
-    void glActiveTexture(GLenum texture);
-
-    // OpenGL 1.4 core functions
-    void glPointParameteriv(GLenum pname, const GLint *params);
-    void glPointParameteri(GLenum pname, GLint param);
-    void glPointParameterfv(GLenum pname, const GLfloat *params);
-    void glPointParameterf(GLenum pname, GLfloat param);
-    void glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount);
-    void glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount);
-    void glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
-
-    // OpenGL 1.5 core functions
-    void glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params);
-    void glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params);
-    GLboolean glUnmapBuffer(GLenum target);
-    GLvoid* glMapBuffer(GLenum target, GLenum access);
-    void glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data);
-    void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data);
-    void glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage);
-    GLboolean glIsBuffer(GLuint buffer);
-    void glGenBuffers(GLsizei n, GLuint *buffers);
-    void glDeleteBuffers(GLsizei n, const GLuint *buffers);
-    void glBindBuffer(GLenum target, GLuint buffer);
-    void glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params);
-    void glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params);
-    void glGetQueryiv(GLenum target, GLenum pname, GLint *params);
-    void glEndQuery(GLenum target);
-    void glBeginQuery(GLenum target, GLuint id);
-    GLboolean glIsQuery(GLuint id);
-    void glDeleteQueries(GLsizei n, const GLuint *ids);
-    void glGenQueries(GLsizei n, GLuint *ids);
-
-    // OpenGL 2.0 core functions
-    void glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer);
-    void glValidateProgram(GLuint program);
-    void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniform4iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform3iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform2iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform1iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform4fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform3fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform2fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform1fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
-    void glUniform3i(GLint location, GLint v0, GLint v1, GLint v2);
-    void glUniform2i(GLint location, GLint v0, GLint v1);
-    void glUniform1i(GLint location, GLint v0);
-    void glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
-    void glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
-    void glUniform2f(GLint location, GLfloat v0, GLfloat v1);
-    void glUniform1f(GLint location, GLfloat v0);
-    void glUseProgram(GLuint program);
-    void glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length);
-    void glLinkProgram(GLuint program);
-    GLboolean glIsShader(GLuint shader);
-    GLboolean glIsProgram(GLuint program);
-    void glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer);
-    void glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params);
-    void glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params);
-    void glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params);
-    void glGetUniformiv(GLuint program, GLint location, GLint *params);
-    void glGetUniformfv(GLuint program, GLint location, GLfloat *params);
-    GLint glGetUniformLocation(GLuint program, const GLchar *name);
-    void glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source);
-    void glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void glGetShaderiv(GLuint shader, GLenum pname, GLint *params);
-    void glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void glGetProgramiv(GLuint program, GLenum pname, GLint *params);
-    GLint glGetAttribLocation(GLuint program, const GLchar *name);
-    void glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj);
-    void glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
-    void glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
-    void glEnableVertexAttribArray(GLuint index);
-    void glDisableVertexAttribArray(GLuint index);
-    void glDetachShader(GLuint program, GLuint shader);
-    void glDeleteShader(GLuint shader);
-    void glDeleteProgram(GLuint program);
-    GLuint glCreateShader(GLenum type);
-    GLuint glCreateProgram();
-    void glCompileShader(GLuint shader);
-    void glBindAttribLocation(GLuint program, GLuint index, const GLchar *name);
-    void glAttachShader(GLuint program, GLuint shader);
-    void glStencilMaskSeparate(GLenum face, GLuint mask);
-    void glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask);
-    void glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);
-    void glDrawBuffers(GLsizei n, const GLenum *bufs);
-    void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha);
-
-    // OpenGL 2.1 core functions
-    void glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-
-    // OpenGL 3.0 core functions
-    GLboolean glIsVertexArray(GLuint array);
-    void glGenVertexArrays(GLsizei n, GLuint *arrays);
-    void glDeleteVertexArrays(GLsizei n, const GLuint *arrays);
-    void glBindVertexArray(GLuint array);
-    void glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length);
-    GLvoid* glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
-    void glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
-    void glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
-    void glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
-    void glGenerateMipmap(GLenum target);
-    void glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params);
-    void glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
-    void glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset);
-    void glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
-    void glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
-    GLenum glCheckFramebufferStatus(GLenum target);
-    void glGenFramebuffers(GLsizei n, GLuint *framebuffers);
-    void glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers);
-    void glBindFramebuffer(GLenum target, GLuint framebuffer);
-    GLboolean glIsFramebuffer(GLuint framebuffer);
-    void glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
-    void glGenRenderbuffers(GLsizei n, GLuint *renderbuffers);
-    void glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers);
-    void glBindRenderbuffer(GLenum target, GLuint renderbuffer);
-    GLboolean glIsRenderbuffer(GLuint renderbuffer);
-    const GLubyte * glGetStringi(GLenum name, GLuint index);
-    void glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
-    void glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value);
-    void glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value);
-    void glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value);
-    void glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params);
-    void glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params);
-    void glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params);
-    void glTexParameterIiv(GLenum target, GLenum pname, const GLint *params);
-    void glUniform4uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform3uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform2uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform1uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
-    void glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2);
-    void glUniform2ui(GLint location, GLuint v0, GLuint v1);
-    void glUniform1ui(GLint location, GLuint v0);
-    GLint glGetFragDataLocation(GLuint program, const GLchar *name);
-    void glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name);
-    void glGetUniformuiv(GLuint program, GLint location, GLuint *params);
-    void glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params);
-    void glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params);
-    void glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glEndConditionalRender();
-    void glBeginConditionalRender(GLuint id, GLenum mode);
-    void glClampColor(GLenum target, GLenum clamp);
-    void glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name);
-    void glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode);
-    void glBindBufferBase(GLenum target, GLuint index, GLuint buffer);
-    void glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
-    void glEndTransformFeedback();
-    void glBeginTransformFeedback(GLenum primitiveMode);
-    GLboolean glIsEnabledi(GLenum target, GLuint index);
-    void glDisablei(GLenum target, GLuint index);
-    void glEnablei(GLenum target, GLuint index);
-    void glGetIntegeri_v(GLenum target, GLuint index, GLint *data);
-    void glGetBooleani_v(GLenum target, GLuint index, GLboolean *data);
-    void glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a);
-
-    // OpenGL 3.1 core functions
-    void glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
-    void glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);
-    void glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName);
-    void glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params);
-    GLuint glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName);
-    void glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName);
-    void glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params);
-    void glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const *uniformNames, GLuint *uniformIndices);
-    void glPrimitiveRestartIndex(GLuint index);
-    void glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer);
-    void glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount);
-    void glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount);
-
-private:
-    friend class QOpenGLContext;
-
-    static bool isContextCompatible(QOpenGLContext *context);
-    static QOpenGLVersionProfile versionProfile();
-
-    QOpenGLFunctions_1_0_CoreBackend* d_1_0_Core;
-    QOpenGLFunctions_1_1_CoreBackend* d_1_1_Core;
-    QOpenGLFunctions_1_2_CoreBackend* d_1_2_Core;
-    QOpenGLFunctions_1_3_CoreBackend* d_1_3_Core;
-    QOpenGLFunctions_1_4_CoreBackend* d_1_4_Core;
-    QOpenGLFunctions_1_5_CoreBackend* d_1_5_Core;
-    QOpenGLFunctions_2_0_CoreBackend* d_2_0_Core;
-    QOpenGLFunctions_2_1_CoreBackend* d_2_1_Core;
-    QOpenGLFunctions_3_0_CoreBackend* d_3_0_Core;
-    QOpenGLFunctions_3_1_CoreBackend* d_3_1_Core;
-};
-
-// OpenGL 1.0 core functions
-inline void QOpenGLFunctions_3_1::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_0_Core->f.Viewport(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_3_1::glDepthRange(GLdouble nearVal, GLdouble farVal)
-{
-    d_1_0_Core->f.DepthRange(nearVal, farVal);
-}
-
-inline GLboolean QOpenGLFunctions_3_1::glIsEnabled(GLenum cap)
-{
-    return d_1_0_Core->f.IsEnabled(cap);
-}
-
-inline void QOpenGLFunctions_3_1::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
-}
-
-inline void QOpenGLFunctions_3_1::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
-}
-
-inline void QOpenGLFunctions_3_1::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetTexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_1::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetTexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_1::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
-{
-    d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
-}
-
-inline const GLubyte * QOpenGLFunctions_3_1::glGetString(GLenum name)
-{
-    return d_1_0_Core->f.GetString(name);
-}
-
-inline void QOpenGLFunctions_3_1::glGetIntegerv(GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetIntegerv(pname, params);
-}
-
-inline void QOpenGLFunctions_3_1::glGetFloatv(GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetFloatv(pname, params);
-}
-
-inline GLenum QOpenGLFunctions_3_1::glGetError()
-{
-    return d_1_0_Core->f.GetError();
-}
-
-inline void QOpenGLFunctions_3_1::glGetDoublev(GLenum pname, GLdouble *params)
-{
-    d_1_0_Core->f.GetDoublev(pname, params);
-}
-
-inline void QOpenGLFunctions_3_1::glGetBooleanv(GLenum pname, GLboolean *params)
-{
-    d_1_0_Core->f.GetBooleanv(pname, params);
-}
-
-inline void QOpenGLFunctions_3_1::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
-{
-    d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_3_1::glReadBuffer(GLenum mode)
-{
-    d_1_0_Core->f.ReadBuffer(mode);
-}
-
-inline void QOpenGLFunctions_3_1::glPixelStorei(GLenum pname, GLint param)
-{
-    d_1_0_Core->f.PixelStorei(pname, param);
-}
-
-inline void QOpenGLFunctions_3_1::glPixelStoref(GLenum pname, GLfloat param)
-{
-    d_1_0_Core->f.PixelStoref(pname, param);
-}
-
-inline void QOpenGLFunctions_3_1::glDepthFunc(GLenum func)
-{
-    d_1_0_Core->f.DepthFunc(func);
-}
-
-inline void QOpenGLFunctions_3_1::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
-{
-    d_1_0_Core->f.StencilOp(fail, zfail, zpass);
-}
-
-inline void QOpenGLFunctions_3_1::glStencilFunc(GLenum func, GLint ref, GLuint mask)
-{
-    d_1_0_Core->f.StencilFunc(func, ref, mask);
-}
-
-inline void QOpenGLFunctions_3_1::glLogicOp(GLenum opcode)
-{
-    d_1_0_Core->f.LogicOp(opcode);
-}
-
-inline void QOpenGLFunctions_3_1::glBlendFunc(GLenum sfactor, GLenum dfactor)
-{
-    d_1_0_Core->f.BlendFunc(sfactor, dfactor);
-}
-
-inline void QOpenGLFunctions_3_1::glFlush()
-{
-    d_1_0_Core->f.Flush();
-}
-
-inline void QOpenGLFunctions_3_1::glFinish()
-{
-    d_1_0_Core->f.Finish();
-}
-
-inline void QOpenGLFunctions_3_1::glEnable(GLenum cap)
-{
-    d_1_0_Core->f.Enable(cap);
-}
-
-inline void QOpenGLFunctions_3_1::glDisable(GLenum cap)
-{
-    d_1_0_Core->f.Disable(cap);
-}
-
-inline void QOpenGLFunctions_3_1::glDepthMask(GLboolean flag)
-{
-    d_1_0_Core->f.DepthMask(flag);
-}
-
-inline void QOpenGLFunctions_3_1::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
-{
-    d_1_0_Core->f.ColorMask(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_3_1::glStencilMask(GLuint mask)
-{
-    d_1_0_Core->f.StencilMask(mask);
-}
-
-inline void QOpenGLFunctions_3_1::glClearDepth(GLdouble depth)
-{
-    d_1_0_Core->f.ClearDepth(depth);
-}
-
-inline void QOpenGLFunctions_3_1::glClearStencil(GLint s)
-{
-    d_1_0_Core->f.ClearStencil(s);
-}
-
-inline void QOpenGLFunctions_3_1::glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Core->f.ClearColor(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_3_1::glClear(GLbitfield mask)
-{
-    d_1_0_Core->f.Clear(mask);
-}
-
-inline void QOpenGLFunctions_3_1::glDrawBuffer(GLenum mode)
-{
-    d_1_0_Core->f.DrawBuffer(mode);
-}
-
-inline void QOpenGLFunctions_3_1::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Core->f.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_3_1::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Core->f.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_3_1::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_0_Core->f.TexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_1::glTexParameteri(GLenum target, GLenum pname, GLint param)
-{
-    d_1_0_Core->f.TexParameteri(target, pname, param);
-}
-
-inline void QOpenGLFunctions_3_1::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Core->f.TexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_1::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
-{
-    d_1_0_Core->f.TexParameterf(target, pname, param);
-}
-
-inline void QOpenGLFunctions_3_1::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_0_Core->f.Scissor(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_3_1::glPolygonMode(GLenum face, GLenum mode)
-{
-    d_1_0_Core->f.PolygonMode(face, mode);
-}
-
-inline void QOpenGLFunctions_3_1::glPointSize(GLfloat size)
-{
-    d_1_0_Core->f.PointSize(size);
-}
-
-inline void QOpenGLFunctions_3_1::glLineWidth(GLfloat width)
-{
-    d_1_0_Core->f.LineWidth(width);
-}
-
-inline void QOpenGLFunctions_3_1::glHint(GLenum target, GLenum mode)
-{
-    d_1_0_Core->f.Hint(target, mode);
-}
-
-inline void QOpenGLFunctions_3_1::glFrontFace(GLenum mode)
-{
-    d_1_0_Core->f.FrontFace(mode);
-}
-
-inline void QOpenGLFunctions_3_1::glCullFace(GLenum mode)
-{
-    d_1_0_Core->f.CullFace(mode);
-}
-
-
-// OpenGL 1.1 core functions
-inline void QOpenGLFunctions_3_1::glIndexubv(const GLubyte *c)
-{
-    Q_UNUSED(c);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_3_1::glIndexub(GLubyte c)
-{
-    Q_UNUSED(c);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline GLboolean QOpenGLFunctions_3_1::glIsTexture(GLuint texture)
-{
-    return d_1_1_Core->f.IsTexture(texture);
-}
-
-inline void QOpenGLFunctions_3_1::glGenTextures(GLsizei n, GLuint *textures)
-{
-    d_1_1_Core->f.GenTextures(n, textures);
-}
-
-inline void QOpenGLFunctions_3_1::glDeleteTextures(GLsizei n, const GLuint *textures)
-{
-    d_1_1_Core->f.DeleteTextures(n, textures);
-}
-
-inline void QOpenGLFunctions_3_1::glBindTexture(GLenum target, GLuint texture)
-{
-    d_1_1_Core->f.BindTexture(target, texture);
-}
-
-inline void QOpenGLFunctions_3_1::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_1_Core->f.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_3_1::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_1_Core->f.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_3_1::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_1_Core->f.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_3_1::glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
-{
-    d_1_1_Core->f.CopyTexSubImage1D(target, level, xoffset, x, y, width);
-}
-
-inline void QOpenGLFunctions_3_1::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
-{
-    d_1_1_Core->f.CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
-}
-
-inline void QOpenGLFunctions_3_1::glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
-{
-    d_1_1_Core->f.CopyTexImage1D(target, level, internalformat, x, y, width, border);
-}
-
-inline void QOpenGLFunctions_3_1::glPolygonOffset(GLfloat factor, GLfloat units)
-{
-    d_1_1_Core->f.PolygonOffset(factor, units);
-}
-
-inline void QOpenGLFunctions_3_1::glGetPointerv(GLenum pname, GLvoid* *params)
-{
-    Q_UNUSED(pname);
-    Q_UNUSED(params);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_3_1::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
-{
-    d_1_1_Core->f.DrawElements(mode, count, type, indices);
-}
-
-inline void QOpenGLFunctions_3_1::glDrawArrays(GLenum mode, GLint first, GLsizei count)
-{
-    d_1_1_Core->f.DrawArrays(mode, first, count);
-}
-
-
-// OpenGL 1.2 core functions
-inline void QOpenGLFunctions_3_1::glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_2_Core->f.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_3_1::glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_2_Core->f.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_3_1::glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_2_Core->f.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_3_1::glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
-{
-    d_1_2_Core->f.DrawRangeElements(mode, start, end, count, type, indices);
-}
-
-inline void QOpenGLFunctions_3_1::glBlendEquation(GLenum mode)
-{
-    d_1_2_Core->f.BlendEquation(mode);
-}
-
-inline void QOpenGLFunctions_3_1::glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_2_Core->f.BlendColor(red, green, blue, alpha);
-}
-
-
-// OpenGL 1.3 core functions
-inline void QOpenGLFunctions_3_1::glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img)
-{
-    d_1_3_Core->f.GetCompressedTexImage(target, level, img);
-}
-
-inline void QOpenGLFunctions_3_1::glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_3_1::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_3_1::glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_3_1::glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_3_1::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_3_1::glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_3_1::glSampleCoverage(GLfloat value, GLboolean invert)
-{
-    d_1_3_Core->f.SampleCoverage(value, invert);
-}
-
-inline void QOpenGLFunctions_3_1::glActiveTexture(GLenum texture)
-{
-    d_1_3_Core->f.ActiveTexture(texture);
-}
-
-
-// OpenGL 1.4 core functions
-inline void QOpenGLFunctions_3_1::glPointParameteriv(GLenum pname, const GLint *params)
-{
-    d_1_4_Core->f.PointParameteriv(pname, params);
-}
-
-inline void QOpenGLFunctions_3_1::glPointParameteri(GLenum pname, GLint param)
-{
-    d_1_4_Core->f.PointParameteri(pname, param);
-}
-
-inline void QOpenGLFunctions_3_1::glPointParameterfv(GLenum pname, const GLfloat *params)
-{
-    d_1_4_Core->f.PointParameterfv(pname, params);
-}
-
-inline void QOpenGLFunctions_3_1::glPointParameterf(GLenum pname, GLfloat param)
-{
-    d_1_4_Core->f.PointParameterf(pname, param);
-}
-
-inline void QOpenGLFunctions_3_1::glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount)
-{
-    d_1_4_Core->f.MultiDrawElements(mode, count, type, indices, drawcount);
-}
-
-inline void QOpenGLFunctions_3_1::glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
-{
-    d_1_4_Core->f.MultiDrawArrays(mode, first, count, drawcount);
-}
-
-inline void QOpenGLFunctions_3_1::glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
-{
-    d_1_4_Core->f.BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
-}
-
-
-// OpenGL 1.5 core functions
-inline void QOpenGLFunctions_3_1::glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params)
-{
-    d_1_5_Core->f.GetBufferPointerv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_1::glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetBufferParameteriv(target, pname, params);
-}
-
-inline GLboolean QOpenGLFunctions_3_1::glUnmapBuffer(GLenum target)
-{
-    return d_1_5_Core->f.UnmapBuffer(target);
-}
-
-inline GLvoid* QOpenGLFunctions_3_1::glMapBuffer(GLenum target, GLenum access)
-{
-    return d_1_5_Core->f.MapBuffer(target, access);
-}
-
-inline void QOpenGLFunctions_3_1::glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data)
-{
-    d_1_5_Core->f.GetBufferSubData(target, offset, size, data);
-}
-
-inline void QOpenGLFunctions_3_1::glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data)
-{
-    d_1_5_Core->f.BufferSubData(target, offset, size, data);
-}
-
-inline void QOpenGLFunctions_3_1::glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)
-{
-    d_1_5_Core->f.BufferData(target, size, data, usage);
-}
-
-inline GLboolean QOpenGLFunctions_3_1::glIsBuffer(GLuint buffer)
-{
-    return d_1_5_Core->f.IsBuffer(buffer);
-}
-
-inline void QOpenGLFunctions_3_1::glGenBuffers(GLsizei n, GLuint *buffers)
-{
-    d_1_5_Core->f.GenBuffers(n, buffers);
-}
-
-inline void QOpenGLFunctions_3_1::glDeleteBuffers(GLsizei n, const GLuint *buffers)
-{
-    d_1_5_Core->f.DeleteBuffers(n, buffers);
-}
-
-inline void QOpenGLFunctions_3_1::glBindBuffer(GLenum target, GLuint buffer)
-{
-    d_1_5_Core->f.BindBuffer(target, buffer);
-}
-
-inline void QOpenGLFunctions_3_1::glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
-{
-    d_1_5_Core->f.GetQueryObjectuiv(id, pname, params);
-}
-
-inline void QOpenGLFunctions_3_1::glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetQueryObjectiv(id, pname, params);
-}
-
-inline void QOpenGLFunctions_3_1::glGetQueryiv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetQueryiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_1::glEndQuery(GLenum target)
-{
-    d_1_5_Core->f.EndQuery(target);
-}
-
-inline void QOpenGLFunctions_3_1::glBeginQuery(GLenum target, GLuint id)
-{
-    d_1_5_Core->f.BeginQuery(target, id);
-}
-
-inline GLboolean QOpenGLFunctions_3_1::glIsQuery(GLuint id)
-{
-    return d_1_5_Core->f.IsQuery(id);
-}
-
-inline void QOpenGLFunctions_3_1::glDeleteQueries(GLsizei n, const GLuint *ids)
-{
-    d_1_5_Core->f.DeleteQueries(n, ids);
-}
-
-inline void QOpenGLFunctions_3_1::glGenQueries(GLsizei n, GLuint *ids)
-{
-    d_1_5_Core->f.GenQueries(n, ids);
-}
-
-
-// OpenGL 2.0 core functions
-inline void QOpenGLFunctions_3_1::glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer)
-{
-    d_2_0_Core->f.VertexAttribPointer(index, size, type, normalized, stride, pointer);
-}
-
-inline void QOpenGLFunctions_3_1::glValidateProgram(GLuint program)
-{
-    d_2_0_Core->f.ValidateProgram(program);
-}
-
-inline void QOpenGLFunctions_3_1::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_3_1::glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix3fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_3_1::glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_3_1::glUniform4iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform4iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_1::glUniform3iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform3iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_1::glUniform2iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform2iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_1::glUniform1iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform1iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_1::glUniform4fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform4fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_1::glUniform3fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform3fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_1::glUniform2fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform2fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_1::glUniform1fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform1fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_1::glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
-{
-    d_2_0_Core->f.Uniform4i(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_3_1::glUniform3i(GLint location, GLint v0, GLint v1, GLint v2)
-{
-    d_2_0_Core->f.Uniform3i(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_3_1::glUniform2i(GLint location, GLint v0, GLint v1)
-{
-    d_2_0_Core->f.Uniform2i(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_3_1::glUniform1i(GLint location, GLint v0)
-{
-    d_2_0_Core->f.Uniform1i(location, v0);
-}
-
-inline void QOpenGLFunctions_3_1::glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
-{
-    d_2_0_Core->f.Uniform4f(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_3_1::glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
-{
-    d_2_0_Core->f.Uniform3f(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_3_1::glUniform2f(GLint location, GLfloat v0, GLfloat v1)
-{
-    d_2_0_Core->f.Uniform2f(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_3_1::glUniform1f(GLint location, GLfloat v0)
-{
-    d_2_0_Core->f.Uniform1f(location, v0);
-}
-
-inline void QOpenGLFunctions_3_1::glUseProgram(GLuint program)
-{
-    d_2_0_Core->f.UseProgram(program);
-}
-
-inline void QOpenGLFunctions_3_1::glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length)
-{
-    d_2_0_Core->f.ShaderSource(shader, count, string, length);
-}
-
-inline void QOpenGLFunctions_3_1::glLinkProgram(GLuint program)
-{
-    d_2_0_Core->f.LinkProgram(program);
-}
-
-inline GLboolean QOpenGLFunctions_3_1::glIsShader(GLuint shader)
-{
-    return d_2_0_Core->f.IsShader(shader);
-}
-
-inline GLboolean QOpenGLFunctions_3_1::glIsProgram(GLuint program)
-{
-    return d_2_0_Core->f.IsProgram(program);
-}
-
-inline void QOpenGLFunctions_3_1::glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer)
-{
-    d_2_0_Core->f.GetVertexAttribPointerv(index, pname, pointer);
-}
-
-inline void QOpenGLFunctions_3_1::glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetVertexAttribiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_3_1::glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
-{
-    d_2_0_Core->f.GetVertexAttribfv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_3_1::glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
-{
-    d_2_0_Core->f.GetVertexAttribdv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_3_1::glGetUniformiv(GLuint program, GLint location, GLint *params)
-{
-    d_2_0_Core->f.GetUniformiv(program, location, params);
-}
-
-inline void QOpenGLFunctions_3_1::glGetUniformfv(GLuint program, GLint location, GLfloat *params)
-{
-    d_2_0_Core->f.GetUniformfv(program, location, params);
-}
-
-inline GLint QOpenGLFunctions_3_1::glGetUniformLocation(GLuint program, const GLchar *name)
-{
-    return d_2_0_Core->f.GetUniformLocation(program, name);
-}
-
-inline void QOpenGLFunctions_3_1::glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
-{
-    d_2_0_Core->f.GetShaderSource(shader, bufSize, length, source);
-}
-
-inline void QOpenGLFunctions_3_1::glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-{
-    d_2_0_Core->f.GetShaderInfoLog(shader, bufSize, length, infoLog);
-}
-
-inline void QOpenGLFunctions_3_1::glGetShaderiv(GLuint shader, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetShaderiv(shader, pname, params);
-}
-
-inline void QOpenGLFunctions_3_1::glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-{
-    d_2_0_Core->f.GetProgramInfoLog(program, bufSize, length, infoLog);
-}
-
-inline void QOpenGLFunctions_3_1::glGetProgramiv(GLuint program, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetProgramiv(program, pname, params);
-}
-
-inline GLint QOpenGLFunctions_3_1::glGetAttribLocation(GLuint program, const GLchar *name)
-{
-    return d_2_0_Core->f.GetAttribLocation(program, name);
-}
-
-inline void QOpenGLFunctions_3_1::glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj)
-{
-    d_2_0_Core->f.GetAttachedShaders(program, maxCount, count, obj);
-}
-
-inline void QOpenGLFunctions_3_1::glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
-{
-    d_2_0_Core->f.GetActiveUniform(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_3_1::glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
-{
-    d_2_0_Core->f.GetActiveAttrib(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_3_1::glEnableVertexAttribArray(GLuint index)
-{
-    d_2_0_Core->f.EnableVertexAttribArray(index);
-}
-
-inline void QOpenGLFunctions_3_1::glDisableVertexAttribArray(GLuint index)
-{
-    d_2_0_Core->f.DisableVertexAttribArray(index);
-}
-
-inline void QOpenGLFunctions_3_1::glDetachShader(GLuint program, GLuint shader)
-{
-    d_2_0_Core->f.DetachShader(program, shader);
-}
-
-inline void QOpenGLFunctions_3_1::glDeleteShader(GLuint shader)
-{
-    d_2_0_Core->f.DeleteShader(shader);
-}
-
-inline void QOpenGLFunctions_3_1::glDeleteProgram(GLuint program)
-{
-    d_2_0_Core->f.DeleteProgram(program);
-}
-
-inline GLuint QOpenGLFunctions_3_1::glCreateShader(GLenum type)
-{
-    return d_2_0_Core->f.CreateShader(type);
-}
-
-inline GLuint QOpenGLFunctions_3_1::glCreateProgram()
-{
-    return d_2_0_Core->f.CreateProgram();
-}
-
-inline void QOpenGLFunctions_3_1::glCompileShader(GLuint shader)
-{
-    d_2_0_Core->f.CompileShader(shader);
-}
-
-inline void QOpenGLFunctions_3_1::glBindAttribLocation(GLuint program, GLuint index, const GLchar *name)
-{
-    d_2_0_Core->f.BindAttribLocation(program, index, name);
-}
-
-inline void QOpenGLFunctions_3_1::glAttachShader(GLuint program, GLuint shader)
-{
-    d_2_0_Core->f.AttachShader(program, shader);
-}
-
-inline void QOpenGLFunctions_3_1::glStencilMaskSeparate(GLenum face, GLuint mask)
-{
-    d_2_0_Core->f.StencilMaskSeparate(face, mask);
-}
-
-inline void QOpenGLFunctions_3_1::glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
-{
-    d_2_0_Core->f.StencilFuncSeparate(face, func, ref, mask);
-}
-
-inline void QOpenGLFunctions_3_1::glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
-{
-    d_2_0_Core->f.StencilOpSeparate(face, sfail, dpfail, dppass);
-}
-
-inline void QOpenGLFunctions_3_1::glDrawBuffers(GLsizei n, const GLenum *bufs)
-{
-    d_2_0_Core->f.DrawBuffers(n, bufs);
-}
-
-inline void QOpenGLFunctions_3_1::glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
-{
-    d_2_0_Core->f.BlendEquationSeparate(modeRGB, modeAlpha);
-}
-
-
-// OpenGL 2.1 core functions
-inline void QOpenGLFunctions_3_1::glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix4x3fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_3_1::glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix3x4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_3_1::glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix4x2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_3_1::glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix2x4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_3_1::glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix3x2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_3_1::glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix2x3fv(location, count, transpose, value);
-}
-
-
-// OpenGL 3.0 core functions
-inline GLboolean QOpenGLFunctions_3_1::glIsVertexArray(GLuint array)
-{
-    return d_3_0_Core->f.IsVertexArray(array);
-}
-
-inline void QOpenGLFunctions_3_1::glGenVertexArrays(GLsizei n, GLuint *arrays)
-{
-    d_3_0_Core->f.GenVertexArrays(n, arrays);
-}
-
-inline void QOpenGLFunctions_3_1::glDeleteVertexArrays(GLsizei n, const GLuint *arrays)
-{
-    d_3_0_Core->f.DeleteVertexArrays(n, arrays);
-}
-
-inline void QOpenGLFunctions_3_1::glBindVertexArray(GLuint array)
-{
-    d_3_0_Core->f.BindVertexArray(array);
-}
-
-inline void QOpenGLFunctions_3_1::glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
-{
-    d_3_0_Core->f.FlushMappedBufferRange(target, offset, length);
-}
-
-inline GLvoid* QOpenGLFunctions_3_1::glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
-{
-    return d_3_0_Core->f.MapBufferRange(target, offset, length, access);
-}
-
-inline void QOpenGLFunctions_3_1::glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
-{
-    d_3_0_Core->f.FramebufferTextureLayer(target, attachment, texture, level, layer);
-}
-
-inline void QOpenGLFunctions_3_1::glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    d_3_0_Core->f.RenderbufferStorageMultisample(target, samples, internalformat, width, height);
-}
-
-inline void QOpenGLFunctions_3_1::glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
-{
-    d_3_0_Core->f.BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
-}
-
-inline void QOpenGLFunctions_3_1::glGenerateMipmap(GLenum target)
-{
-    d_3_0_Core->f.GenerateMipmap(target);
-}
-
-inline void QOpenGLFunctions_3_1::glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
-}
-
-inline void QOpenGLFunctions_3_1::glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
-{
-    d_3_0_Core->f.FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
-}
-
-inline void QOpenGLFunctions_3_1::glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
-{
-    d_3_0_Core->f.FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
-}
-
-inline void QOpenGLFunctions_3_1::glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
-{
-    d_3_0_Core->f.FramebufferTexture2D(target, attachment, textarget, texture, level);
-}
-
-inline void QOpenGLFunctions_3_1::glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
-{
-    d_3_0_Core->f.FramebufferTexture1D(target, attachment, textarget, texture, level);
-}
-
-inline GLenum QOpenGLFunctions_3_1::glCheckFramebufferStatus(GLenum target)
-{
-    return d_3_0_Core->f.CheckFramebufferStatus(target);
-}
-
-inline void QOpenGLFunctions_3_1::glGenFramebuffers(GLsizei n, GLuint *framebuffers)
-{
-    d_3_0_Core->f.GenFramebuffers(n, framebuffers);
-}
-
-inline void QOpenGLFunctions_3_1::glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
-{
-    d_3_0_Core->f.DeleteFramebuffers(n, framebuffers);
-}
-
-inline void QOpenGLFunctions_3_1::glBindFramebuffer(GLenum target, GLuint framebuffer)
-{
-    d_3_0_Core->f.BindFramebuffer(target, framebuffer);
-}
-
-inline GLboolean QOpenGLFunctions_3_1::glIsFramebuffer(GLuint framebuffer)
-{
-    return d_3_0_Core->f.IsFramebuffer(framebuffer);
-}
-
-inline void QOpenGLFunctions_3_1::glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetRenderbufferParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_1::glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    d_3_0_Core->f.RenderbufferStorage(target, internalformat, width, height);
-}
-
-inline void QOpenGLFunctions_3_1::glGenRenderbuffers(GLsizei n, GLuint *renderbuffers)
-{
-    d_3_0_Core->f.GenRenderbuffers(n, renderbuffers);
-}
-
-inline void QOpenGLFunctions_3_1::glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
-{
-    d_3_0_Core->f.DeleteRenderbuffers(n, renderbuffers);
-}
-
-inline void QOpenGLFunctions_3_1::glBindRenderbuffer(GLenum target, GLuint renderbuffer)
-{
-    d_3_0_Core->f.BindRenderbuffer(target, renderbuffer);
-}
-
-inline GLboolean QOpenGLFunctions_3_1::glIsRenderbuffer(GLuint renderbuffer)
-{
-    return d_3_0_Core->f.IsRenderbuffer(renderbuffer);
-}
-
-inline const GLubyte * QOpenGLFunctions_3_1::glGetStringi(GLenum name, GLuint index)
-{
-    return d_3_0_Core->f.GetStringi(name, index);
-}
-
-inline void QOpenGLFunctions_3_1::glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
-{
-    d_3_0_Core->f.ClearBufferfi(buffer, drawbuffer, depth, stencil);
-}
-
-inline void QOpenGLFunctions_3_1::glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
-{
-    d_3_0_Core->f.ClearBufferfv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_3_1::glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
-{
-    d_3_0_Core->f.ClearBufferuiv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_3_1::glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
-{
-    d_3_0_Core->f.ClearBufferiv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_3_1::glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params)
-{
-    d_3_0_Core->f.GetTexParameterIuiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_1::glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetTexParameterIiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_1::glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params)
-{
-    d_3_0_Core->f.TexParameterIuiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_1::glTexParameterIiv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_3_0_Core->f.TexParameterIiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_1::glUniform4uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform4uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_1::glUniform3uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform3uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_1::glUniform2uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform2uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_1::glUniform1uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform1uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_1::glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
-{
-    d_3_0_Core->f.Uniform4ui(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_3_1::glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
-{
-    d_3_0_Core->f.Uniform3ui(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_3_1::glUniform2ui(GLint location, GLuint v0, GLuint v1)
-{
-    d_3_0_Core->f.Uniform2ui(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_3_1::glUniform1ui(GLint location, GLuint v0)
-{
-    d_3_0_Core->f.Uniform1ui(location, v0);
-}
-
-inline GLint QOpenGLFunctions_3_1::glGetFragDataLocation(GLuint program, const GLchar *name)
-{
-    return d_3_0_Core->f.GetFragDataLocation(program, name);
-}
-
-inline void QOpenGLFunctions_3_1::glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name)
-{
-    d_3_0_Core->f.BindFragDataLocation(program, color, name);
-}
-
-inline void QOpenGLFunctions_3_1::glGetUniformuiv(GLuint program, GLint location, GLuint *params)
-{
-    d_3_0_Core->f.GetUniformuiv(program, location, params);
-}
-
-inline void QOpenGLFunctions_3_1::glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
-{
-    d_3_0_Core->f.GetVertexAttribIuiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_3_1::glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetVertexAttribIiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_3_1::glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_3_0_Core->f.VertexAttribIPointer(index, size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_3_1::glEndConditionalRender()
-{
-    d_3_0_Core->f.EndConditionalRender();
-}
-
-inline void QOpenGLFunctions_3_1::glBeginConditionalRender(GLuint id, GLenum mode)
-{
-    d_3_0_Core->f.BeginConditionalRender(id, mode);
-}
-
-inline void QOpenGLFunctions_3_1::glClampColor(GLenum target, GLenum clamp)
-{
-    d_3_0_Core->f.ClampColor(target, clamp);
-}
-
-inline void QOpenGLFunctions_3_1::glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
-{
-    d_3_0_Core->f.GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_3_1::glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode)
-{
-    d_3_0_Core->f.TransformFeedbackVaryings(program, count, varyings, bufferMode);
-}
-
-inline void QOpenGLFunctions_3_1::glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
-{
-    d_3_0_Core->f.BindBufferBase(target, index, buffer);
-}
-
-inline void QOpenGLFunctions_3_1::glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
-{
-    d_3_0_Core->f.BindBufferRange(target, index, buffer, offset, size);
-}
-
-inline void QOpenGLFunctions_3_1::glEndTransformFeedback()
-{
-    d_3_0_Core->f.EndTransformFeedback();
-}
-
-inline void QOpenGLFunctions_3_1::glBeginTransformFeedback(GLenum primitiveMode)
-{
-    d_3_0_Core->f.BeginTransformFeedback(primitiveMode);
-}
-
-inline GLboolean QOpenGLFunctions_3_1::glIsEnabledi(GLenum target, GLuint index)
-{
-    return d_3_0_Core->f.IsEnabledi(target, index);
-}
-
-inline void QOpenGLFunctions_3_1::glDisablei(GLenum target, GLuint index)
-{
-    d_3_0_Core->f.Disablei(target, index);
-}
-
-inline void QOpenGLFunctions_3_1::glEnablei(GLenum target, GLuint index)
-{
-    d_3_0_Core->f.Enablei(target, index);
-}
-
-inline void QOpenGLFunctions_3_1::glGetIntegeri_v(GLenum target, GLuint index, GLint *data)
-{
-    d_3_0_Core->f.GetIntegeri_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_3_1::glGetBooleani_v(GLenum target, GLuint index, GLboolean *data)
-{
-    d_3_0_Core->f.GetBooleani_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_3_1::glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
-{
-    d_3_0_Core->f.ColorMaski(index, r, g, b, a);
-}
-
-
-// OpenGL 3.1 core functions
-inline void QOpenGLFunctions_3_1::glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
-{
-    d_3_1_Core->f.CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
-}
-
-inline void QOpenGLFunctions_3_1::glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
-{
-    d_3_1_Core->f.UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
-}
-
-inline void QOpenGLFunctions_3_1::glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
-{
-    d_3_1_Core->f.GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
-}
-
-inline void QOpenGLFunctions_3_1::glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params)
-{
-    d_3_1_Core->f.GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
-}
-
-inline GLuint QOpenGLFunctions_3_1::glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName)
-{
-    return d_3_1_Core->f.GetUniformBlockIndex(program, uniformBlockName);
-}
-
-inline void QOpenGLFunctions_3_1::glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName)
-{
-    d_3_1_Core->f.GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
-}
-
-inline void QOpenGLFunctions_3_1::glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params)
-{
-    d_3_1_Core->f.GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
-}
-
-inline void QOpenGLFunctions_3_1::glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const *uniformNames, GLuint *uniformIndices)
-{
-    d_3_1_Core->f.GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
-}
-
-inline void QOpenGLFunctions_3_1::glPrimitiveRestartIndex(GLuint index)
-{
-    d_3_1_Core->f.PrimitiveRestartIndex(index);
-}
-
-inline void QOpenGLFunctions_3_1::glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer)
-{
-    d_3_1_Core->f.TexBuffer(target, internalformat, buffer);
-}
-
-inline void QOpenGLFunctions_3_1::glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount)
-{
-    d_3_1_Core->f.DrawElementsInstanced(mode, count, type, indices, instancecount);
-}
-
-inline void QOpenGLFunctions_3_1::glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount)
-{
-    d_3_1_Core->f.DrawArraysInstanced(mode, first, count, instancecount);
-}
-
-
-
-QT_END_NAMESPACE
-
-#endif // QT_NO_OPENGL && !QT_OPENGL_ES_2
-
-#endif
diff --git a/src/gui/opengl/qopenglfunctions_3_2_compatibility.cpp b/src/gui/opengl/qopenglfunctions_3_2_compatibility.cpp
deleted file mode 100644
index 3e4fd96dc2..0000000000
--- a/src/gui/opengl/qopenglfunctions_3_2_compatibility.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#include "qopenglfunctions_3_2_compatibility.h"
-#include "qopenglcontext.h"
-
-QT_BEGIN_NAMESPACE
-
-/*!
-    \class QOpenGLFunctions_3_2_Compatibility
-    \inmodule QtGui
-    \since 5.1
-    \wrapper
-    \brief The QOpenGLFunctions_3_2_Compatibility class provides all functions for OpenGL 3.2 compatibility profile.
-
-    This class is a wrapper for functions from OpenGL 3.2 compatibility profile.
-    See reference pages on \l {http://www.opengl.org/sdk/docs/}{opengl.org}
-    for function documentation.
-
-    \sa QAbstractOpenGLFunctions
-*/
-
-QOpenGLFunctions_3_2_Compatibility::QOpenGLFunctions_3_2_Compatibility()
- : QAbstractOpenGLFunctions()
- , d_1_0_Core(nullptr)
- , d_1_1_Core(nullptr)
- , d_1_2_Core(nullptr)
- , d_1_3_Core(nullptr)
- , d_1_4_Core(nullptr)
- , d_1_5_Core(nullptr)
- , d_2_0_Core(nullptr)
- , d_2_1_Core(nullptr)
- , d_3_0_Core(nullptr)
- , d_3_1_Core(nullptr)
- , d_3_2_Core(nullptr)
- , d_1_0_Deprecated(nullptr)
- , d_1_1_Deprecated(nullptr)
- , d_1_2_Deprecated(nullptr)
- , d_1_3_Deprecated(nullptr)
- , d_1_4_Deprecated(nullptr)
- , m_reserved_2_0_Deprecated(nullptr)
- , m_reserved_3_0_Deprecated(nullptr)
-{
-}
-
-QOpenGLFunctions_3_2_Compatibility::~QOpenGLFunctions_3_2_Compatibility()
-{
-    if (d_1_0_Core) {
-        d_1_0_Core->refs.deref();
-        Q_ASSERT(d_1_0_Core->refs.loadRelaxed());
-    }
-    if (d_1_1_Core) {
-        d_1_1_Core->refs.deref();
-        Q_ASSERT(d_1_1_Core->refs.loadRelaxed());
-    }
-    if (d_1_2_Core) {
-        d_1_2_Core->refs.deref();
-        Q_ASSERT(d_1_2_Core->refs.loadRelaxed());
-    }
-    if (d_1_3_Core) {
-        d_1_3_Core->refs.deref();
-        Q_ASSERT(d_1_3_Core->refs.loadRelaxed());
-    }
-    if (d_1_4_Core) {
-        d_1_4_Core->refs.deref();
-        Q_ASSERT(d_1_4_Core->refs.loadRelaxed());
-    }
-    if (d_1_5_Core) {
-        d_1_5_Core->refs.deref();
-        Q_ASSERT(d_1_5_Core->refs.loadRelaxed());
-    }
-    if (d_2_0_Core) {
-        d_2_0_Core->refs.deref();
-        Q_ASSERT(d_2_0_Core->refs.loadRelaxed());
-    }
-    if (d_2_1_Core) {
-        d_2_1_Core->refs.deref();
-        Q_ASSERT(d_2_1_Core->refs.loadRelaxed());
-    }
-    if (d_3_0_Core) {
-        d_3_0_Core->refs.deref();
-        Q_ASSERT(d_3_0_Core->refs.loadRelaxed());
-    }
-    if (d_3_1_Core) {
-        d_3_1_Core->refs.deref();
-        Q_ASSERT(d_3_1_Core->refs.loadRelaxed());
-    }
-    if (d_3_2_Core) {
-        d_3_2_Core->refs.deref();
-        Q_ASSERT(d_3_2_Core->refs.loadRelaxed());
-    }
-    if (d_1_0_Deprecated) {
-        d_1_0_Deprecated->refs.deref();
-        Q_ASSERT(d_1_0_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_1_Deprecated) {
-        d_1_1_Deprecated->refs.deref();
-        Q_ASSERT(d_1_1_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_2_Deprecated) {
-        d_1_2_Deprecated->refs.deref();
-        Q_ASSERT(d_1_2_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_3_Deprecated) {
-        d_1_3_Deprecated->refs.deref();
-        Q_ASSERT(d_1_3_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_4_Deprecated) {
-        d_1_4_Deprecated->refs.deref();
-        Q_ASSERT(d_1_4_Deprecated->refs.loadRelaxed());
-    }
-}
-
-bool QOpenGLFunctions_3_2_Compatibility::initializeOpenGLFunctions()
-{
-    if ( isInitialized() )
-        return true;
-
-    QOpenGLContext* context = QOpenGLContext::currentContext();
-
-    // If owned by a context object make sure it is current.
-    // Also check that current context is capable of resolving all needed functions
-    if (((owningContext() && owningContext() == context) || !owningContext())
-        && QOpenGLFunctions_3_2_Compatibility::isContextCompatible(context))
-    {
-        // Associate with private implementation, creating if necessary
-        // Function pointers in the backends are resolved at creation time
-        QOpenGLVersionFunctionsBackend* d = nullptr;
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        d_1_3_Core = static_cast<QOpenGLFunctions_1_3_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        d_1_4_Core = static_cast<QOpenGLFunctions_1_4_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        d_1_5_Core = static_cast<QOpenGLFunctions_1_5_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        d_2_0_Core = static_cast<QOpenGLFunctions_2_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        d_2_1_Core = static_cast<QOpenGLFunctions_2_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        d_3_0_Core = static_cast<QOpenGLFunctions_3_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
-        d_3_1_Core = static_cast<QOpenGLFunctions_3_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
-        d_3_2_Core = static_cast<QOpenGLFunctions_3_2_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
-        d_1_0_Deprecated = static_cast<QOpenGLFunctions_1_0_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
-        d_1_1_Deprecated = static_cast<QOpenGLFunctions_1_1_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus());
-        d_1_2_Deprecated = static_cast<QOpenGLFunctions_1_2_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus());
-        d_1_3_Deprecated = static_cast<QOpenGLFunctions_1_3_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
-        d_1_4_Deprecated = static_cast<QOpenGLFunctions_1_4_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        QAbstractOpenGLFunctions::initializeOpenGLFunctions();
-    }
-    return isInitialized();
-}
-
-bool QOpenGLFunctions_3_2_Compatibility::isContextCompatible(QOpenGLContext *context)
-{
-    Q_ASSERT(context);
-    QSurfaceFormat f = context->format();
-    const QPair<int, int> v = qMakePair(f.majorVersion(), f.minorVersion());
-    if (v < qMakePair(3, 2))
-        return false;
-
-    if (f.profile() == QSurfaceFormat::CoreProfile)
-        return false;
-
-    return true;
-}
-
-QOpenGLVersionProfile QOpenGLFunctions_3_2_Compatibility::versionProfile()
-{
-    QOpenGLVersionProfile v;
-    v.setVersion(3, 2);
-    v.setProfile(QSurfaceFormat::CompatibilityProfile);
-    return v;
-}
-
-QT_END_NAMESPACE
diff --git a/src/gui/opengl/qopenglfunctions_3_2_compatibility.h b/src/gui/opengl/qopenglfunctions_3_2_compatibility.h
deleted file mode 100644
index 391e725953..0000000000
--- a/src/gui/opengl/qopenglfunctions_3_2_compatibility.h
+++ /dev/null
@@ -1,4377 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#ifndef QOPENGLVERSIONFUNCTIONS_3_2_COMPATIBILITY_H
-#define QOPENGLVERSIONFUNCTIONS_3_2_COMPATIBILITY_H
-
-#include <QtGui/qtguiglobal.h>
-
-#if !defined(QT_NO_OPENGL) && !defined(QT_OPENGL_ES_2)
-
-#include <QtGui/QOpenGLVersionFunctions>
-#include <QtGui/qopenglcontext.h>
-
-QT_BEGIN_NAMESPACE
-
-class Q_GUI_EXPORT QOpenGLFunctions_3_2_Compatibility : public QAbstractOpenGLFunctions
-{
-public:
-    QOpenGLFunctions_3_2_Compatibility();
-    ~QOpenGLFunctions_3_2_Compatibility();
-
-    bool initializeOpenGLFunctions() override;
-
-    // OpenGL 1.0 core functions
-    void glViewport(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glDepthRange(GLdouble nearVal, GLdouble farVal);
-    GLboolean glIsEnabled(GLenum cap);
-    void glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params);
-    void glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params);
-    void glGetTexParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
-    const GLubyte * glGetString(GLenum name);
-    void glGetIntegerv(GLenum pname, GLint *params);
-    void glGetFloatv(GLenum pname, GLfloat *params);
-    GLenum glGetError();
-    void glGetDoublev(GLenum pname, GLdouble *params);
-    void glGetBooleanv(GLenum pname, GLboolean *params);
-    void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
-    void glReadBuffer(GLenum mode);
-    void glPixelStorei(GLenum pname, GLint param);
-    void glPixelStoref(GLenum pname, GLfloat param);
-    void glDepthFunc(GLenum func);
-    void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass);
-    void glStencilFunc(GLenum func, GLint ref, GLuint mask);
-    void glLogicOp(GLenum opcode);
-    void glBlendFunc(GLenum sfactor, GLenum dfactor);
-    void glFlush();
-    void glFinish();
-    void glEnable(GLenum cap);
-    void glDisable(GLenum cap);
-    void glDepthMask(GLboolean flag);
-    void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
-    void glStencilMask(GLuint mask);
-    void glClearDepth(GLdouble depth);
-    void glClearStencil(GLint s);
-    void glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glClear(GLbitfield mask);
-    void glDrawBuffer(GLenum mode);
-    void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glTexParameteri(GLenum target, GLenum pname, GLint param);
-    void glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glTexParameterf(GLenum target, GLenum pname, GLfloat param);
-    void glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glPolygonMode(GLenum face, GLenum mode);
-    void glPointSize(GLfloat size);
-    void glLineWidth(GLfloat width);
-    void glHint(GLenum target, GLenum mode);
-    void glFrontFace(GLenum mode);
-    void glCullFace(GLenum mode);
-
-    // OpenGL 1.1 core functions
-    void glIndexubv(const GLubyte *c);
-    void glIndexub(GLubyte c);
-    GLboolean glIsTexture(GLuint texture);
-    void glGenTextures(GLsizei n, GLuint *textures);
-    void glDeleteTextures(GLsizei n, const GLuint *textures);
-    void glBindTexture(GLenum target, GLuint texture);
-    void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
-    void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
-    void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
-    void glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
-    void glPolygonOffset(GLfloat factor, GLfloat units);
-    void glGetPointerv(GLenum pname, GLvoid* *params);
-    void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
-    void glDrawArrays(GLenum mode, GLint first, GLsizei count);
-
-    // OpenGL 1.2 core functions
-    void glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices);
-    void glBlendEquation(GLenum mode);
-    void glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-
-    // OpenGL 1.3 core functions
-    void glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img);
-    void glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glSampleCoverage(GLfloat value, GLboolean invert);
-    void glActiveTexture(GLenum texture);
-
-    // OpenGL 1.4 core functions
-    void glPointParameteriv(GLenum pname, const GLint *params);
-    void glPointParameteri(GLenum pname, GLint param);
-    void glPointParameterfv(GLenum pname, const GLfloat *params);
-    void glPointParameterf(GLenum pname, GLfloat param);
-    void glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount);
-    void glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount);
-    void glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
-
-    // OpenGL 1.5 core functions
-    void glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params);
-    void glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params);
-    GLboolean glUnmapBuffer(GLenum target);
-    GLvoid* glMapBuffer(GLenum target, GLenum access);
-    void glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data);
-    void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data);
-    void glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage);
-    GLboolean glIsBuffer(GLuint buffer);
-    void glGenBuffers(GLsizei n, GLuint *buffers);
-    void glDeleteBuffers(GLsizei n, const GLuint *buffers);
-    void glBindBuffer(GLenum target, GLuint buffer);
-    void glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params);
-    void glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params);
-    void glGetQueryiv(GLenum target, GLenum pname, GLint *params);
-    void glEndQuery(GLenum target);
-    void glBeginQuery(GLenum target, GLuint id);
-    GLboolean glIsQuery(GLuint id);
-    void glDeleteQueries(GLsizei n, const GLuint *ids);
-    void glGenQueries(GLsizei n, GLuint *ids);
-
-    // OpenGL 2.0 core functions
-    void glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer);
-    void glValidateProgram(GLuint program);
-    void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniform4iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform3iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform2iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform1iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform4fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform3fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform2fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform1fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
-    void glUniform3i(GLint location, GLint v0, GLint v1, GLint v2);
-    void glUniform2i(GLint location, GLint v0, GLint v1);
-    void glUniform1i(GLint location, GLint v0);
-    void glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
-    void glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
-    void glUniform2f(GLint location, GLfloat v0, GLfloat v1);
-    void glUniform1f(GLint location, GLfloat v0);
-    void glUseProgram(GLuint program);
-    void glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length);
-    void glLinkProgram(GLuint program);
-    GLboolean glIsShader(GLuint shader);
-    GLboolean glIsProgram(GLuint program);
-    void glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer);
-    void glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params);
-    void glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params);
-    void glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params);
-    void glGetUniformiv(GLuint program, GLint location, GLint *params);
-    void glGetUniformfv(GLuint program, GLint location, GLfloat *params);
-    GLint glGetUniformLocation(GLuint program, const GLchar *name);
-    void glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source);
-    void glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void glGetShaderiv(GLuint shader, GLenum pname, GLint *params);
-    void glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void glGetProgramiv(GLuint program, GLenum pname, GLint *params);
-    GLint glGetAttribLocation(GLuint program, const GLchar *name);
-    void glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj);
-    void glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
-    void glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
-    void glEnableVertexAttribArray(GLuint index);
-    void glDisableVertexAttribArray(GLuint index);
-    void glDetachShader(GLuint program, GLuint shader);
-    void glDeleteShader(GLuint shader);
-    void glDeleteProgram(GLuint program);
-    GLuint glCreateShader(GLenum type);
-    GLuint glCreateProgram();
-    void glCompileShader(GLuint shader);
-    void glBindAttribLocation(GLuint program, GLuint index, const GLchar *name);
-    void glAttachShader(GLuint program, GLuint shader);
-    void glStencilMaskSeparate(GLenum face, GLuint mask);
-    void glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask);
-    void glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);
-    void glDrawBuffers(GLsizei n, const GLenum *bufs);
-    void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha);
-
-    // OpenGL 2.1 core functions
-    void glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-
-    // OpenGL 3.0 core functions
-    GLboolean glIsVertexArray(GLuint array);
-    void glGenVertexArrays(GLsizei n, GLuint *arrays);
-    void glDeleteVertexArrays(GLsizei n, const GLuint *arrays);
-    void glBindVertexArray(GLuint array);
-    void glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length);
-    GLvoid* glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
-    void glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
-    void glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
-    void glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
-    void glGenerateMipmap(GLenum target);
-    void glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params);
-    void glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
-    void glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset);
-    void glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
-    void glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
-    GLenum glCheckFramebufferStatus(GLenum target);
-    void glGenFramebuffers(GLsizei n, GLuint *framebuffers);
-    void glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers);
-    void glBindFramebuffer(GLenum target, GLuint framebuffer);
-    GLboolean glIsFramebuffer(GLuint framebuffer);
-    void glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
-    void glGenRenderbuffers(GLsizei n, GLuint *renderbuffers);
-    void glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers);
-    void glBindRenderbuffer(GLenum target, GLuint renderbuffer);
-    GLboolean glIsRenderbuffer(GLuint renderbuffer);
-    const GLubyte * glGetStringi(GLenum name, GLuint index);
-    void glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
-    void glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value);
-    void glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value);
-    void glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value);
-    void glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params);
-    void glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params);
-    void glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params);
-    void glTexParameterIiv(GLenum target, GLenum pname, const GLint *params);
-    void glUniform4uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform3uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform2uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform1uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
-    void glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2);
-    void glUniform2ui(GLint location, GLuint v0, GLuint v1);
-    void glUniform1ui(GLint location, GLuint v0);
-    GLint glGetFragDataLocation(GLuint program, const GLchar *name);
-    void glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name);
-    void glGetUniformuiv(GLuint program, GLint location, GLuint *params);
-    void glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params);
-    void glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params);
-    void glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glEndConditionalRender();
-    void glBeginConditionalRender(GLuint id, GLenum mode);
-    void glClampColor(GLenum target, GLenum clamp);
-    void glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name);
-    void glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode);
-    void glBindBufferBase(GLenum target, GLuint index, GLuint buffer);
-    void glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
-    void glEndTransformFeedback();
-    void glBeginTransformFeedback(GLenum primitiveMode);
-    GLboolean glIsEnabledi(GLenum target, GLuint index);
-    void glDisablei(GLenum target, GLuint index);
-    void glEnablei(GLenum target, GLuint index);
-    void glGetIntegeri_v(GLenum target, GLuint index, GLint *data);
-    void glGetBooleani_v(GLenum target, GLuint index, GLboolean *data);
-    void glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a);
-
-    // OpenGL 3.1 core functions
-    void glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
-    void glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);
-    void glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName);
-    void glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params);
-    GLuint glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName);
-    void glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName);
-    void glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params);
-    void glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const *uniformNames, GLuint *uniformIndices);
-    void glPrimitiveRestartIndex(GLuint index);
-    void glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer);
-    void glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount);
-    void glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount);
-
-    // OpenGL 3.2 core functions
-    void glSampleMaski(GLuint index, GLbitfield mask);
-    void glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val);
-    void glTexImage3DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
-    void glTexImage2DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
-    void glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values);
-    void glGetInteger64v(GLenum pname, GLint64 *params);
-    void glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout);
-    GLenum glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout);
-    void glDeleteSync(GLsync sync);
-    GLboolean glIsSync(GLsync sync);
-    GLsync glFenceSync(GLenum condition, GLbitfield flags);
-    void glProvokingVertex(GLenum mode);
-    void glMultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount, const GLint *basevertex);
-    void glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount, GLint basevertex);
-    void glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex);
-    void glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex);
-    void glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level);
-    void glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params);
-    void glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data);
-
-    // OpenGL 1.0 deprecated functions
-    void glTranslatef(GLfloat x, GLfloat y, GLfloat z);
-    void glTranslated(GLdouble x, GLdouble y, GLdouble z);
-    void glScalef(GLfloat x, GLfloat y, GLfloat z);
-    void glScaled(GLdouble x, GLdouble y, GLdouble z);
-    void glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
-    void glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
-    void glPushMatrix();
-    void glPopMatrix();
-    void glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
-    void glMultMatrixd(const GLdouble *m);
-    void glMultMatrixf(const GLfloat *m);
-    void glMatrixMode(GLenum mode);
-    void glLoadMatrixd(const GLdouble *m);
-    void glLoadMatrixf(const GLfloat *m);
-    void glLoadIdentity();
-    void glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
-    GLboolean glIsList(GLuint list);
-    void glGetTexGeniv(GLenum coord, GLenum pname, GLint *params);
-    void glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params);
-    void glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params);
-    void glGetTexEnviv(GLenum target, GLenum pname, GLint *params);
-    void glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetPolygonStipple(GLubyte *mask);
-    void glGetPixelMapusv(GLenum map, GLushort *values);
-    void glGetPixelMapuiv(GLenum map, GLuint *values);
-    void glGetPixelMapfv(GLenum map, GLfloat *values);
-    void glGetMaterialiv(GLenum face, GLenum pname, GLint *params);
-    void glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params);
-    void glGetMapiv(GLenum target, GLenum query, GLint *v);
-    void glGetMapfv(GLenum target, GLenum query, GLfloat *v);
-    void glGetMapdv(GLenum target, GLenum query, GLdouble *v);
-    void glGetLightiv(GLenum light, GLenum pname, GLint *params);
-    void glGetLightfv(GLenum light, GLenum pname, GLfloat *params);
-    void glGetClipPlane(GLenum plane, GLdouble *equation);
-    void glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
-    void glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
-    void glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values);
-    void glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values);
-    void glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values);
-    void glPixelTransferi(GLenum pname, GLint param);
-    void glPixelTransferf(GLenum pname, GLfloat param);
-    void glPixelZoom(GLfloat xfactor, GLfloat yfactor);
-    void glAlphaFunc(GLenum func, GLfloat ref);
-    void glEvalPoint2(GLint i, GLint j);
-    void glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
-    void glEvalPoint1(GLint i);
-    void glEvalMesh1(GLenum mode, GLint i1, GLint i2);
-    void glEvalCoord2fv(const GLfloat *u);
-    void glEvalCoord2f(GLfloat u, GLfloat v);
-    void glEvalCoord2dv(const GLdouble *u);
-    void glEvalCoord2d(GLdouble u, GLdouble v);
-    void glEvalCoord1fv(const GLfloat *u);
-    void glEvalCoord1f(GLfloat u);
-    void glEvalCoord1dv(const GLdouble *u);
-    void glEvalCoord1d(GLdouble u);
-    void glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
-    void glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
-    void glMapGrid1f(GLint un, GLfloat u1, GLfloat u2);
-    void glMapGrid1d(GLint un, GLdouble u1, GLdouble u2);
-    void glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);
-    void glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);
-    void glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);
-    void glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);
-    void glPushAttrib(GLbitfield mask);
-    void glPopAttrib();
-    void glAccum(GLenum op, GLfloat value);
-    void glIndexMask(GLuint mask);
-    void glClearIndex(GLfloat c);
-    void glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glPushName(GLuint name);
-    void glPopName();
-    void glPassThrough(GLfloat token);
-    void glLoadName(GLuint name);
-    void glInitNames();
-    GLint glRenderMode(GLenum mode);
-    void glSelectBuffer(GLsizei size, GLuint *buffer);
-    void glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer);
-    void glTexGeniv(GLenum coord, GLenum pname, const GLint *params);
-    void glTexGeni(GLenum coord, GLenum pname, GLint param);
-    void glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params);
-    void glTexGenf(GLenum coord, GLenum pname, GLfloat param);
-    void glTexGendv(GLenum coord, GLenum pname, const GLdouble *params);
-    void glTexGend(GLenum coord, GLenum pname, GLdouble param);
-    void glTexEnviv(GLenum target, GLenum pname, const GLint *params);
-    void glTexEnvi(GLenum target, GLenum pname, GLint param);
-    void glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glTexEnvf(GLenum target, GLenum pname, GLfloat param);
-    void glShadeModel(GLenum mode);
-    void glPolygonStipple(const GLubyte *mask);
-    void glMaterialiv(GLenum face, GLenum pname, const GLint *params);
-    void glMateriali(GLenum face, GLenum pname, GLint param);
-    void glMaterialfv(GLenum face, GLenum pname, const GLfloat *params);
-    void glMaterialf(GLenum face, GLenum pname, GLfloat param);
-    void glLineStipple(GLint factor, GLushort pattern);
-    void glLightModeliv(GLenum pname, const GLint *params);
-    void glLightModeli(GLenum pname, GLint param);
-    void glLightModelfv(GLenum pname, const GLfloat *params);
-    void glLightModelf(GLenum pname, GLfloat param);
-    void glLightiv(GLenum light, GLenum pname, const GLint *params);
-    void glLighti(GLenum light, GLenum pname, GLint param);
-    void glLightfv(GLenum light, GLenum pname, const GLfloat *params);
-    void glLightf(GLenum light, GLenum pname, GLfloat param);
-    void glFogiv(GLenum pname, const GLint *params);
-    void glFogi(GLenum pname, GLint param);
-    void glFogfv(GLenum pname, const GLfloat *params);
-    void glFogf(GLenum pname, GLfloat param);
-    void glColorMaterial(GLenum face, GLenum mode);
-    void glClipPlane(GLenum plane, const GLdouble *equation);
-    void glVertex4sv(const GLshort *v);
-    void glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w);
-    void glVertex4iv(const GLint *v);
-    void glVertex4i(GLint x, GLint y, GLint z, GLint w);
-    void glVertex4fv(const GLfloat *v);
-    void glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void glVertex4dv(const GLdouble *v);
-    void glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glVertex3sv(const GLshort *v);
-    void glVertex3s(GLshort x, GLshort y, GLshort z);
-    void glVertex3iv(const GLint *v);
-    void glVertex3i(GLint x, GLint y, GLint z);
-    void glVertex3fv(const GLfloat *v);
-    void glVertex3f(GLfloat x, GLfloat y, GLfloat z);
-    void glVertex3dv(const GLdouble *v);
-    void glVertex3d(GLdouble x, GLdouble y, GLdouble z);
-    void glVertex2sv(const GLshort *v);
-    void glVertex2s(GLshort x, GLshort y);
-    void glVertex2iv(const GLint *v);
-    void glVertex2i(GLint x, GLint y);
-    void glVertex2fv(const GLfloat *v);
-    void glVertex2f(GLfloat x, GLfloat y);
-    void glVertex2dv(const GLdouble *v);
-    void glVertex2d(GLdouble x, GLdouble y);
-    void glTexCoord4sv(const GLshort *v);
-    void glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q);
-    void glTexCoord4iv(const GLint *v);
-    void glTexCoord4i(GLint s, GLint t, GLint r, GLint q);
-    void glTexCoord4fv(const GLfloat *v);
-    void glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
-    void glTexCoord4dv(const GLdouble *v);
-    void glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q);
-    void glTexCoord3sv(const GLshort *v);
-    void glTexCoord3s(GLshort s, GLshort t, GLshort r);
-    void glTexCoord3iv(const GLint *v);
-    void glTexCoord3i(GLint s, GLint t, GLint r);
-    void glTexCoord3fv(const GLfloat *v);
-    void glTexCoord3f(GLfloat s, GLfloat t, GLfloat r);
-    void glTexCoord3dv(const GLdouble *v);
-    void glTexCoord3d(GLdouble s, GLdouble t, GLdouble r);
-    void glTexCoord2sv(const GLshort *v);
-    void glTexCoord2s(GLshort s, GLshort t);
-    void glTexCoord2iv(const GLint *v);
-    void glTexCoord2i(GLint s, GLint t);
-    void glTexCoord2fv(const GLfloat *v);
-    void glTexCoord2f(GLfloat s, GLfloat t);
-    void glTexCoord2dv(const GLdouble *v);
-    void glTexCoord2d(GLdouble s, GLdouble t);
-    void glTexCoord1sv(const GLshort *v);
-    void glTexCoord1s(GLshort s);
-    void glTexCoord1iv(const GLint *v);
-    void glTexCoord1i(GLint s);
-    void glTexCoord1fv(const GLfloat *v);
-    void glTexCoord1f(GLfloat s);
-    void glTexCoord1dv(const GLdouble *v);
-    void glTexCoord1d(GLdouble s);
-    void glRectsv(const GLshort *v1, const GLshort *v2);
-    void glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
-    void glRectiv(const GLint *v1, const GLint *v2);
-    void glRecti(GLint x1, GLint y1, GLint x2, GLint y2);
-    void glRectfv(const GLfloat *v1, const GLfloat *v2);
-    void glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
-    void glRectdv(const GLdouble *v1, const GLdouble *v2);
-    void glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
-    void glRasterPos4sv(const GLshort *v);
-    void glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w);
-    void glRasterPos4iv(const GLint *v);
-    void glRasterPos4i(GLint x, GLint y, GLint z, GLint w);
-    void glRasterPos4fv(const GLfloat *v);
-    void glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void glRasterPos4dv(const GLdouble *v);
-    void glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glRasterPos3sv(const GLshort *v);
-    void glRasterPos3s(GLshort x, GLshort y, GLshort z);
-    void glRasterPos3iv(const GLint *v);
-    void glRasterPos3i(GLint x, GLint y, GLint z);
-    void glRasterPos3fv(const GLfloat *v);
-    void glRasterPos3f(GLfloat x, GLfloat y, GLfloat z);
-    void glRasterPos3dv(const GLdouble *v);
-    void glRasterPos3d(GLdouble x, GLdouble y, GLdouble z);
-    void glRasterPos2sv(const GLshort *v);
-    void glRasterPos2s(GLshort x, GLshort y);
-    void glRasterPos2iv(const GLint *v);
-    void glRasterPos2i(GLint x, GLint y);
-    void glRasterPos2fv(const GLfloat *v);
-    void glRasterPos2f(GLfloat x, GLfloat y);
-    void glRasterPos2dv(const GLdouble *v);
-    void glRasterPos2d(GLdouble x, GLdouble y);
-    void glNormal3sv(const GLshort *v);
-    void glNormal3s(GLshort nx, GLshort ny, GLshort nz);
-    void glNormal3iv(const GLint *v);
-    void glNormal3i(GLint nx, GLint ny, GLint nz);
-    void glNormal3fv(const GLfloat *v);
-    void glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz);
-    void glNormal3dv(const GLdouble *v);
-    void glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz);
-    void glNormal3bv(const GLbyte *v);
-    void glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz);
-    void glIndexsv(const GLshort *c);
-    void glIndexs(GLshort c);
-    void glIndexiv(const GLint *c);
-    void glIndexi(GLint c);
-    void glIndexfv(const GLfloat *c);
-    void glIndexf(GLfloat c);
-    void glIndexdv(const GLdouble *c);
-    void glIndexd(GLdouble c);
-    void glEnd();
-    void glEdgeFlagv(const GLboolean *flag);
-    void glEdgeFlag(GLboolean flag);
-    void glColor4usv(const GLushort *v);
-    void glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha);
-    void glColor4uiv(const GLuint *v);
-    void glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha);
-    void glColor4ubv(const GLubyte *v);
-    void glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
-    void glColor4sv(const GLshort *v);
-    void glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha);
-    void glColor4iv(const GLint *v);
-    void glColor4i(GLint red, GLint green, GLint blue, GLint alpha);
-    void glColor4fv(const GLfloat *v);
-    void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glColor4dv(const GLdouble *v);
-    void glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
-    void glColor4bv(const GLbyte *v);
-    void glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
-    void glColor3usv(const GLushort *v);
-    void glColor3us(GLushort red, GLushort green, GLushort blue);
-    void glColor3uiv(const GLuint *v);
-    void glColor3ui(GLuint red, GLuint green, GLuint blue);
-    void glColor3ubv(const GLubyte *v);
-    void glColor3ub(GLubyte red, GLubyte green, GLubyte blue);
-    void glColor3sv(const GLshort *v);
-    void glColor3s(GLshort red, GLshort green, GLshort blue);
-    void glColor3iv(const GLint *v);
-    void glColor3i(GLint red, GLint green, GLint blue);
-    void glColor3fv(const GLfloat *v);
-    void glColor3f(GLfloat red, GLfloat green, GLfloat blue);
-    void glColor3dv(const GLdouble *v);
-    void glColor3d(GLdouble red, GLdouble green, GLdouble blue);
-    void glColor3bv(const GLbyte *v);
-    void glColor3b(GLbyte red, GLbyte green, GLbyte blue);
-    void glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap);
-    void glBegin(GLenum mode);
-    void glListBase(GLuint base);
-    GLuint glGenLists(GLsizei range);
-    void glDeleteLists(GLuint list, GLsizei range);
-    void glCallLists(GLsizei n, GLenum type, const GLvoid *lists);
-    void glCallList(GLuint list);
-    void glEndList();
-    void glNewList(GLuint list, GLenum mode);
-
-    // OpenGL 1.1 deprecated functions
-    void glPushClientAttrib(GLbitfield mask);
-    void glPopClientAttrib();
-    void glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities);
-    GLboolean glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences);
-    void glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer);
-    void glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glEnableClientState(GLenum array);
-    void glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer);
-    void glDisableClientState(GLenum array);
-    void glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glArrayElement(GLint i);
-
-    // OpenGL 1.2 deprecated functions
-    void glResetMinmax(GLenum target);
-    void glResetHistogram(GLenum target);
-    void glMinmax(GLenum target, GLenum internalformat, GLboolean sink);
-    void glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink);
-    void glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
-    void glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
-    void glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column);
-    void glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span);
-    void glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image);
-    void glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
-    void glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glConvolutionParameteri(GLenum target, GLenum pname, GLint params);
-    void glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params);
-    void glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image);
-    void glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image);
-    void glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width);
-    void glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data);
-    void glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table);
-    void glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
-    void glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table);
-
-    // OpenGL 1.3 deprecated functions
-    void glMultTransposeMatrixd(const GLdouble *m);
-    void glMultTransposeMatrixf(const GLfloat *m);
-    void glLoadTransposeMatrixd(const GLdouble *m);
-    void glLoadTransposeMatrixf(const GLfloat *m);
-    void glMultiTexCoord4sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);
-    void glMultiTexCoord4iv(GLenum target, const GLint *v);
-    void glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q);
-    void glMultiTexCoord4fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
-    void glMultiTexCoord4dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
-    void glMultiTexCoord3sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r);
-    void glMultiTexCoord3iv(GLenum target, const GLint *v);
-    void glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r);
-    void glMultiTexCoord3fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r);
-    void glMultiTexCoord3dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r);
-    void glMultiTexCoord2sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord2s(GLenum target, GLshort s, GLshort t);
-    void glMultiTexCoord2iv(GLenum target, const GLint *v);
-    void glMultiTexCoord2i(GLenum target, GLint s, GLint t);
-    void glMultiTexCoord2fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t);
-    void glMultiTexCoord2dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t);
-    void glMultiTexCoord1sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord1s(GLenum target, GLshort s);
-    void glMultiTexCoord1iv(GLenum target, const GLint *v);
-    void glMultiTexCoord1i(GLenum target, GLint s);
-    void glMultiTexCoord1fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord1f(GLenum target, GLfloat s);
-    void glMultiTexCoord1dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord1d(GLenum target, GLdouble s);
-    void glClientActiveTexture(GLenum texture);
-
-    // OpenGL 1.4 deprecated functions
-    void glWindowPos3sv(const GLshort *v);
-    void glWindowPos3s(GLshort x, GLshort y, GLshort z);
-    void glWindowPos3iv(const GLint *v);
-    void glWindowPos3i(GLint x, GLint y, GLint z);
-    void glWindowPos3fv(const GLfloat *v);
-    void glWindowPos3f(GLfloat x, GLfloat y, GLfloat z);
-    void glWindowPos3dv(const GLdouble *v);
-    void glWindowPos3d(GLdouble x, GLdouble y, GLdouble z);
-    void glWindowPos2sv(const GLshort *v);
-    void glWindowPos2s(GLshort x, GLshort y);
-    void glWindowPos2iv(const GLint *v);
-    void glWindowPos2i(GLint x, GLint y);
-    void glWindowPos2fv(const GLfloat *v);
-    void glWindowPos2f(GLfloat x, GLfloat y);
-    void glWindowPos2dv(const GLdouble *v);
-    void glWindowPos2d(GLdouble x, GLdouble y);
-    void glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glSecondaryColor3usv(const GLushort *v);
-    void glSecondaryColor3us(GLushort red, GLushort green, GLushort blue);
-    void glSecondaryColor3uiv(const GLuint *v);
-    void glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue);
-    void glSecondaryColor3ubv(const GLubyte *v);
-    void glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue);
-    void glSecondaryColor3sv(const GLshort *v);
-    void glSecondaryColor3s(GLshort red, GLshort green, GLshort blue);
-    void glSecondaryColor3iv(const GLint *v);
-    void glSecondaryColor3i(GLint red, GLint green, GLint blue);
-    void glSecondaryColor3fv(const GLfloat *v);
-    void glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue);
-    void glSecondaryColor3dv(const GLdouble *v);
-    void glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue);
-    void glSecondaryColor3bv(const GLbyte *v);
-    void glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue);
-    void glFogCoordPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glFogCoorddv(const GLdouble *coord);
-    void glFogCoordd(GLdouble coord);
-    void glFogCoordfv(const GLfloat *coord);
-    void glFogCoordf(GLfloat coord);
-
-    // OpenGL 1.5 deprecated functions
-
-    // OpenGL 2.0 deprecated functions
-    void glVertexAttrib4usv(GLuint index, const GLushort *v);
-    void glVertexAttrib4uiv(GLuint index, const GLuint *v);
-    void glVertexAttrib4ubv(GLuint index, const GLubyte *v);
-    void glVertexAttrib4sv(GLuint index, const GLshort *v);
-    void glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
-    void glVertexAttrib4iv(GLuint index, const GLint *v);
-    void glVertexAttrib4fv(GLuint index, const GLfloat *v);
-    void glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void glVertexAttrib4dv(GLuint index, const GLdouble *v);
-    void glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glVertexAttrib4bv(GLuint index, const GLbyte *v);
-    void glVertexAttrib4Nusv(GLuint index, const GLushort *v);
-    void glVertexAttrib4Nuiv(GLuint index, const GLuint *v);
-    void glVertexAttrib4Nubv(GLuint index, const GLubyte *v);
-    void glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
-    void glVertexAttrib4Nsv(GLuint index, const GLshort *v);
-    void glVertexAttrib4Niv(GLuint index, const GLint *v);
-    void glVertexAttrib4Nbv(GLuint index, const GLbyte *v);
-    void glVertexAttrib3sv(GLuint index, const GLshort *v);
-    void glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z);
-    void glVertexAttrib3fv(GLuint index, const GLfloat *v);
-    void glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z);
-    void glVertexAttrib3dv(GLuint index, const GLdouble *v);
-    void glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z);
-    void glVertexAttrib2sv(GLuint index, const GLshort *v);
-    void glVertexAttrib2s(GLuint index, GLshort x, GLshort y);
-    void glVertexAttrib2fv(GLuint index, const GLfloat *v);
-    void glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y);
-    void glVertexAttrib2dv(GLuint index, const GLdouble *v);
-    void glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y);
-    void glVertexAttrib1sv(GLuint index, const GLshort *v);
-    void glVertexAttrib1s(GLuint index, GLshort x);
-    void glVertexAttrib1fv(GLuint index, const GLfloat *v);
-    void glVertexAttrib1f(GLuint index, GLfloat x);
-    void glVertexAttrib1dv(GLuint index, const GLdouble *v);
-    void glVertexAttrib1d(GLuint index, GLdouble x);
-
-    // OpenGL 2.1 deprecated functions
-
-    // OpenGL 3.0 deprecated functions
-    void glVertexAttribI4usv(GLuint index, const GLushort *v);
-    void glVertexAttribI4ubv(GLuint index, const GLubyte *v);
-    void glVertexAttribI4sv(GLuint index, const GLshort *v);
-    void glVertexAttribI4bv(GLuint index, const GLbyte *v);
-    void glVertexAttribI4uiv(GLuint index, const GLuint *v);
-    void glVertexAttribI3uiv(GLuint index, const GLuint *v);
-    void glVertexAttribI2uiv(GLuint index, const GLuint *v);
-    void glVertexAttribI1uiv(GLuint index, const GLuint *v);
-    void glVertexAttribI4iv(GLuint index, const GLint *v);
-    void glVertexAttribI3iv(GLuint index, const GLint *v);
-    void glVertexAttribI2iv(GLuint index, const GLint *v);
-    void glVertexAttribI1iv(GLuint index, const GLint *v);
-    void glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
-    void glVertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z);
-    void glVertexAttribI2ui(GLuint index, GLuint x, GLuint y);
-    void glVertexAttribI1ui(GLuint index, GLuint x);
-    void glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w);
-    void glVertexAttribI3i(GLuint index, GLint x, GLint y, GLint z);
-    void glVertexAttribI2i(GLuint index, GLint x, GLint y);
-    void glVertexAttribI1i(GLuint index, GLint x);
-
-    // OpenGL 3.1 deprecated functions
-
-    // OpenGL 3.2 deprecated functions
-
-private:
-    friend class QOpenGLContext;
-
-    static bool isContextCompatible(QOpenGLContext *context);
-    static QOpenGLVersionProfile versionProfile();
-
-    QOpenGLFunctions_1_0_CoreBackend* d_1_0_Core;
-    QOpenGLFunctions_1_1_CoreBackend* d_1_1_Core;
-    QOpenGLFunctions_1_2_CoreBackend* d_1_2_Core;
-    QOpenGLFunctions_1_3_CoreBackend* d_1_3_Core;
-    QOpenGLFunctions_1_4_CoreBackend* d_1_4_Core;
-    QOpenGLFunctions_1_5_CoreBackend* d_1_5_Core;
-    QOpenGLFunctions_2_0_CoreBackend* d_2_0_Core;
-    QOpenGLFunctions_2_1_CoreBackend* d_2_1_Core;
-    QOpenGLFunctions_3_0_CoreBackend* d_3_0_Core;
-    QOpenGLFunctions_3_1_CoreBackend* d_3_1_Core;
-    QOpenGLFunctions_3_2_CoreBackend* d_3_2_Core;
-    QOpenGLFunctions_1_0_DeprecatedBackend* d_1_0_Deprecated;
-    QOpenGLFunctions_1_1_DeprecatedBackend* d_1_1_Deprecated;
-    QOpenGLFunctions_1_2_DeprecatedBackend* d_1_2_Deprecated;
-    QOpenGLFunctions_1_3_DeprecatedBackend* d_1_3_Deprecated;
-    QOpenGLFunctions_1_4_DeprecatedBackend* d_1_4_Deprecated;
-    void *m_reserved_2_0_Deprecated; // To maintain BC
-    void *m_reserved_3_0_Deprecated; // To maintain BC
-};
-
-// OpenGL 1.0 core functions
-inline void QOpenGLFunctions_3_2_Compatibility::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_0_Core->f.Viewport(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glDepthRange(GLdouble nearVal, GLdouble farVal)
-{
-    d_1_0_Core->f.DepthRange(nearVal, farVal);
-}
-
-inline GLboolean QOpenGLFunctions_3_2_Compatibility::glIsEnabled(GLenum cap)
-{
-    return d_1_0_Core->f.IsEnabled(cap);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetTexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetTexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
-{
-    d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
-}
-
-inline const GLubyte * QOpenGLFunctions_3_2_Compatibility::glGetString(GLenum name)
-{
-    return d_1_0_Core->f.GetString(name);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetIntegerv(GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetIntegerv(pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetFloatv(GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetFloatv(pname, params);
-}
-
-inline GLenum QOpenGLFunctions_3_2_Compatibility::glGetError()
-{
-    return d_1_0_Core->f.GetError();
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetDoublev(GLenum pname, GLdouble *params)
-{
-    d_1_0_Core->f.GetDoublev(pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetBooleanv(GLenum pname, GLboolean *params)
-{
-    d_1_0_Core->f.GetBooleanv(pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
-{
-    d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glReadBuffer(GLenum mode)
-{
-    d_1_0_Core->f.ReadBuffer(mode);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glPixelStorei(GLenum pname, GLint param)
-{
-    d_1_0_Core->f.PixelStorei(pname, param);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glPixelStoref(GLenum pname, GLfloat param)
-{
-    d_1_0_Core->f.PixelStoref(pname, param);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glDepthFunc(GLenum func)
-{
-    d_1_0_Core->f.DepthFunc(func);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
-{
-    d_1_0_Core->f.StencilOp(fail, zfail, zpass);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glStencilFunc(GLenum func, GLint ref, GLuint mask)
-{
-    d_1_0_Core->f.StencilFunc(func, ref, mask);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glLogicOp(GLenum opcode)
-{
-    d_1_0_Core->f.LogicOp(opcode);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glBlendFunc(GLenum sfactor, GLenum dfactor)
-{
-    d_1_0_Core->f.BlendFunc(sfactor, dfactor);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glFlush()
-{
-    d_1_0_Core->f.Flush();
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glFinish()
-{
-    d_1_0_Core->f.Finish();
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glEnable(GLenum cap)
-{
-    d_1_0_Core->f.Enable(cap);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glDisable(GLenum cap)
-{
-    d_1_0_Core->f.Disable(cap);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glDepthMask(GLboolean flag)
-{
-    d_1_0_Core->f.DepthMask(flag);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
-{
-    d_1_0_Core->f.ColorMask(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glStencilMask(GLuint mask)
-{
-    d_1_0_Core->f.StencilMask(mask);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glClearDepth(GLdouble depth)
-{
-    d_1_0_Core->f.ClearDepth(depth);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glClearStencil(GLint s)
-{
-    d_1_0_Core->f.ClearStencil(s);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Core->f.ClearColor(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glClear(GLbitfield mask)
-{
-    d_1_0_Core->f.Clear(mask);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glDrawBuffer(GLenum mode)
-{
-    d_1_0_Core->f.DrawBuffer(mode);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Core->f.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Core->f.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_0_Core->f.TexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexParameteri(GLenum target, GLenum pname, GLint param)
-{
-    d_1_0_Core->f.TexParameteri(target, pname, param);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Core->f.TexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
-{
-    d_1_0_Core->f.TexParameterf(target, pname, param);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_0_Core->f.Scissor(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glPolygonMode(GLenum face, GLenum mode)
-{
-    d_1_0_Core->f.PolygonMode(face, mode);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glPointSize(GLfloat size)
-{
-    d_1_0_Core->f.PointSize(size);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glLineWidth(GLfloat width)
-{
-    d_1_0_Core->f.LineWidth(width);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glHint(GLenum target, GLenum mode)
-{
-    d_1_0_Core->f.Hint(target, mode);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glFrontFace(GLenum mode)
-{
-    d_1_0_Core->f.FrontFace(mode);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glCullFace(GLenum mode)
-{
-    d_1_0_Core->f.CullFace(mode);
-}
-
-
-// OpenGL 1.1 core functions
-inline void QOpenGLFunctions_3_2_Compatibility::glIndexubv(const GLubyte *c)
-{
-    d_1_1_Deprecated->f.Indexubv(c);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glIndexub(GLubyte c)
-{
-    d_1_1_Deprecated->f.Indexub(c);
-}
-
-inline GLboolean QOpenGLFunctions_3_2_Compatibility::glIsTexture(GLuint texture)
-{
-    return d_1_1_Core->f.IsTexture(texture);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGenTextures(GLsizei n, GLuint *textures)
-{
-    d_1_1_Core->f.GenTextures(n, textures);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glDeleteTextures(GLsizei n, const GLuint *textures)
-{
-    d_1_1_Core->f.DeleteTextures(n, textures);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glBindTexture(GLenum target, GLuint texture)
-{
-    d_1_1_Core->f.BindTexture(target, texture);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_1_Core->f.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_1_Core->f.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_1_Core->f.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
-{
-    d_1_1_Core->f.CopyTexSubImage1D(target, level, xoffset, x, y, width);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
-{
-    d_1_1_Core->f.CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
-{
-    d_1_1_Core->f.CopyTexImage1D(target, level, internalformat, x, y, width, border);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glPolygonOffset(GLfloat factor, GLfloat units)
-{
-    d_1_1_Core->f.PolygonOffset(factor, units);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetPointerv(GLenum pname, GLvoid* *params)
-{
-    d_1_1_Deprecated->f.GetPointerv(pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
-{
-    d_1_1_Core->f.DrawElements(mode, count, type, indices);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glDrawArrays(GLenum mode, GLint first, GLsizei count)
-{
-    d_1_1_Core->f.DrawArrays(mode, first, count);
-}
-
-
-// OpenGL 1.2 core functions
-inline void QOpenGLFunctions_3_2_Compatibility::glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_2_Core->f.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_2_Core->f.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_2_Core->f.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
-{
-    d_1_2_Core->f.DrawRangeElements(mode, start, end, count, type, indices);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glBlendEquation(GLenum mode)
-{
-    d_1_2_Core->f.BlendEquation(mode);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_2_Core->f.BlendColor(red, green, blue, alpha);
-}
-
-
-// OpenGL 1.3 core functions
-inline void QOpenGLFunctions_3_2_Compatibility::glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img)
-{
-    d_1_3_Core->f.GetCompressedTexImage(target, level, img);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glSampleCoverage(GLfloat value, GLboolean invert)
-{
-    d_1_3_Core->f.SampleCoverage(value, invert);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glActiveTexture(GLenum texture)
-{
-    d_1_3_Core->f.ActiveTexture(texture);
-}
-
-
-// OpenGL 1.4 core functions
-inline void QOpenGLFunctions_3_2_Compatibility::glPointParameteriv(GLenum pname, const GLint *params)
-{
-    d_1_4_Core->f.PointParameteriv(pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glPointParameteri(GLenum pname, GLint param)
-{
-    d_1_4_Core->f.PointParameteri(pname, param);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glPointParameterfv(GLenum pname, const GLfloat *params)
-{
-    d_1_4_Core->f.PointParameterfv(pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glPointParameterf(GLenum pname, GLfloat param)
-{
-    d_1_4_Core->f.PointParameterf(pname, param);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount)
-{
-    d_1_4_Core->f.MultiDrawElements(mode, count, type, indices, drawcount);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
-{
-    d_1_4_Core->f.MultiDrawArrays(mode, first, count, drawcount);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
-{
-    d_1_4_Core->f.BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
-}
-
-
-// OpenGL 1.5 core functions
-inline void QOpenGLFunctions_3_2_Compatibility::glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params)
-{
-    d_1_5_Core->f.GetBufferPointerv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetBufferParameteriv(target, pname, params);
-}
-
-inline GLboolean QOpenGLFunctions_3_2_Compatibility::glUnmapBuffer(GLenum target)
-{
-    return d_1_5_Core->f.UnmapBuffer(target);
-}
-
-inline GLvoid* QOpenGLFunctions_3_2_Compatibility::glMapBuffer(GLenum target, GLenum access)
-{
-    return d_1_5_Core->f.MapBuffer(target, access);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data)
-{
-    d_1_5_Core->f.GetBufferSubData(target, offset, size, data);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data)
-{
-    d_1_5_Core->f.BufferSubData(target, offset, size, data);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)
-{
-    d_1_5_Core->f.BufferData(target, size, data, usage);
-}
-
-inline GLboolean QOpenGLFunctions_3_2_Compatibility::glIsBuffer(GLuint buffer)
-{
-    return d_1_5_Core->f.IsBuffer(buffer);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGenBuffers(GLsizei n, GLuint *buffers)
-{
-    d_1_5_Core->f.GenBuffers(n, buffers);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glDeleteBuffers(GLsizei n, const GLuint *buffers)
-{
-    d_1_5_Core->f.DeleteBuffers(n, buffers);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glBindBuffer(GLenum target, GLuint buffer)
-{
-    d_1_5_Core->f.BindBuffer(target, buffer);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
-{
-    d_1_5_Core->f.GetQueryObjectuiv(id, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetQueryObjectiv(id, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetQueryiv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetQueryiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glEndQuery(GLenum target)
-{
-    d_1_5_Core->f.EndQuery(target);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glBeginQuery(GLenum target, GLuint id)
-{
-    d_1_5_Core->f.BeginQuery(target, id);
-}
-
-inline GLboolean QOpenGLFunctions_3_2_Compatibility::glIsQuery(GLuint id)
-{
-    return d_1_5_Core->f.IsQuery(id);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glDeleteQueries(GLsizei n, const GLuint *ids)
-{
-    d_1_5_Core->f.DeleteQueries(n, ids);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGenQueries(GLsizei n, GLuint *ids)
-{
-    d_1_5_Core->f.GenQueries(n, ids);
-}
-
-
-// OpenGL 2.0 core functions
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer)
-{
-    d_2_0_Core->f.VertexAttribPointer(index, size, type, normalized, stride, pointer);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glValidateProgram(GLuint program)
-{
-    d_2_0_Core->f.ValidateProgram(program);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix3fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glUniform4iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform4iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glUniform3iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform3iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glUniform2iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform2iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glUniform1iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform1iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glUniform4fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform4fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glUniform3fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform3fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glUniform2fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform2fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glUniform1fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform1fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
-{
-    d_2_0_Core->f.Uniform4i(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glUniform3i(GLint location, GLint v0, GLint v1, GLint v2)
-{
-    d_2_0_Core->f.Uniform3i(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glUniform2i(GLint location, GLint v0, GLint v1)
-{
-    d_2_0_Core->f.Uniform2i(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glUniform1i(GLint location, GLint v0)
-{
-    d_2_0_Core->f.Uniform1i(location, v0);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
-{
-    d_2_0_Core->f.Uniform4f(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
-{
-    d_2_0_Core->f.Uniform3f(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glUniform2f(GLint location, GLfloat v0, GLfloat v1)
-{
-    d_2_0_Core->f.Uniform2f(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glUniform1f(GLint location, GLfloat v0)
-{
-    d_2_0_Core->f.Uniform1f(location, v0);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glUseProgram(GLuint program)
-{
-    d_2_0_Core->f.UseProgram(program);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length)
-{
-    d_2_0_Core->f.ShaderSource(shader, count, string, length);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glLinkProgram(GLuint program)
-{
-    d_2_0_Core->f.LinkProgram(program);
-}
-
-inline GLboolean QOpenGLFunctions_3_2_Compatibility::glIsShader(GLuint shader)
-{
-    return d_2_0_Core->f.IsShader(shader);
-}
-
-inline GLboolean QOpenGLFunctions_3_2_Compatibility::glIsProgram(GLuint program)
-{
-    return d_2_0_Core->f.IsProgram(program);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer)
-{
-    d_2_0_Core->f.GetVertexAttribPointerv(index, pname, pointer);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetVertexAttribiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
-{
-    d_2_0_Core->f.GetVertexAttribfv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
-{
-    d_2_0_Core->f.GetVertexAttribdv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetUniformiv(GLuint program, GLint location, GLint *params)
-{
-    d_2_0_Core->f.GetUniformiv(program, location, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetUniformfv(GLuint program, GLint location, GLfloat *params)
-{
-    d_2_0_Core->f.GetUniformfv(program, location, params);
-}
-
-inline GLint QOpenGLFunctions_3_2_Compatibility::glGetUniformLocation(GLuint program, const GLchar *name)
-{
-    return d_2_0_Core->f.GetUniformLocation(program, name);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
-{
-    d_2_0_Core->f.GetShaderSource(shader, bufSize, length, source);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-{
-    d_2_0_Core->f.GetShaderInfoLog(shader, bufSize, length, infoLog);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetShaderiv(GLuint shader, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetShaderiv(shader, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-{
-    d_2_0_Core->f.GetProgramInfoLog(program, bufSize, length, infoLog);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetProgramiv(GLuint program, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetProgramiv(program, pname, params);
-}
-
-inline GLint QOpenGLFunctions_3_2_Compatibility::glGetAttribLocation(GLuint program, const GLchar *name)
-{
-    return d_2_0_Core->f.GetAttribLocation(program, name);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj)
-{
-    d_2_0_Core->f.GetAttachedShaders(program, maxCount, count, obj);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
-{
-    d_2_0_Core->f.GetActiveUniform(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
-{
-    d_2_0_Core->f.GetActiveAttrib(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glEnableVertexAttribArray(GLuint index)
-{
-    d_2_0_Core->f.EnableVertexAttribArray(index);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glDisableVertexAttribArray(GLuint index)
-{
-    d_2_0_Core->f.DisableVertexAttribArray(index);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glDetachShader(GLuint program, GLuint shader)
-{
-    d_2_0_Core->f.DetachShader(program, shader);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glDeleteShader(GLuint shader)
-{
-    d_2_0_Core->f.DeleteShader(shader);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glDeleteProgram(GLuint program)
-{
-    d_2_0_Core->f.DeleteProgram(program);
-}
-
-inline GLuint QOpenGLFunctions_3_2_Compatibility::glCreateShader(GLenum type)
-{
-    return d_2_0_Core->f.CreateShader(type);
-}
-
-inline GLuint QOpenGLFunctions_3_2_Compatibility::glCreateProgram()
-{
-    return d_2_0_Core->f.CreateProgram();
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glCompileShader(GLuint shader)
-{
-    d_2_0_Core->f.CompileShader(shader);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glBindAttribLocation(GLuint program, GLuint index, const GLchar *name)
-{
-    d_2_0_Core->f.BindAttribLocation(program, index, name);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glAttachShader(GLuint program, GLuint shader)
-{
-    d_2_0_Core->f.AttachShader(program, shader);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glStencilMaskSeparate(GLenum face, GLuint mask)
-{
-    d_2_0_Core->f.StencilMaskSeparate(face, mask);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
-{
-    d_2_0_Core->f.StencilFuncSeparate(face, func, ref, mask);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
-{
-    d_2_0_Core->f.StencilOpSeparate(face, sfail, dpfail, dppass);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glDrawBuffers(GLsizei n, const GLenum *bufs)
-{
-    d_2_0_Core->f.DrawBuffers(n, bufs);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
-{
-    d_2_0_Core->f.BlendEquationSeparate(modeRGB, modeAlpha);
-}
-
-
-// OpenGL 2.1 core functions
-inline void QOpenGLFunctions_3_2_Compatibility::glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix4x3fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix3x4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix4x2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix2x4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix3x2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix2x3fv(location, count, transpose, value);
-}
-
-
-// OpenGL 3.0 core functions
-inline GLboolean QOpenGLFunctions_3_2_Compatibility::glIsVertexArray(GLuint array)
-{
-    return d_3_0_Core->f.IsVertexArray(array);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGenVertexArrays(GLsizei n, GLuint *arrays)
-{
-    d_3_0_Core->f.GenVertexArrays(n, arrays);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glDeleteVertexArrays(GLsizei n, const GLuint *arrays)
-{
-    d_3_0_Core->f.DeleteVertexArrays(n, arrays);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glBindVertexArray(GLuint array)
-{
-    d_3_0_Core->f.BindVertexArray(array);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
-{
-    d_3_0_Core->f.FlushMappedBufferRange(target, offset, length);
-}
-
-inline GLvoid* QOpenGLFunctions_3_2_Compatibility::glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
-{
-    return d_3_0_Core->f.MapBufferRange(target, offset, length, access);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
-{
-    d_3_0_Core->f.FramebufferTextureLayer(target, attachment, texture, level, layer);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    d_3_0_Core->f.RenderbufferStorageMultisample(target, samples, internalformat, width, height);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
-{
-    d_3_0_Core->f.BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGenerateMipmap(GLenum target)
-{
-    d_3_0_Core->f.GenerateMipmap(target);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
-{
-    d_3_0_Core->f.FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
-{
-    d_3_0_Core->f.FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
-{
-    d_3_0_Core->f.FramebufferTexture2D(target, attachment, textarget, texture, level);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
-{
-    d_3_0_Core->f.FramebufferTexture1D(target, attachment, textarget, texture, level);
-}
-
-inline GLenum QOpenGLFunctions_3_2_Compatibility::glCheckFramebufferStatus(GLenum target)
-{
-    return d_3_0_Core->f.CheckFramebufferStatus(target);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGenFramebuffers(GLsizei n, GLuint *framebuffers)
-{
-    d_3_0_Core->f.GenFramebuffers(n, framebuffers);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
-{
-    d_3_0_Core->f.DeleteFramebuffers(n, framebuffers);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glBindFramebuffer(GLenum target, GLuint framebuffer)
-{
-    d_3_0_Core->f.BindFramebuffer(target, framebuffer);
-}
-
-inline GLboolean QOpenGLFunctions_3_2_Compatibility::glIsFramebuffer(GLuint framebuffer)
-{
-    return d_3_0_Core->f.IsFramebuffer(framebuffer);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetRenderbufferParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    d_3_0_Core->f.RenderbufferStorage(target, internalformat, width, height);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGenRenderbuffers(GLsizei n, GLuint *renderbuffers)
-{
-    d_3_0_Core->f.GenRenderbuffers(n, renderbuffers);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
-{
-    d_3_0_Core->f.DeleteRenderbuffers(n, renderbuffers);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glBindRenderbuffer(GLenum target, GLuint renderbuffer)
-{
-    d_3_0_Core->f.BindRenderbuffer(target, renderbuffer);
-}
-
-inline GLboolean QOpenGLFunctions_3_2_Compatibility::glIsRenderbuffer(GLuint renderbuffer)
-{
-    return d_3_0_Core->f.IsRenderbuffer(renderbuffer);
-}
-
-inline const GLubyte * QOpenGLFunctions_3_2_Compatibility::glGetStringi(GLenum name, GLuint index)
-{
-    return d_3_0_Core->f.GetStringi(name, index);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
-{
-    d_3_0_Core->f.ClearBufferfi(buffer, drawbuffer, depth, stencil);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
-{
-    d_3_0_Core->f.ClearBufferfv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
-{
-    d_3_0_Core->f.ClearBufferuiv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
-{
-    d_3_0_Core->f.ClearBufferiv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params)
-{
-    d_3_0_Core->f.GetTexParameterIuiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetTexParameterIiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params)
-{
-    d_3_0_Core->f.TexParameterIuiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexParameterIiv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_3_0_Core->f.TexParameterIiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glUniform4uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform4uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glUniform3uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform3uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glUniform2uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform2uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glUniform1uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform1uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
-{
-    d_3_0_Core->f.Uniform4ui(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
-{
-    d_3_0_Core->f.Uniform3ui(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glUniform2ui(GLint location, GLuint v0, GLuint v1)
-{
-    d_3_0_Core->f.Uniform2ui(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glUniform1ui(GLint location, GLuint v0)
-{
-    d_3_0_Core->f.Uniform1ui(location, v0);
-}
-
-inline GLint QOpenGLFunctions_3_2_Compatibility::glGetFragDataLocation(GLuint program, const GLchar *name)
-{
-    return d_3_0_Core->f.GetFragDataLocation(program, name);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name)
-{
-    d_3_0_Core->f.BindFragDataLocation(program, color, name);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetUniformuiv(GLuint program, GLint location, GLuint *params)
-{
-    d_3_0_Core->f.GetUniformuiv(program, location, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
-{
-    d_3_0_Core->f.GetVertexAttribIuiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetVertexAttribIiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_3_0_Core->f.VertexAttribIPointer(index, size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glEndConditionalRender()
-{
-    d_3_0_Core->f.EndConditionalRender();
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glBeginConditionalRender(GLuint id, GLenum mode)
-{
-    d_3_0_Core->f.BeginConditionalRender(id, mode);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glClampColor(GLenum target, GLenum clamp)
-{
-    d_3_0_Core->f.ClampColor(target, clamp);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
-{
-    d_3_0_Core->f.GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode)
-{
-    d_3_0_Core->f.TransformFeedbackVaryings(program, count, varyings, bufferMode);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
-{
-    d_3_0_Core->f.BindBufferBase(target, index, buffer);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
-{
-    d_3_0_Core->f.BindBufferRange(target, index, buffer, offset, size);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glEndTransformFeedback()
-{
-    d_3_0_Core->f.EndTransformFeedback();
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glBeginTransformFeedback(GLenum primitiveMode)
-{
-    d_3_0_Core->f.BeginTransformFeedback(primitiveMode);
-}
-
-inline GLboolean QOpenGLFunctions_3_2_Compatibility::glIsEnabledi(GLenum target, GLuint index)
-{
-    return d_3_0_Core->f.IsEnabledi(target, index);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glDisablei(GLenum target, GLuint index)
-{
-    d_3_0_Core->f.Disablei(target, index);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glEnablei(GLenum target, GLuint index)
-{
-    d_3_0_Core->f.Enablei(target, index);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetIntegeri_v(GLenum target, GLuint index, GLint *data)
-{
-    d_3_0_Core->f.GetIntegeri_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetBooleani_v(GLenum target, GLuint index, GLboolean *data)
-{
-    d_3_0_Core->f.GetBooleani_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
-{
-    d_3_0_Core->f.ColorMaski(index, r, g, b, a);
-}
-
-
-// OpenGL 3.1 core functions
-inline void QOpenGLFunctions_3_2_Compatibility::glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
-{
-    d_3_1_Core->f.CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
-{
-    d_3_1_Core->f.UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
-{
-    d_3_1_Core->f.GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params)
-{
-    d_3_1_Core->f.GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
-}
-
-inline GLuint QOpenGLFunctions_3_2_Compatibility::glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName)
-{
-    return d_3_1_Core->f.GetUniformBlockIndex(program, uniformBlockName);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName)
-{
-    d_3_1_Core->f.GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params)
-{
-    d_3_1_Core->f.GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const *uniformNames, GLuint *uniformIndices)
-{
-    d_3_1_Core->f.GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glPrimitiveRestartIndex(GLuint index)
-{
-    d_3_1_Core->f.PrimitiveRestartIndex(index);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer)
-{
-    d_3_1_Core->f.TexBuffer(target, internalformat, buffer);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount)
-{
-    d_3_1_Core->f.DrawElementsInstanced(mode, count, type, indices, instancecount);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount)
-{
-    d_3_1_Core->f.DrawArraysInstanced(mode, first, count, instancecount);
-}
-
-
-// OpenGL 3.2 core functions
-inline void QOpenGLFunctions_3_2_Compatibility::glSampleMaski(GLuint index, GLbitfield mask)
-{
-    d_3_2_Core->f.SampleMaski(index, mask);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val)
-{
-    d_3_2_Core->f.GetMultisamplefv(pname, index, val);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexImage3DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
-{
-    d_3_2_Core->f.TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexImage2DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
-{
-    d_3_2_Core->f.TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values)
-{
-    d_3_2_Core->f.GetSynciv(sync, pname, bufSize, length, values);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetInteger64v(GLenum pname, GLint64 *params)
-{
-    d_3_2_Core->f.GetInteger64v(pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
-{
-    d_3_2_Core->f.WaitSync(sync, flags, timeout);
-}
-
-inline GLenum QOpenGLFunctions_3_2_Compatibility::glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
-{
-    return d_3_2_Core->f.ClientWaitSync(sync, flags, timeout);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glDeleteSync(GLsync sync)
-{
-    d_3_2_Core->f.DeleteSync(sync);
-}
-
-inline GLboolean QOpenGLFunctions_3_2_Compatibility::glIsSync(GLsync sync)
-{
-    return d_3_2_Core->f.IsSync(sync);
-}
-
-inline GLsync QOpenGLFunctions_3_2_Compatibility::glFenceSync(GLenum condition, GLbitfield flags)
-{
-    return d_3_2_Core->f.FenceSync(condition, flags);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glProvokingVertex(GLenum mode)
-{
-    d_3_2_Core->f.ProvokingVertex(mode);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glMultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount, const GLint *basevertex)
-{
-    d_3_2_Core->f.MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount, GLint basevertex)
-{
-    d_3_2_Core->f.DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)
-{
-    d_3_2_Core->f.DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)
-{
-    d_3_2_Core->f.DrawElementsBaseVertex(mode, count, type, indices, basevertex);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level)
-{
-    d_3_2_Core->f.FramebufferTexture(target, attachment, texture, level);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params)
-{
-    d_3_2_Core->f.GetBufferParameteri64v(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data)
-{
-    d_3_2_Core->f.GetInteger64i_v(target, index, data);
-}
-
-
-// OpenGL 1.0 deprecated functions
-inline void QOpenGLFunctions_3_2_Compatibility::glTranslatef(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Translatef(x, y, z);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTranslated(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Translated(x, y, z);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glScalef(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Scalef(x, y, z);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glScaled(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Scaled(x, y, z);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Rotatef(angle, x, y, z);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Rotated(angle, x, y, z);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glPushMatrix()
-{
-    d_1_0_Deprecated->f.PushMatrix();
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glPopMatrix()
-{
-    d_1_0_Deprecated->f.PopMatrix();
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
-{
-    d_1_0_Deprecated->f.Ortho(left, right, bottom, top, zNear, zFar);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glMultMatrixd(const GLdouble *m)
-{
-    d_1_0_Deprecated->f.MultMatrixd(m);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glMultMatrixf(const GLfloat *m)
-{
-    d_1_0_Deprecated->f.MultMatrixf(m);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glMatrixMode(GLenum mode)
-{
-    d_1_0_Deprecated->f.MatrixMode(mode);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glLoadMatrixd(const GLdouble *m)
-{
-    d_1_0_Deprecated->f.LoadMatrixd(m);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glLoadMatrixf(const GLfloat *m)
-{
-    d_1_0_Deprecated->f.LoadMatrixf(m);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glLoadIdentity()
-{
-    d_1_0_Deprecated->f.LoadIdentity();
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
-{
-    d_1_0_Deprecated->f.Frustum(left, right, bottom, top, zNear, zFar);
-}
-
-inline GLboolean QOpenGLFunctions_3_2_Compatibility::glIsList(GLuint list)
-{
-    return d_1_0_Deprecated->f.IsList(list);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetTexGeniv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetTexGenfv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
-{
-    d_1_0_Deprecated->f.GetTexGendv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetTexEnviv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetTexEnviv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetTexEnvfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetPolygonStipple(GLubyte *mask)
-{
-    d_1_0_Deprecated->f.GetPolygonStipple(mask);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetPixelMapusv(GLenum map, GLushort *values)
-{
-    d_1_0_Deprecated->f.GetPixelMapusv(map, values);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetPixelMapuiv(GLenum map, GLuint *values)
-{
-    d_1_0_Deprecated->f.GetPixelMapuiv(map, values);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetPixelMapfv(GLenum map, GLfloat *values)
-{
-    d_1_0_Deprecated->f.GetPixelMapfv(map, values);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetMaterialiv(GLenum face, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetMaterialiv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetMaterialfv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetMapiv(GLenum target, GLenum query, GLint *v)
-{
-    d_1_0_Deprecated->f.GetMapiv(target, query, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetMapfv(GLenum target, GLenum query, GLfloat *v)
-{
-    d_1_0_Deprecated->f.GetMapfv(target, query, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetMapdv(GLenum target, GLenum query, GLdouble *v)
-{
-    d_1_0_Deprecated->f.GetMapdv(target, query, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetLightiv(GLenum light, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetLightiv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetLightfv(GLenum light, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetLightfv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetClipPlane(GLenum plane, GLdouble *equation)
-{
-    d_1_0_Deprecated->f.GetClipPlane(plane, equation);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Deprecated->f.DrawPixels(width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
-{
-    d_1_0_Deprecated->f.CopyPixels(x, y, width, height, type);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values)
-{
-    d_1_0_Deprecated->f.PixelMapusv(map, mapsize, values);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values)
-{
-    d_1_0_Deprecated->f.PixelMapuiv(map, mapsize, values);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values)
-{
-    d_1_0_Deprecated->f.PixelMapfv(map, mapsize, values);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glPixelTransferi(GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.PixelTransferi(pname, param);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glPixelTransferf(GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.PixelTransferf(pname, param);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glPixelZoom(GLfloat xfactor, GLfloat yfactor)
-{
-    d_1_0_Deprecated->f.PixelZoom(xfactor, yfactor);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glAlphaFunc(GLenum func, GLfloat ref)
-{
-    d_1_0_Deprecated->f.AlphaFunc(func, ref);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glEvalPoint2(GLint i, GLint j)
-{
-    d_1_0_Deprecated->f.EvalPoint2(i, j);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
-{
-    d_1_0_Deprecated->f.EvalMesh2(mode, i1, i2, j1, j2);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glEvalPoint1(GLint i)
-{
-    d_1_0_Deprecated->f.EvalPoint1(i);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glEvalMesh1(GLenum mode, GLint i1, GLint i2)
-{
-    d_1_0_Deprecated->f.EvalMesh1(mode, i1, i2);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glEvalCoord2fv(const GLfloat *u)
-{
-    d_1_0_Deprecated->f.EvalCoord2fv(u);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glEvalCoord2f(GLfloat u, GLfloat v)
-{
-    d_1_0_Deprecated->f.EvalCoord2f(u, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glEvalCoord2dv(const GLdouble *u)
-{
-    d_1_0_Deprecated->f.EvalCoord2dv(u);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glEvalCoord2d(GLdouble u, GLdouble v)
-{
-    d_1_0_Deprecated->f.EvalCoord2d(u, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glEvalCoord1fv(const GLfloat *u)
-{
-    d_1_0_Deprecated->f.EvalCoord1fv(u);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glEvalCoord1f(GLfloat u)
-{
-    d_1_0_Deprecated->f.EvalCoord1f(u);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glEvalCoord1dv(const GLdouble *u)
-{
-    d_1_0_Deprecated->f.EvalCoord1dv(u);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glEvalCoord1d(GLdouble u)
-{
-    d_1_0_Deprecated->f.EvalCoord1d(u);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
-{
-    d_1_0_Deprecated->f.MapGrid2f(un, u1, u2, vn, v1, v2);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
-{
-    d_1_0_Deprecated->f.MapGrid2d(un, u1, u2, vn, v1, v2);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
-{
-    d_1_0_Deprecated->f.MapGrid1f(un, u1, u2);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
-{
-    d_1_0_Deprecated->f.MapGrid1d(un, u1, u2);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
-{
-    d_1_0_Deprecated->f.Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
-{
-    d_1_0_Deprecated->f.Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
-{
-    d_1_0_Deprecated->f.Map1f(target, u1, u2, stride, order, points);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
-{
-    d_1_0_Deprecated->f.Map1d(target, u1, u2, stride, order, points);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glPushAttrib(GLbitfield mask)
-{
-    d_1_0_Deprecated->f.PushAttrib(mask);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glPopAttrib()
-{
-    d_1_0_Deprecated->f.PopAttrib();
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glAccum(GLenum op, GLfloat value)
-{
-    d_1_0_Deprecated->f.Accum(op, value);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glIndexMask(GLuint mask)
-{
-    d_1_0_Deprecated->f.IndexMask(mask);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glClearIndex(GLfloat c)
-{
-    d_1_0_Deprecated->f.ClearIndex(c);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Deprecated->f.ClearAccum(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glPushName(GLuint name)
-{
-    d_1_0_Deprecated->f.PushName(name);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glPopName()
-{
-    d_1_0_Deprecated->f.PopName();
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glPassThrough(GLfloat token)
-{
-    d_1_0_Deprecated->f.PassThrough(token);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glLoadName(GLuint name)
-{
-    d_1_0_Deprecated->f.LoadName(name);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glInitNames()
-{
-    d_1_0_Deprecated->f.InitNames();
-}
-
-inline GLint QOpenGLFunctions_3_2_Compatibility::glRenderMode(GLenum mode)
-{
-    return d_1_0_Deprecated->f.RenderMode(mode);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glSelectBuffer(GLsizei size, GLuint *buffer)
-{
-    d_1_0_Deprecated->f.SelectBuffer(size, buffer);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
-{
-    d_1_0_Deprecated->f.FeedbackBuffer(size, type, buffer);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexGeniv(GLenum coord, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.TexGeniv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexGeni(GLenum coord, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.TexGeni(coord, pname, param);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.TexGenfv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexGenf(GLenum coord, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.TexGenf(coord, pname, param);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
-{
-    d_1_0_Deprecated->f.TexGendv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexGend(GLenum coord, GLenum pname, GLdouble param)
-{
-    d_1_0_Deprecated->f.TexGend(coord, pname, param);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexEnviv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.TexEnviv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexEnvi(GLenum target, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.TexEnvi(target, pname, param);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.TexEnvfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexEnvf(GLenum target, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.TexEnvf(target, pname, param);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glShadeModel(GLenum mode)
-{
-    d_1_0_Deprecated->f.ShadeModel(mode);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glPolygonStipple(const GLubyte *mask)
-{
-    d_1_0_Deprecated->f.PolygonStipple(mask);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glMaterialiv(GLenum face, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.Materialiv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glMateriali(GLenum face, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.Materiali(face, pname, param);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.Materialfv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glMaterialf(GLenum face, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.Materialf(face, pname, param);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glLineStipple(GLint factor, GLushort pattern)
-{
-    d_1_0_Deprecated->f.LineStipple(factor, pattern);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glLightModeliv(GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.LightModeliv(pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glLightModeli(GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.LightModeli(pname, param);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glLightModelfv(GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.LightModelfv(pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glLightModelf(GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.LightModelf(pname, param);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glLightiv(GLenum light, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.Lightiv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glLighti(GLenum light, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.Lighti(light, pname, param);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glLightfv(GLenum light, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.Lightfv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glLightf(GLenum light, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.Lightf(light, pname, param);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glFogiv(GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.Fogiv(pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glFogi(GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.Fogi(pname, param);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glFogfv(GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.Fogfv(pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glFogf(GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.Fogf(pname, param);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glColorMaterial(GLenum face, GLenum mode)
-{
-    d_1_0_Deprecated->f.ColorMaterial(face, mode);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glClipPlane(GLenum plane, const GLdouble *equation)
-{
-    d_1_0_Deprecated->f.ClipPlane(plane, equation);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertex4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Vertex4sv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
-{
-    d_1_0_Deprecated->f.Vertex4s(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertex4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Vertex4iv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertex4i(GLint x, GLint y, GLint z, GLint w)
-{
-    d_1_0_Deprecated->f.Vertex4i(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertex4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Vertex4fv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    d_1_0_Deprecated->f.Vertex4f(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertex4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Vertex4dv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_1_0_Deprecated->f.Vertex4d(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertex3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Vertex3sv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertex3s(GLshort x, GLshort y, GLshort z)
-{
-    d_1_0_Deprecated->f.Vertex3s(x, y, z);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertex3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Vertex3iv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertex3i(GLint x, GLint y, GLint z)
-{
-    d_1_0_Deprecated->f.Vertex3i(x, y, z);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertex3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Vertex3fv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertex3f(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Vertex3f(x, y, z);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertex3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Vertex3dv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertex3d(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Vertex3d(x, y, z);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertex2sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Vertex2sv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertex2s(GLshort x, GLshort y)
-{
-    d_1_0_Deprecated->f.Vertex2s(x, y);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertex2iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Vertex2iv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertex2i(GLint x, GLint y)
-{
-    d_1_0_Deprecated->f.Vertex2i(x, y);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertex2fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Vertex2fv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertex2f(GLfloat x, GLfloat y)
-{
-    d_1_0_Deprecated->f.Vertex2f(x, y);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertex2dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Vertex2dv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertex2d(GLdouble x, GLdouble y)
-{
-    d_1_0_Deprecated->f.Vertex2d(x, y);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord4sv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
-{
-    d_1_0_Deprecated->f.TexCoord4s(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord4iv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
-{
-    d_1_0_Deprecated->f.TexCoord4i(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord4fv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
-{
-    d_1_0_Deprecated->f.TexCoord4f(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord4dv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
-{
-    d_1_0_Deprecated->f.TexCoord4d(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord3sv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord3s(GLshort s, GLshort t, GLshort r)
-{
-    d_1_0_Deprecated->f.TexCoord3s(s, t, r);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord3iv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord3i(GLint s, GLint t, GLint r)
-{
-    d_1_0_Deprecated->f.TexCoord3i(s, t, r);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord3fv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
-{
-    d_1_0_Deprecated->f.TexCoord3f(s, t, r);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord3dv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
-{
-    d_1_0_Deprecated->f.TexCoord3d(s, t, r);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord2sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord2sv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord2s(GLshort s, GLshort t)
-{
-    d_1_0_Deprecated->f.TexCoord2s(s, t);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord2iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord2iv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord2i(GLint s, GLint t)
-{
-    d_1_0_Deprecated->f.TexCoord2i(s, t);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord2fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord2fv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord2f(GLfloat s, GLfloat t)
-{
-    d_1_0_Deprecated->f.TexCoord2f(s, t);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord2dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord2dv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord2d(GLdouble s, GLdouble t)
-{
-    d_1_0_Deprecated->f.TexCoord2d(s, t);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord1sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord1sv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord1s(GLshort s)
-{
-    d_1_0_Deprecated->f.TexCoord1s(s);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord1iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord1iv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord1i(GLint s)
-{
-    d_1_0_Deprecated->f.TexCoord1i(s);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord1fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord1fv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord1f(GLfloat s)
-{
-    d_1_0_Deprecated->f.TexCoord1f(s);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord1dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord1dv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord1d(GLdouble s)
-{
-    d_1_0_Deprecated->f.TexCoord1d(s);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glRectsv(const GLshort *v1, const GLshort *v2)
-{
-    d_1_0_Deprecated->f.Rectsv(v1, v2);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
-{
-    d_1_0_Deprecated->f.Rects(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glRectiv(const GLint *v1, const GLint *v2)
-{
-    d_1_0_Deprecated->f.Rectiv(v1, v2);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
-{
-    d_1_0_Deprecated->f.Recti(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glRectfv(const GLfloat *v1, const GLfloat *v2)
-{
-    d_1_0_Deprecated->f.Rectfv(v1, v2);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
-{
-    d_1_0_Deprecated->f.Rectf(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glRectdv(const GLdouble *v1, const GLdouble *v2)
-{
-    d_1_0_Deprecated->f.Rectdv(v1, v2);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
-{
-    d_1_0_Deprecated->f.Rectd(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glRasterPos4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.RasterPos4sv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
-{
-    d_1_0_Deprecated->f.RasterPos4s(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glRasterPos4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.RasterPos4iv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
-{
-    d_1_0_Deprecated->f.RasterPos4i(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glRasterPos4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.RasterPos4fv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    d_1_0_Deprecated->f.RasterPos4f(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glRasterPos4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.RasterPos4dv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_1_0_Deprecated->f.RasterPos4d(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glRasterPos3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.RasterPos3sv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glRasterPos3s(GLshort x, GLshort y, GLshort z)
-{
-    d_1_0_Deprecated->f.RasterPos3s(x, y, z);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glRasterPos3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.RasterPos3iv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glRasterPos3i(GLint x, GLint y, GLint z)
-{
-    d_1_0_Deprecated->f.RasterPos3i(x, y, z);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glRasterPos3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.RasterPos3fv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.RasterPos3f(x, y, z);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glRasterPos3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.RasterPos3dv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.RasterPos3d(x, y, z);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glRasterPos2sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.RasterPos2sv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glRasterPos2s(GLshort x, GLshort y)
-{
-    d_1_0_Deprecated->f.RasterPos2s(x, y);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glRasterPos2iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.RasterPos2iv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glRasterPos2i(GLint x, GLint y)
-{
-    d_1_0_Deprecated->f.RasterPos2i(x, y);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glRasterPos2fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.RasterPos2fv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glRasterPos2f(GLfloat x, GLfloat y)
-{
-    d_1_0_Deprecated->f.RasterPos2f(x, y);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glRasterPos2dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.RasterPos2dv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glRasterPos2d(GLdouble x, GLdouble y)
-{
-    d_1_0_Deprecated->f.RasterPos2d(x, y);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glNormal3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Normal3sv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glNormal3s(GLshort nx, GLshort ny, GLshort nz)
-{
-    d_1_0_Deprecated->f.Normal3s(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glNormal3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Normal3iv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glNormal3i(GLint nx, GLint ny, GLint nz)
-{
-    d_1_0_Deprecated->f.Normal3i(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glNormal3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Normal3fv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
-{
-    d_1_0_Deprecated->f.Normal3f(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glNormal3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Normal3dv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
-{
-    d_1_0_Deprecated->f.Normal3d(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glNormal3bv(const GLbyte *v)
-{
-    d_1_0_Deprecated->f.Normal3bv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
-{
-    d_1_0_Deprecated->f.Normal3b(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glIndexsv(const GLshort *c)
-{
-    d_1_0_Deprecated->f.Indexsv(c);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glIndexs(GLshort c)
-{
-    d_1_0_Deprecated->f.Indexs(c);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glIndexiv(const GLint *c)
-{
-    d_1_0_Deprecated->f.Indexiv(c);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glIndexi(GLint c)
-{
-    d_1_0_Deprecated->f.Indexi(c);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glIndexfv(const GLfloat *c)
-{
-    d_1_0_Deprecated->f.Indexfv(c);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glIndexf(GLfloat c)
-{
-    d_1_0_Deprecated->f.Indexf(c);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glIndexdv(const GLdouble *c)
-{
-    d_1_0_Deprecated->f.Indexdv(c);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glIndexd(GLdouble c)
-{
-    d_1_0_Deprecated->f.Indexd(c);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glEnd()
-{
-    d_1_0_Deprecated->f.End();
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glEdgeFlagv(const GLboolean *flag)
-{
-    d_1_0_Deprecated->f.EdgeFlagv(flag);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glEdgeFlag(GLboolean flag)
-{
-    d_1_0_Deprecated->f.EdgeFlag(flag);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glColor4usv(const GLushort *v)
-{
-    d_1_0_Deprecated->f.Color4usv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
-{
-    d_1_0_Deprecated->f.Color4us(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glColor4uiv(const GLuint *v)
-{
-    d_1_0_Deprecated->f.Color4uiv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
-{
-    d_1_0_Deprecated->f.Color4ui(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glColor4ubv(const GLubyte *v)
-{
-    d_1_0_Deprecated->f.Color4ubv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
-{
-    d_1_0_Deprecated->f.Color4ub(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glColor4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Color4sv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
-{
-    d_1_0_Deprecated->f.Color4s(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glColor4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Color4iv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
-{
-    d_1_0_Deprecated->f.Color4i(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glColor4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Color4fv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Deprecated->f.Color4f(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glColor4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Color4dv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
-{
-    d_1_0_Deprecated->f.Color4d(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glColor4bv(const GLbyte *v)
-{
-    d_1_0_Deprecated->f.Color4bv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
-{
-    d_1_0_Deprecated->f.Color4b(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glColor3usv(const GLushort *v)
-{
-    d_1_0_Deprecated->f.Color3usv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glColor3us(GLushort red, GLushort green, GLushort blue)
-{
-    d_1_0_Deprecated->f.Color3us(red, green, blue);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glColor3uiv(const GLuint *v)
-{
-    d_1_0_Deprecated->f.Color3uiv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glColor3ui(GLuint red, GLuint green, GLuint blue)
-{
-    d_1_0_Deprecated->f.Color3ui(red, green, blue);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glColor3ubv(const GLubyte *v)
-{
-    d_1_0_Deprecated->f.Color3ubv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
-{
-    d_1_0_Deprecated->f.Color3ub(red, green, blue);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glColor3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Color3sv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glColor3s(GLshort red, GLshort green, GLshort blue)
-{
-    d_1_0_Deprecated->f.Color3s(red, green, blue);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glColor3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Color3iv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glColor3i(GLint red, GLint green, GLint blue)
-{
-    d_1_0_Deprecated->f.Color3i(red, green, blue);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glColor3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Color3fv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glColor3f(GLfloat red, GLfloat green, GLfloat blue)
-{
-    d_1_0_Deprecated->f.Color3f(red, green, blue);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glColor3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Color3dv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glColor3d(GLdouble red, GLdouble green, GLdouble blue)
-{
-    d_1_0_Deprecated->f.Color3d(red, green, blue);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glColor3bv(const GLbyte *v)
-{
-    d_1_0_Deprecated->f.Color3bv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glColor3b(GLbyte red, GLbyte green, GLbyte blue)
-{
-    d_1_0_Deprecated->f.Color3b(red, green, blue);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
-{
-    d_1_0_Deprecated->f.Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glBegin(GLenum mode)
-{
-    d_1_0_Deprecated->f.Begin(mode);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glListBase(GLuint base)
-{
-    d_1_0_Deprecated->f.ListBase(base);
-}
-
-inline GLuint QOpenGLFunctions_3_2_Compatibility::glGenLists(GLsizei range)
-{
-    return d_1_0_Deprecated->f.GenLists(range);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glDeleteLists(GLuint list, GLsizei range)
-{
-    d_1_0_Deprecated->f.DeleteLists(list, range);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glCallLists(GLsizei n, GLenum type, const GLvoid *lists)
-{
-    d_1_0_Deprecated->f.CallLists(n, type, lists);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glCallList(GLuint list)
-{
-    d_1_0_Deprecated->f.CallList(list);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glEndList()
-{
-    d_1_0_Deprecated->f.EndList();
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glNewList(GLuint list, GLenum mode)
-{
-    d_1_0_Deprecated->f.NewList(list, mode);
-}
-
-
-// OpenGL 1.1 deprecated functions
-inline void QOpenGLFunctions_3_2_Compatibility::glPushClientAttrib(GLbitfield mask)
-{
-    d_1_1_Deprecated->f.PushClientAttrib(mask);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glPopClientAttrib()
-{
-    d_1_1_Deprecated->f.PopClientAttrib();
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities)
-{
-    d_1_1_Deprecated->f.PrioritizeTextures(n, textures, priorities);
-}
-
-inline GLboolean QOpenGLFunctions_3_2_Compatibility::glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
-{
-    return d_1_1_Deprecated->f.AreTexturesResident(n, textures, residences);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.VertexPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.TexCoordPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.NormalPointer(type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.InterleavedArrays(format, stride, pointer);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.IndexPointer(type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glEnableClientState(GLenum array)
-{
-    d_1_1_Deprecated->f.EnableClientState(array);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.EdgeFlagPointer(stride, pointer);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glDisableClientState(GLenum array)
-{
-    d_1_1_Deprecated->f.DisableClientState(array);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.ColorPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glArrayElement(GLint i)
-{
-    d_1_1_Deprecated->f.ArrayElement(i);
-}
-
-
-// OpenGL 1.2 deprecated functions
-inline void QOpenGLFunctions_3_2_Compatibility::glResetMinmax(GLenum target)
-{
-    d_1_2_Deprecated->f.ResetMinmax(target);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glResetHistogram(GLenum target)
-{
-    d_1_2_Deprecated->f.ResetHistogram(target);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glMinmax(GLenum target, GLenum internalformat, GLboolean sink)
-{
-    d_1_2_Deprecated->f.Minmax(target, internalformat, sink);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
-{
-    d_1_2_Deprecated->f.Histogram(target, width, internalformat, sink);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetMinmaxParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetMinmaxParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
-{
-    d_1_2_Deprecated->f.GetMinmax(target, reset, format, type, values);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetHistogramParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetHistogramParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
-{
-    d_1_2_Deprecated->f.GetHistogram(target, reset, format, type, values);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column)
-{
-    d_1_2_Deprecated->f.SeparableFilter2D(target, internalformat, width, height, format, type, row, column);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span)
-{
-    d_1_2_Deprecated->f.GetSeparableFilter(target, format, type, row, column, span);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetConvolutionParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetConvolutionParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image)
-{
-    d_1_2_Deprecated->f.GetConvolutionFilter(target, format, type, image);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_2_Deprecated->f.CopyConvolutionFilter2D(target, internalformat, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
-{
-    d_1_2_Deprecated->f.CopyConvolutionFilter1D(target, internalformat, x, y, width);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glConvolutionParameteri(GLenum target, GLenum pname, GLint params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameteri(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameterf(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image)
-{
-    d_1_2_Deprecated->f.ConvolutionFilter2D(target, internalformat, width, height, format, type, image);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image)
-{
-    d_1_2_Deprecated->f.ConvolutionFilter1D(target, internalformat, width, format, type, image);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
-{
-    d_1_2_Deprecated->f.CopyColorSubTable(target, start, x, y, width);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data)
-{
-    d_1_2_Deprecated->f.ColorSubTable(target, start, count, format, type, data);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetColorTableParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetColorTableParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table)
-{
-    d_1_2_Deprecated->f.GetColorTable(target, format, type, table);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
-{
-    d_1_2_Deprecated->f.CopyColorTable(target, internalformat, x, y, width);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_2_Deprecated->f.ColorTableParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_2_Deprecated->f.ColorTableParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table)
-{
-    d_1_2_Deprecated->f.ColorTable(target, internalformat, width, format, type, table);
-}
-
-
-// OpenGL 1.3 deprecated functions
-inline void QOpenGLFunctions_3_2_Compatibility::glMultTransposeMatrixd(const GLdouble *m)
-{
-    d_1_3_Deprecated->f.MultTransposeMatrixd(m);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glMultTransposeMatrixf(const GLfloat *m)
-{
-    d_1_3_Deprecated->f.MultTransposeMatrixf(m);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glLoadTransposeMatrixd(const GLdouble *m)
-{
-    d_1_3_Deprecated->f.LoadTransposeMatrixd(m);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glLoadTransposeMatrixf(const GLfloat *m)
-{
-    d_1_3_Deprecated->f.LoadTransposeMatrixf(m);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord4sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4sv(target, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4s(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord4iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4iv(target, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4i(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord4fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4fv(target, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4f(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord4dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4dv(target, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4d(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord3sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3sv(target, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3s(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord3iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3iv(target, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3i(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord3fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3fv(target, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3f(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord3dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3dv(target, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3d(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord2sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2sv(target, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord2s(GLenum target, GLshort s, GLshort t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2s(target, s, t);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord2iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2iv(target, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord2i(GLenum target, GLint s, GLint t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2i(target, s, t);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord2fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2fv(target, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2f(target, s, t);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord2dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2dv(target, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2d(target, s, t);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord1sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1sv(target, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord1s(GLenum target, GLshort s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1s(target, s);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord1iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1iv(target, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord1i(GLenum target, GLint s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1i(target, s);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord1fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1fv(target, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord1f(GLenum target, GLfloat s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1f(target, s);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord1dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1dv(target, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord1d(GLenum target, GLdouble s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1d(target, s);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glClientActiveTexture(GLenum texture)
-{
-    d_1_3_Deprecated->f.ClientActiveTexture(texture);
-}
-
-
-// OpenGL 1.4 deprecated functions
-inline void QOpenGLFunctions_3_2_Compatibility::glWindowPos3sv(const GLshort *v)
-{
-    d_1_4_Deprecated->f.WindowPos3sv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glWindowPos3s(GLshort x, GLshort y, GLshort z)
-{
-    d_1_4_Deprecated->f.WindowPos3s(x, y, z);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glWindowPos3iv(const GLint *v)
-{
-    d_1_4_Deprecated->f.WindowPos3iv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glWindowPos3i(GLint x, GLint y, GLint z)
-{
-    d_1_4_Deprecated->f.WindowPos3i(x, y, z);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glWindowPos3fv(const GLfloat *v)
-{
-    d_1_4_Deprecated->f.WindowPos3fv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glWindowPos3f(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_4_Deprecated->f.WindowPos3f(x, y, z);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glWindowPos3dv(const GLdouble *v)
-{
-    d_1_4_Deprecated->f.WindowPos3dv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glWindowPos3d(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_4_Deprecated->f.WindowPos3d(x, y, z);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glWindowPos2sv(const GLshort *v)
-{
-    d_1_4_Deprecated->f.WindowPos2sv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glWindowPos2s(GLshort x, GLshort y)
-{
-    d_1_4_Deprecated->f.WindowPos2s(x, y);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glWindowPos2iv(const GLint *v)
-{
-    d_1_4_Deprecated->f.WindowPos2iv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glWindowPos2i(GLint x, GLint y)
-{
-    d_1_4_Deprecated->f.WindowPos2i(x, y);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glWindowPos2fv(const GLfloat *v)
-{
-    d_1_4_Deprecated->f.WindowPos2fv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glWindowPos2f(GLfloat x, GLfloat y)
-{
-    d_1_4_Deprecated->f.WindowPos2f(x, y);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glWindowPos2dv(const GLdouble *v)
-{
-    d_1_4_Deprecated->f.WindowPos2dv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glWindowPos2d(GLdouble x, GLdouble y)
-{
-    d_1_4_Deprecated->f.WindowPos2d(x, y);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_4_Deprecated->f.SecondaryColorPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glSecondaryColor3usv(const GLushort *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3usv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glSecondaryColor3us(GLushort red, GLushort green, GLushort blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3us(red, green, blue);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glSecondaryColor3uiv(const GLuint *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3uiv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3ui(red, green, blue);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glSecondaryColor3ubv(const GLubyte *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3ubv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3ub(red, green, blue);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glSecondaryColor3sv(const GLshort *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3sv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glSecondaryColor3s(GLshort red, GLshort green, GLshort blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3s(red, green, blue);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glSecondaryColor3iv(const GLint *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3iv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glSecondaryColor3i(GLint red, GLint green, GLint blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3i(red, green, blue);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glSecondaryColor3fv(const GLfloat *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3fv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3f(red, green, blue);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glSecondaryColor3dv(const GLdouble *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3dv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3d(red, green, blue);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glSecondaryColor3bv(const GLbyte *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3bv(v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3b(red, green, blue);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glFogCoordPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_4_Deprecated->f.FogCoordPointer(type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glFogCoorddv(const GLdouble *coord)
-{
-    d_1_4_Deprecated->f.FogCoorddv(coord);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glFogCoordd(GLdouble coord)
-{
-    d_1_4_Deprecated->f.FogCoordd(coord);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glFogCoordfv(const GLfloat *coord)
-{
-    d_1_4_Deprecated->f.FogCoordfv(coord);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glFogCoordf(GLfloat coord)
-{
-    d_1_4_Deprecated->f.FogCoordf(coord);
-}
-
-
-// OpenGL 1.5 deprecated functions
-
-// OpenGL 2.0 deprecated functions
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4usv(GLuint index, const GLushort *v)
-{
-    d_2_0_Core->f.VertexAttrib4usv(index, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4uiv(GLuint index, const GLuint *v)
-{
-    d_2_0_Core->f.VertexAttrib4uiv(index, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4ubv(GLuint index, const GLubyte *v)
-{
-    d_2_0_Core->f.VertexAttrib4ubv(index, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4sv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib4sv(index, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
-{
-    d_2_0_Core->f.VertexAttrib4s(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4iv(GLuint index, const GLint *v)
-{
-    d_2_0_Core->f.VertexAttrib4iv(index, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4fv(GLuint index, const GLfloat *v)
-{
-    d_2_0_Core->f.VertexAttrib4fv(index, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    d_2_0_Core->f.VertexAttrib4f(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4dv(GLuint index, const GLdouble *v)
-{
-    d_2_0_Core->f.VertexAttrib4dv(index, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_2_0_Core->f.VertexAttrib4d(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4bv(GLuint index, const GLbyte *v)
-{
-    d_2_0_Core->f.VertexAttrib4bv(index, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4Nusv(GLuint index, const GLushort *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nusv(index, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4Nuiv(GLuint index, const GLuint *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nuiv(index, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4Nubv(GLuint index, const GLubyte *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nubv(index, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
-{
-    d_2_0_Core->f.VertexAttrib4Nub(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4Nsv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nsv(index, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4Niv(GLuint index, const GLint *v)
-{
-    d_2_0_Core->f.VertexAttrib4Niv(index, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4Nbv(GLuint index, const GLbyte *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nbv(index, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib3sv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib3sv(index, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
-{
-    d_2_0_Core->f.VertexAttrib3s(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib3fv(GLuint index, const GLfloat *v)
-{
-    d_2_0_Core->f.VertexAttrib3fv(index, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
-{
-    d_2_0_Core->f.VertexAttrib3f(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib3dv(GLuint index, const GLdouble *v)
-{
-    d_2_0_Core->f.VertexAttrib3dv(index, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
-{
-    d_2_0_Core->f.VertexAttrib3d(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib2sv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib2sv(index, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib2s(GLuint index, GLshort x, GLshort y)
-{
-    d_2_0_Core->f.VertexAttrib2s(index, x, y);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib2fv(GLuint index, const GLfloat *v)
-{
-    d_2_0_Core->f.VertexAttrib2fv(index, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
-{
-    d_2_0_Core->f.VertexAttrib2f(index, x, y);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib2dv(GLuint index, const GLdouble *v)
-{
-    d_2_0_Core->f.VertexAttrib2dv(index, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
-{
-    d_2_0_Core->f.VertexAttrib2d(index, x, y);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib1sv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib1sv(index, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib1s(GLuint index, GLshort x)
-{
-    d_2_0_Core->f.VertexAttrib1s(index, x);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib1fv(GLuint index, const GLfloat *v)
-{
-    d_2_0_Core->f.VertexAttrib1fv(index, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib1f(GLuint index, GLfloat x)
-{
-    d_2_0_Core->f.VertexAttrib1f(index, x);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib1dv(GLuint index, const GLdouble *v)
-{
-    d_2_0_Core->f.VertexAttrib1dv(index, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib1d(GLuint index, GLdouble x)
-{
-    d_2_0_Core->f.VertexAttrib1d(index, x);
-}
-
-
-// OpenGL 2.1 deprecated functions
-
-// OpenGL 3.0 deprecated functions
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI4usv(GLuint index, const GLushort *v)
-{
-    d_3_0_Core->f.VertexAttribI4usv(index, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI4ubv(GLuint index, const GLubyte *v)
-{
-    d_3_0_Core->f.VertexAttribI4ubv(index, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI4sv(GLuint index, const GLshort *v)
-{
-    d_3_0_Core->f.VertexAttribI4sv(index, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI4bv(GLuint index, const GLbyte *v)
-{
-    d_3_0_Core->f.VertexAttribI4bv(index, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI4uiv(GLuint index, const GLuint *v)
-{
-    d_3_0_Core->f.VertexAttribI4uiv(index, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI3uiv(GLuint index, const GLuint *v)
-{
-    d_3_0_Core->f.VertexAttribI3uiv(index, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI2uiv(GLuint index, const GLuint *v)
-{
-    d_3_0_Core->f.VertexAttribI2uiv(index, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI1uiv(GLuint index, const GLuint *v)
-{
-    d_3_0_Core->f.VertexAttribI1uiv(index, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI4iv(GLuint index, const GLint *v)
-{
-    d_3_0_Core->f.VertexAttribI4iv(index, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI3iv(GLuint index, const GLint *v)
-{
-    d_3_0_Core->f.VertexAttribI3iv(index, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI2iv(GLuint index, const GLint *v)
-{
-    d_3_0_Core->f.VertexAttribI2iv(index, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI1iv(GLuint index, const GLint *v)
-{
-    d_3_0_Core->f.VertexAttribI1iv(index, v);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
-{
-    d_3_0_Core->f.VertexAttribI4ui(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z)
-{
-    d_3_0_Core->f.VertexAttribI3ui(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI2ui(GLuint index, GLuint x, GLuint y)
-{
-    d_3_0_Core->f.VertexAttribI2ui(index, x, y);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI1ui(GLuint index, GLuint x)
-{
-    d_3_0_Core->f.VertexAttribI1ui(index, x);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
-{
-    d_3_0_Core->f.VertexAttribI4i(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI3i(GLuint index, GLint x, GLint y, GLint z)
-{
-    d_3_0_Core->f.VertexAttribI3i(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI2i(GLuint index, GLint x, GLint y)
-{
-    d_3_0_Core->f.VertexAttribI2i(index, x, y);
-}
-
-inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI1i(GLuint index, GLint x)
-{
-    d_3_0_Core->f.VertexAttribI1i(index, x);
-}
-
-
-// OpenGL 3.1 deprecated functions
-
-// OpenGL 3.2 deprecated functions
-
-
-QT_END_NAMESPACE
-
-#endif // QT_NO_OPENGL && !QT_OPENGL_ES_2
-
-#endif
diff --git a/src/gui/opengl/qopenglfunctions_3_2_core.cpp b/src/gui/opengl/qopenglfunctions_3_2_core.cpp
deleted file mode 100644
index ea89fc9e48..0000000000
--- a/src/gui/opengl/qopenglfunctions_3_2_core.cpp
+++ /dev/null
@@ -1,215 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#include "qopenglfunctions_3_2_core.h"
-#include "qopenglcontext.h"
-
-QT_BEGIN_NAMESPACE
-
-/*!
-    \class QOpenGLFunctions_3_2_Core
-    \inmodule QtGui
-    \since 5.1
-    \wrapper
-    \brief The QOpenGLFunctions_3_2_Core class provides all functions for OpenGL 3.2 core profile.
-
-    This class is a wrapper for functions from OpenGL 3.2 core profile.
-    See reference pages on \l {http://www.opengl.org/sdk/docs/}{opengl.org}
-    for function documentation.
-
-    \sa QAbstractOpenGLFunctions
-*/
-
-QOpenGLFunctions_3_2_Core::QOpenGLFunctions_3_2_Core()
- : QAbstractOpenGLFunctions()
- , d_1_0_Core(nullptr)
- , d_1_1_Core(nullptr)
- , d_1_2_Core(nullptr)
- , d_1_3_Core(nullptr)
- , d_1_4_Core(nullptr)
- , d_1_5_Core(nullptr)
- , d_2_0_Core(nullptr)
- , d_2_1_Core(nullptr)
- , d_3_0_Core(nullptr)
- , d_3_1_Core(nullptr)
- , d_3_2_Core(nullptr)
-{
-}
-
-QOpenGLFunctions_3_2_Core::~QOpenGLFunctions_3_2_Core()
-{
-    if (d_1_0_Core) {
-        d_1_0_Core->refs.deref();
-        Q_ASSERT(d_1_0_Core->refs.loadRelaxed());
-    }
-    if (d_1_1_Core) {
-        d_1_1_Core->refs.deref();
-        Q_ASSERT(d_1_1_Core->refs.loadRelaxed());
-    }
-    if (d_1_2_Core) {
-        d_1_2_Core->refs.deref();
-        Q_ASSERT(d_1_2_Core->refs.loadRelaxed());
-    }
-    if (d_1_3_Core) {
-        d_1_3_Core->refs.deref();
-        Q_ASSERT(d_1_3_Core->refs.loadRelaxed());
-    }
-    if (d_1_4_Core) {
-        d_1_4_Core->refs.deref();
-        Q_ASSERT(d_1_4_Core->refs.loadRelaxed());
-    }
-    if (d_1_5_Core) {
-        d_1_5_Core->refs.deref();
-        Q_ASSERT(d_1_5_Core->refs.loadRelaxed());
-    }
-    if (d_2_0_Core) {
-        d_2_0_Core->refs.deref();
-        Q_ASSERT(d_2_0_Core->refs.loadRelaxed());
-    }
-    if (d_2_1_Core) {
-        d_2_1_Core->refs.deref();
-        Q_ASSERT(d_2_1_Core->refs.loadRelaxed());
-    }
-    if (d_3_0_Core) {
-        d_3_0_Core->refs.deref();
-        Q_ASSERT(d_3_0_Core->refs.loadRelaxed());
-    }
-    if (d_3_1_Core) {
-        d_3_1_Core->refs.deref();
-        Q_ASSERT(d_3_1_Core->refs.loadRelaxed());
-    }
-    if (d_3_2_Core) {
-        d_3_2_Core->refs.deref();
-        Q_ASSERT(d_3_2_Core->refs.loadRelaxed());
-    }
-}
-
-bool QOpenGLFunctions_3_2_Core::initializeOpenGLFunctions()
-{
-    if ( isInitialized() )
-        return true;
-
-    QOpenGLContext* context = QOpenGLContext::currentContext();
-
-    // If owned by a context object make sure it is current.
-    // Also check that current context is capable of resolving all needed functions
-    if (((owningContext() && owningContext() == context) || !owningContext())
-        && QOpenGLFunctions_3_2_Core::isContextCompatible(context))
-    {
-        // Associate with private implementation, creating if necessary
-        // Function pointers in the backends are resolved at creation time
-        QOpenGLVersionFunctionsBackend* d = nullptr;
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        d_1_3_Core = static_cast<QOpenGLFunctions_1_3_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        d_1_4_Core = static_cast<QOpenGLFunctions_1_4_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        d_1_5_Core = static_cast<QOpenGLFunctions_1_5_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        d_2_0_Core = static_cast<QOpenGLFunctions_2_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        d_2_1_Core = static_cast<QOpenGLFunctions_2_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        d_3_0_Core = static_cast<QOpenGLFunctions_3_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
-        d_3_1_Core = static_cast<QOpenGLFunctions_3_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
-        d_3_2_Core = static_cast<QOpenGLFunctions_3_2_CoreBackend*>(d);
-        d->refs.ref();
-
-        QAbstractOpenGLFunctions::initializeOpenGLFunctions();
-    }
-    return isInitialized();
-}
-
-bool QOpenGLFunctions_3_2_Core::isContextCompatible(QOpenGLContext *context)
-{
-    Q_ASSERT(context);
-    QSurfaceFormat f = context->format();
-    const QPair<int, int> v = qMakePair(f.majorVersion(), f.minorVersion());
-    if (v < qMakePair(3, 2))
-        return false;
-
-    return true;
-}
-
-QOpenGLVersionProfile QOpenGLFunctions_3_2_Core::versionProfile()
-{
-    QOpenGLVersionProfile v;
-    v.setVersion(3, 2);
-    v.setProfile(QSurfaceFormat::CoreProfile);
-    return v;
-}
-
-QT_END_NAMESPACE
diff --git a/src/gui/opengl/qopenglfunctions_3_2_core.h b/src/gui/opengl/qopenglfunctions_3_2_core.h
deleted file mode 100644
index 1eafb6f441..0000000000
--- a/src/gui/opengl/qopenglfunctions_3_2_core.h
+++ /dev/null
@@ -1,1720 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#ifndef QOPENGLVERSIONFUNCTIONS_3_2_CORE_H
-#define QOPENGLVERSIONFUNCTIONS_3_2_CORE_H
-
-#include <QtGui/qtguiglobal.h>
-
-#if !defined(QT_NO_OPENGL) && !defined(QT_OPENGL_ES_2)
-
-#include <QtGui/QOpenGLVersionFunctions>
-#include <QtGui/qopenglcontext.h>
-
-QT_BEGIN_NAMESPACE
-
-class Q_GUI_EXPORT QOpenGLFunctions_3_2_Core : public QAbstractOpenGLFunctions
-{
-public:
-    QOpenGLFunctions_3_2_Core();
-    ~QOpenGLFunctions_3_2_Core();
-
-    bool initializeOpenGLFunctions() override;
-
-    // OpenGL 1.0 core functions
-    void glViewport(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glDepthRange(GLdouble nearVal, GLdouble farVal);
-    GLboolean glIsEnabled(GLenum cap);
-    void glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params);
-    void glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params);
-    void glGetTexParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
-    const GLubyte * glGetString(GLenum name);
-    void glGetIntegerv(GLenum pname, GLint *params);
-    void glGetFloatv(GLenum pname, GLfloat *params);
-    GLenum glGetError();
-    void glGetDoublev(GLenum pname, GLdouble *params);
-    void glGetBooleanv(GLenum pname, GLboolean *params);
-    void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
-    void glReadBuffer(GLenum mode);
-    void glPixelStorei(GLenum pname, GLint param);
-    void glPixelStoref(GLenum pname, GLfloat param);
-    void glDepthFunc(GLenum func);
-    void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass);
-    void glStencilFunc(GLenum func, GLint ref, GLuint mask);
-    void glLogicOp(GLenum opcode);
-    void glBlendFunc(GLenum sfactor, GLenum dfactor);
-    void glFlush();
-    void glFinish();
-    void glEnable(GLenum cap);
-    void glDisable(GLenum cap);
-    void glDepthMask(GLboolean flag);
-    void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
-    void glStencilMask(GLuint mask);
-    void glClearDepth(GLdouble depth);
-    void glClearStencil(GLint s);
-    void glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glClear(GLbitfield mask);
-    void glDrawBuffer(GLenum mode);
-    void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glTexParameteri(GLenum target, GLenum pname, GLint param);
-    void glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glTexParameterf(GLenum target, GLenum pname, GLfloat param);
-    void glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glPolygonMode(GLenum face, GLenum mode);
-    void glPointSize(GLfloat size);
-    void glLineWidth(GLfloat width);
-    void glHint(GLenum target, GLenum mode);
-    void glFrontFace(GLenum mode);
-    void glCullFace(GLenum mode);
-
-    // OpenGL 1.1 core functions
-    void glIndexubv(const GLubyte *c);
-    void glIndexub(GLubyte c);
-    GLboolean glIsTexture(GLuint texture);
-    void glGenTextures(GLsizei n, GLuint *textures);
-    void glDeleteTextures(GLsizei n, const GLuint *textures);
-    void glBindTexture(GLenum target, GLuint texture);
-    void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
-    void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
-    void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
-    void glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
-    void glPolygonOffset(GLfloat factor, GLfloat units);
-    void glGetPointerv(GLenum pname, GLvoid* *params);
-    void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
-    void glDrawArrays(GLenum mode, GLint first, GLsizei count);
-
-    // OpenGL 1.2 core functions
-    void glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices);
-    void glBlendEquation(GLenum mode);
-    void glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-
-    // OpenGL 1.3 core functions
-    void glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img);
-    void glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glSampleCoverage(GLfloat value, GLboolean invert);
-    void glActiveTexture(GLenum texture);
-
-    // OpenGL 1.4 core functions
-    void glPointParameteriv(GLenum pname, const GLint *params);
-    void glPointParameteri(GLenum pname, GLint param);
-    void glPointParameterfv(GLenum pname, const GLfloat *params);
-    void glPointParameterf(GLenum pname, GLfloat param);
-    void glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount);
-    void glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount);
-    void glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
-
-    // OpenGL 1.5 core functions
-    void glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params);
-    void glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params);
-    GLboolean glUnmapBuffer(GLenum target);
-    GLvoid* glMapBuffer(GLenum target, GLenum access);
-    void glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data);
-    void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data);
-    void glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage);
-    GLboolean glIsBuffer(GLuint buffer);
-    void glGenBuffers(GLsizei n, GLuint *buffers);
-    void glDeleteBuffers(GLsizei n, const GLuint *buffers);
-    void glBindBuffer(GLenum target, GLuint buffer);
-    void glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params);
-    void glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params);
-    void glGetQueryiv(GLenum target, GLenum pname, GLint *params);
-    void glEndQuery(GLenum target);
-    void glBeginQuery(GLenum target, GLuint id);
-    GLboolean glIsQuery(GLuint id);
-    void glDeleteQueries(GLsizei n, const GLuint *ids);
-    void glGenQueries(GLsizei n, GLuint *ids);
-
-    // OpenGL 2.0 core functions
-    void glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer);
-    void glValidateProgram(GLuint program);
-    void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniform4iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform3iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform2iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform1iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform4fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform3fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform2fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform1fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
-    void glUniform3i(GLint location, GLint v0, GLint v1, GLint v2);
-    void glUniform2i(GLint location, GLint v0, GLint v1);
-    void glUniform1i(GLint location, GLint v0);
-    void glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
-    void glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
-    void glUniform2f(GLint location, GLfloat v0, GLfloat v1);
-    void glUniform1f(GLint location, GLfloat v0);
-    void glUseProgram(GLuint program);
-    void glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length);
-    void glLinkProgram(GLuint program);
-    GLboolean glIsShader(GLuint shader);
-    GLboolean glIsProgram(GLuint program);
-    void glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer);
-    void glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params);
-    void glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params);
-    void glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params);
-    void glGetUniformiv(GLuint program, GLint location, GLint *params);
-    void glGetUniformfv(GLuint program, GLint location, GLfloat *params);
-    GLint glGetUniformLocation(GLuint program, const GLchar *name);
-    void glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source);
-    void glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void glGetShaderiv(GLuint shader, GLenum pname, GLint *params);
-    void glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void glGetProgramiv(GLuint program, GLenum pname, GLint *params);
-    GLint glGetAttribLocation(GLuint program, const GLchar *name);
-    void glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj);
-    void glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
-    void glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
-    void glEnableVertexAttribArray(GLuint index);
-    void glDisableVertexAttribArray(GLuint index);
-    void glDetachShader(GLuint program, GLuint shader);
-    void glDeleteShader(GLuint shader);
-    void glDeleteProgram(GLuint program);
-    GLuint glCreateShader(GLenum type);
-    GLuint glCreateProgram();
-    void glCompileShader(GLuint shader);
-    void glBindAttribLocation(GLuint program, GLuint index, const GLchar *name);
-    void glAttachShader(GLuint program, GLuint shader);
-    void glStencilMaskSeparate(GLenum face, GLuint mask);
-    void glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask);
-    void glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);
-    void glDrawBuffers(GLsizei n, const GLenum *bufs);
-    void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha);
-
-    // OpenGL 2.1 core functions
-    void glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-
-    // OpenGL 3.0 core functions
-    GLboolean glIsVertexArray(GLuint array);
-    void glGenVertexArrays(GLsizei n, GLuint *arrays);
-    void glDeleteVertexArrays(GLsizei n, const GLuint *arrays);
-    void glBindVertexArray(GLuint array);
-    void glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length);
-    GLvoid* glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
-    void glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
-    void glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
-    void glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
-    void glGenerateMipmap(GLenum target);
-    void glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params);
-    void glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
-    void glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset);
-    void glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
-    void glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
-    GLenum glCheckFramebufferStatus(GLenum target);
-    void glGenFramebuffers(GLsizei n, GLuint *framebuffers);
-    void glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers);
-    void glBindFramebuffer(GLenum target, GLuint framebuffer);
-    GLboolean glIsFramebuffer(GLuint framebuffer);
-    void glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
-    void glGenRenderbuffers(GLsizei n, GLuint *renderbuffers);
-    void glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers);
-    void glBindRenderbuffer(GLenum target, GLuint renderbuffer);
-    GLboolean glIsRenderbuffer(GLuint renderbuffer);
-    const GLubyte * glGetStringi(GLenum name, GLuint index);
-    void glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
-    void glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value);
-    void glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value);
-    void glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value);
-    void glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params);
-    void glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params);
-    void glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params);
-    void glTexParameterIiv(GLenum target, GLenum pname, const GLint *params);
-    void glUniform4uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform3uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform2uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform1uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
-    void glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2);
-    void glUniform2ui(GLint location, GLuint v0, GLuint v1);
-    void glUniform1ui(GLint location, GLuint v0);
-    GLint glGetFragDataLocation(GLuint program, const GLchar *name);
-    void glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name);
-    void glGetUniformuiv(GLuint program, GLint location, GLuint *params);
-    void glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params);
-    void glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params);
-    void glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glEndConditionalRender();
-    void glBeginConditionalRender(GLuint id, GLenum mode);
-    void glClampColor(GLenum target, GLenum clamp);
-    void glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name);
-    void glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode);
-    void glBindBufferBase(GLenum target, GLuint index, GLuint buffer);
-    void glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
-    void glEndTransformFeedback();
-    void glBeginTransformFeedback(GLenum primitiveMode);
-    GLboolean glIsEnabledi(GLenum target, GLuint index);
-    void glDisablei(GLenum target, GLuint index);
-    void glEnablei(GLenum target, GLuint index);
-    void glGetIntegeri_v(GLenum target, GLuint index, GLint *data);
-    void glGetBooleani_v(GLenum target, GLuint index, GLboolean *data);
-    void glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a);
-
-    // OpenGL 3.1 core functions
-    void glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
-    void glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);
-    void glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName);
-    void glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params);
-    GLuint glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName);
-    void glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName);
-    void glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params);
-    void glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const *uniformNames, GLuint *uniformIndices);
-    void glPrimitiveRestartIndex(GLuint index);
-    void glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer);
-    void glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount);
-    void glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount);
-
-    // OpenGL 3.2 core functions
-    void glSampleMaski(GLuint index, GLbitfield mask);
-    void glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val);
-    void glTexImage3DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
-    void glTexImage2DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
-    void glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values);
-    void glGetInteger64v(GLenum pname, GLint64 *params);
-    void glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout);
-    GLenum glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout);
-    void glDeleteSync(GLsync sync);
-    GLboolean glIsSync(GLsync sync);
-    GLsync glFenceSync(GLenum condition, GLbitfield flags);
-    void glProvokingVertex(GLenum mode);
-    void glMultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount, const GLint *basevertex);
-    void glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount, GLint basevertex);
-    void glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex);
-    void glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex);
-    void glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level);
-    void glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params);
-    void glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data);
-
-private:
-    friend class QOpenGLContext;
-
-    static bool isContextCompatible(QOpenGLContext *context);
-    static QOpenGLVersionProfile versionProfile();
-
-    QOpenGLFunctions_1_0_CoreBackend* d_1_0_Core;
-    QOpenGLFunctions_1_1_CoreBackend* d_1_1_Core;
-    QOpenGLFunctions_1_2_CoreBackend* d_1_2_Core;
-    QOpenGLFunctions_1_3_CoreBackend* d_1_3_Core;
-    QOpenGLFunctions_1_4_CoreBackend* d_1_4_Core;
-    QOpenGLFunctions_1_5_CoreBackend* d_1_5_Core;
-    QOpenGLFunctions_2_0_CoreBackend* d_2_0_Core;
-    QOpenGLFunctions_2_1_CoreBackend* d_2_1_Core;
-    QOpenGLFunctions_3_0_CoreBackend* d_3_0_Core;
-    QOpenGLFunctions_3_1_CoreBackend* d_3_1_Core;
-    QOpenGLFunctions_3_2_CoreBackend* d_3_2_Core;
-};
-
-// OpenGL 1.0 core functions
-inline void QOpenGLFunctions_3_2_Core::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_0_Core->f.Viewport(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glDepthRange(GLdouble nearVal, GLdouble farVal)
-{
-    d_1_0_Core->f.DepthRange(nearVal, farVal);
-}
-
-inline GLboolean QOpenGLFunctions_3_2_Core::glIsEnabled(GLenum cap)
-{
-    return d_1_0_Core->f.IsEnabled(cap);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetTexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetTexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
-{
-    d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
-}
-
-inline const GLubyte * QOpenGLFunctions_3_2_Core::glGetString(GLenum name)
-{
-    return d_1_0_Core->f.GetString(name);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGetIntegerv(GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetIntegerv(pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGetFloatv(GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetFloatv(pname, params);
-}
-
-inline GLenum QOpenGLFunctions_3_2_Core::glGetError()
-{
-    return d_1_0_Core->f.GetError();
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGetDoublev(GLenum pname, GLdouble *params)
-{
-    d_1_0_Core->f.GetDoublev(pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGetBooleanv(GLenum pname, GLboolean *params)
-{
-    d_1_0_Core->f.GetBooleanv(pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
-{
-    d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glReadBuffer(GLenum mode)
-{
-    d_1_0_Core->f.ReadBuffer(mode);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glPixelStorei(GLenum pname, GLint param)
-{
-    d_1_0_Core->f.PixelStorei(pname, param);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glPixelStoref(GLenum pname, GLfloat param)
-{
-    d_1_0_Core->f.PixelStoref(pname, param);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glDepthFunc(GLenum func)
-{
-    d_1_0_Core->f.DepthFunc(func);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
-{
-    d_1_0_Core->f.StencilOp(fail, zfail, zpass);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glStencilFunc(GLenum func, GLint ref, GLuint mask)
-{
-    d_1_0_Core->f.StencilFunc(func, ref, mask);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glLogicOp(GLenum opcode)
-{
-    d_1_0_Core->f.LogicOp(opcode);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glBlendFunc(GLenum sfactor, GLenum dfactor)
-{
-    d_1_0_Core->f.BlendFunc(sfactor, dfactor);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glFlush()
-{
-    d_1_0_Core->f.Flush();
-}
-
-inline void QOpenGLFunctions_3_2_Core::glFinish()
-{
-    d_1_0_Core->f.Finish();
-}
-
-inline void QOpenGLFunctions_3_2_Core::glEnable(GLenum cap)
-{
-    d_1_0_Core->f.Enable(cap);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glDisable(GLenum cap)
-{
-    d_1_0_Core->f.Disable(cap);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glDepthMask(GLboolean flag)
-{
-    d_1_0_Core->f.DepthMask(flag);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
-{
-    d_1_0_Core->f.ColorMask(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glStencilMask(GLuint mask)
-{
-    d_1_0_Core->f.StencilMask(mask);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glClearDepth(GLdouble depth)
-{
-    d_1_0_Core->f.ClearDepth(depth);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glClearStencil(GLint s)
-{
-    d_1_0_Core->f.ClearStencil(s);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Core->f.ClearColor(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glClear(GLbitfield mask)
-{
-    d_1_0_Core->f.Clear(mask);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glDrawBuffer(GLenum mode)
-{
-    d_1_0_Core->f.DrawBuffer(mode);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Core->f.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Core->f.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_0_Core->f.TexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glTexParameteri(GLenum target, GLenum pname, GLint param)
-{
-    d_1_0_Core->f.TexParameteri(target, pname, param);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Core->f.TexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
-{
-    d_1_0_Core->f.TexParameterf(target, pname, param);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_0_Core->f.Scissor(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glPolygonMode(GLenum face, GLenum mode)
-{
-    d_1_0_Core->f.PolygonMode(face, mode);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glPointSize(GLfloat size)
-{
-    d_1_0_Core->f.PointSize(size);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glLineWidth(GLfloat width)
-{
-    d_1_0_Core->f.LineWidth(width);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glHint(GLenum target, GLenum mode)
-{
-    d_1_0_Core->f.Hint(target, mode);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glFrontFace(GLenum mode)
-{
-    d_1_0_Core->f.FrontFace(mode);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glCullFace(GLenum mode)
-{
-    d_1_0_Core->f.CullFace(mode);
-}
-
-
-// OpenGL 1.1 core functions
-inline void QOpenGLFunctions_3_2_Core::glIndexubv(const GLubyte *c)
-{
-    Q_UNUSED(c);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_3_2_Core::glIndexub(GLubyte c)
-{
-    Q_UNUSED(c);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline GLboolean QOpenGLFunctions_3_2_Core::glIsTexture(GLuint texture)
-{
-    return d_1_1_Core->f.IsTexture(texture);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGenTextures(GLsizei n, GLuint *textures)
-{
-    d_1_1_Core->f.GenTextures(n, textures);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glDeleteTextures(GLsizei n, const GLuint *textures)
-{
-    d_1_1_Core->f.DeleteTextures(n, textures);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glBindTexture(GLenum target, GLuint texture)
-{
-    d_1_1_Core->f.BindTexture(target, texture);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_1_Core->f.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_1_Core->f.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_1_Core->f.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
-{
-    d_1_1_Core->f.CopyTexSubImage1D(target, level, xoffset, x, y, width);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
-{
-    d_1_1_Core->f.CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
-{
-    d_1_1_Core->f.CopyTexImage1D(target, level, internalformat, x, y, width, border);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glPolygonOffset(GLfloat factor, GLfloat units)
-{
-    d_1_1_Core->f.PolygonOffset(factor, units);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGetPointerv(GLenum pname, GLvoid* *params)
-{
-    Q_UNUSED(pname);
-    Q_UNUSED(params);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_3_2_Core::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
-{
-    d_1_1_Core->f.DrawElements(mode, count, type, indices);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glDrawArrays(GLenum mode, GLint first, GLsizei count)
-{
-    d_1_1_Core->f.DrawArrays(mode, first, count);
-}
-
-
-// OpenGL 1.2 core functions
-inline void QOpenGLFunctions_3_2_Core::glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_2_Core->f.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_2_Core->f.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_2_Core->f.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
-{
-    d_1_2_Core->f.DrawRangeElements(mode, start, end, count, type, indices);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glBlendEquation(GLenum mode)
-{
-    d_1_2_Core->f.BlendEquation(mode);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_2_Core->f.BlendColor(red, green, blue, alpha);
-}
-
-
-// OpenGL 1.3 core functions
-inline void QOpenGLFunctions_3_2_Core::glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img)
-{
-    d_1_3_Core->f.GetCompressedTexImage(target, level, img);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glSampleCoverage(GLfloat value, GLboolean invert)
-{
-    d_1_3_Core->f.SampleCoverage(value, invert);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glActiveTexture(GLenum texture)
-{
-    d_1_3_Core->f.ActiveTexture(texture);
-}
-
-
-// OpenGL 1.4 core functions
-inline void QOpenGLFunctions_3_2_Core::glPointParameteriv(GLenum pname, const GLint *params)
-{
-    d_1_4_Core->f.PointParameteriv(pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glPointParameteri(GLenum pname, GLint param)
-{
-    d_1_4_Core->f.PointParameteri(pname, param);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glPointParameterfv(GLenum pname, const GLfloat *params)
-{
-    d_1_4_Core->f.PointParameterfv(pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glPointParameterf(GLenum pname, GLfloat param)
-{
-    d_1_4_Core->f.PointParameterf(pname, param);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount)
-{
-    d_1_4_Core->f.MultiDrawElements(mode, count, type, indices, drawcount);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
-{
-    d_1_4_Core->f.MultiDrawArrays(mode, first, count, drawcount);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
-{
-    d_1_4_Core->f.BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
-}
-
-
-// OpenGL 1.5 core functions
-inline void QOpenGLFunctions_3_2_Core::glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params)
-{
-    d_1_5_Core->f.GetBufferPointerv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetBufferParameteriv(target, pname, params);
-}
-
-inline GLboolean QOpenGLFunctions_3_2_Core::glUnmapBuffer(GLenum target)
-{
-    return d_1_5_Core->f.UnmapBuffer(target);
-}
-
-inline GLvoid* QOpenGLFunctions_3_2_Core::glMapBuffer(GLenum target, GLenum access)
-{
-    return d_1_5_Core->f.MapBuffer(target, access);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data)
-{
-    d_1_5_Core->f.GetBufferSubData(target, offset, size, data);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data)
-{
-    d_1_5_Core->f.BufferSubData(target, offset, size, data);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)
-{
-    d_1_5_Core->f.BufferData(target, size, data, usage);
-}
-
-inline GLboolean QOpenGLFunctions_3_2_Core::glIsBuffer(GLuint buffer)
-{
-    return d_1_5_Core->f.IsBuffer(buffer);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGenBuffers(GLsizei n, GLuint *buffers)
-{
-    d_1_5_Core->f.GenBuffers(n, buffers);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glDeleteBuffers(GLsizei n, const GLuint *buffers)
-{
-    d_1_5_Core->f.DeleteBuffers(n, buffers);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glBindBuffer(GLenum target, GLuint buffer)
-{
-    d_1_5_Core->f.BindBuffer(target, buffer);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
-{
-    d_1_5_Core->f.GetQueryObjectuiv(id, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetQueryObjectiv(id, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGetQueryiv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetQueryiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glEndQuery(GLenum target)
-{
-    d_1_5_Core->f.EndQuery(target);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glBeginQuery(GLenum target, GLuint id)
-{
-    d_1_5_Core->f.BeginQuery(target, id);
-}
-
-inline GLboolean QOpenGLFunctions_3_2_Core::glIsQuery(GLuint id)
-{
-    return d_1_5_Core->f.IsQuery(id);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glDeleteQueries(GLsizei n, const GLuint *ids)
-{
-    d_1_5_Core->f.DeleteQueries(n, ids);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGenQueries(GLsizei n, GLuint *ids)
-{
-    d_1_5_Core->f.GenQueries(n, ids);
-}
-
-
-// OpenGL 2.0 core functions
-inline void QOpenGLFunctions_3_2_Core::glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer)
-{
-    d_2_0_Core->f.VertexAttribPointer(index, size, type, normalized, stride, pointer);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glValidateProgram(GLuint program)
-{
-    d_2_0_Core->f.ValidateProgram(program);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix3fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glUniform4iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform4iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glUniform3iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform3iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glUniform2iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform2iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glUniform1iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform1iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glUniform4fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform4fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glUniform3fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform3fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glUniform2fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform2fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glUniform1fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform1fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
-{
-    d_2_0_Core->f.Uniform4i(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glUniform3i(GLint location, GLint v0, GLint v1, GLint v2)
-{
-    d_2_0_Core->f.Uniform3i(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glUniform2i(GLint location, GLint v0, GLint v1)
-{
-    d_2_0_Core->f.Uniform2i(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glUniform1i(GLint location, GLint v0)
-{
-    d_2_0_Core->f.Uniform1i(location, v0);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
-{
-    d_2_0_Core->f.Uniform4f(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
-{
-    d_2_0_Core->f.Uniform3f(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glUniform2f(GLint location, GLfloat v0, GLfloat v1)
-{
-    d_2_0_Core->f.Uniform2f(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glUniform1f(GLint location, GLfloat v0)
-{
-    d_2_0_Core->f.Uniform1f(location, v0);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glUseProgram(GLuint program)
-{
-    d_2_0_Core->f.UseProgram(program);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length)
-{
-    d_2_0_Core->f.ShaderSource(shader, count, string, length);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glLinkProgram(GLuint program)
-{
-    d_2_0_Core->f.LinkProgram(program);
-}
-
-inline GLboolean QOpenGLFunctions_3_2_Core::glIsShader(GLuint shader)
-{
-    return d_2_0_Core->f.IsShader(shader);
-}
-
-inline GLboolean QOpenGLFunctions_3_2_Core::glIsProgram(GLuint program)
-{
-    return d_2_0_Core->f.IsProgram(program);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer)
-{
-    d_2_0_Core->f.GetVertexAttribPointerv(index, pname, pointer);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetVertexAttribiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
-{
-    d_2_0_Core->f.GetVertexAttribfv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
-{
-    d_2_0_Core->f.GetVertexAttribdv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGetUniformiv(GLuint program, GLint location, GLint *params)
-{
-    d_2_0_Core->f.GetUniformiv(program, location, params);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGetUniformfv(GLuint program, GLint location, GLfloat *params)
-{
-    d_2_0_Core->f.GetUniformfv(program, location, params);
-}
-
-inline GLint QOpenGLFunctions_3_2_Core::glGetUniformLocation(GLuint program, const GLchar *name)
-{
-    return d_2_0_Core->f.GetUniformLocation(program, name);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
-{
-    d_2_0_Core->f.GetShaderSource(shader, bufSize, length, source);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-{
-    d_2_0_Core->f.GetShaderInfoLog(shader, bufSize, length, infoLog);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGetShaderiv(GLuint shader, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetShaderiv(shader, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-{
-    d_2_0_Core->f.GetProgramInfoLog(program, bufSize, length, infoLog);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGetProgramiv(GLuint program, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetProgramiv(program, pname, params);
-}
-
-inline GLint QOpenGLFunctions_3_2_Core::glGetAttribLocation(GLuint program, const GLchar *name)
-{
-    return d_2_0_Core->f.GetAttribLocation(program, name);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj)
-{
-    d_2_0_Core->f.GetAttachedShaders(program, maxCount, count, obj);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
-{
-    d_2_0_Core->f.GetActiveUniform(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
-{
-    d_2_0_Core->f.GetActiveAttrib(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glEnableVertexAttribArray(GLuint index)
-{
-    d_2_0_Core->f.EnableVertexAttribArray(index);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glDisableVertexAttribArray(GLuint index)
-{
-    d_2_0_Core->f.DisableVertexAttribArray(index);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glDetachShader(GLuint program, GLuint shader)
-{
-    d_2_0_Core->f.DetachShader(program, shader);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glDeleteShader(GLuint shader)
-{
-    d_2_0_Core->f.DeleteShader(shader);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glDeleteProgram(GLuint program)
-{
-    d_2_0_Core->f.DeleteProgram(program);
-}
-
-inline GLuint QOpenGLFunctions_3_2_Core::glCreateShader(GLenum type)
-{
-    return d_2_0_Core->f.CreateShader(type);
-}
-
-inline GLuint QOpenGLFunctions_3_2_Core::glCreateProgram()
-{
-    return d_2_0_Core->f.CreateProgram();
-}
-
-inline void QOpenGLFunctions_3_2_Core::glCompileShader(GLuint shader)
-{
-    d_2_0_Core->f.CompileShader(shader);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glBindAttribLocation(GLuint program, GLuint index, const GLchar *name)
-{
-    d_2_0_Core->f.BindAttribLocation(program, index, name);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glAttachShader(GLuint program, GLuint shader)
-{
-    d_2_0_Core->f.AttachShader(program, shader);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glStencilMaskSeparate(GLenum face, GLuint mask)
-{
-    d_2_0_Core->f.StencilMaskSeparate(face, mask);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
-{
-    d_2_0_Core->f.StencilFuncSeparate(face, func, ref, mask);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
-{
-    d_2_0_Core->f.StencilOpSeparate(face, sfail, dpfail, dppass);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glDrawBuffers(GLsizei n, const GLenum *bufs)
-{
-    d_2_0_Core->f.DrawBuffers(n, bufs);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
-{
-    d_2_0_Core->f.BlendEquationSeparate(modeRGB, modeAlpha);
-}
-
-
-// OpenGL 2.1 core functions
-inline void QOpenGLFunctions_3_2_Core::glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix4x3fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix3x4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix4x2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix2x4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix3x2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix2x3fv(location, count, transpose, value);
-}
-
-
-// OpenGL 3.0 core functions
-inline GLboolean QOpenGLFunctions_3_2_Core::glIsVertexArray(GLuint array)
-{
-    return d_3_0_Core->f.IsVertexArray(array);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGenVertexArrays(GLsizei n, GLuint *arrays)
-{
-    d_3_0_Core->f.GenVertexArrays(n, arrays);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glDeleteVertexArrays(GLsizei n, const GLuint *arrays)
-{
-    d_3_0_Core->f.DeleteVertexArrays(n, arrays);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glBindVertexArray(GLuint array)
-{
-    d_3_0_Core->f.BindVertexArray(array);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
-{
-    d_3_0_Core->f.FlushMappedBufferRange(target, offset, length);
-}
-
-inline GLvoid* QOpenGLFunctions_3_2_Core::glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
-{
-    return d_3_0_Core->f.MapBufferRange(target, offset, length, access);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
-{
-    d_3_0_Core->f.FramebufferTextureLayer(target, attachment, texture, level, layer);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    d_3_0_Core->f.RenderbufferStorageMultisample(target, samples, internalformat, width, height);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
-{
-    d_3_0_Core->f.BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGenerateMipmap(GLenum target)
-{
-    d_3_0_Core->f.GenerateMipmap(target);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
-{
-    d_3_0_Core->f.FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
-{
-    d_3_0_Core->f.FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
-{
-    d_3_0_Core->f.FramebufferTexture2D(target, attachment, textarget, texture, level);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
-{
-    d_3_0_Core->f.FramebufferTexture1D(target, attachment, textarget, texture, level);
-}
-
-inline GLenum QOpenGLFunctions_3_2_Core::glCheckFramebufferStatus(GLenum target)
-{
-    return d_3_0_Core->f.CheckFramebufferStatus(target);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGenFramebuffers(GLsizei n, GLuint *framebuffers)
-{
-    d_3_0_Core->f.GenFramebuffers(n, framebuffers);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
-{
-    d_3_0_Core->f.DeleteFramebuffers(n, framebuffers);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glBindFramebuffer(GLenum target, GLuint framebuffer)
-{
-    d_3_0_Core->f.BindFramebuffer(target, framebuffer);
-}
-
-inline GLboolean QOpenGLFunctions_3_2_Core::glIsFramebuffer(GLuint framebuffer)
-{
-    return d_3_0_Core->f.IsFramebuffer(framebuffer);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetRenderbufferParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    d_3_0_Core->f.RenderbufferStorage(target, internalformat, width, height);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGenRenderbuffers(GLsizei n, GLuint *renderbuffers)
-{
-    d_3_0_Core->f.GenRenderbuffers(n, renderbuffers);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
-{
-    d_3_0_Core->f.DeleteRenderbuffers(n, renderbuffers);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glBindRenderbuffer(GLenum target, GLuint renderbuffer)
-{
-    d_3_0_Core->f.BindRenderbuffer(target, renderbuffer);
-}
-
-inline GLboolean QOpenGLFunctions_3_2_Core::glIsRenderbuffer(GLuint renderbuffer)
-{
-    return d_3_0_Core->f.IsRenderbuffer(renderbuffer);
-}
-
-inline const GLubyte * QOpenGLFunctions_3_2_Core::glGetStringi(GLenum name, GLuint index)
-{
-    return d_3_0_Core->f.GetStringi(name, index);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
-{
-    d_3_0_Core->f.ClearBufferfi(buffer, drawbuffer, depth, stencil);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
-{
-    d_3_0_Core->f.ClearBufferfv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
-{
-    d_3_0_Core->f.ClearBufferuiv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
-{
-    d_3_0_Core->f.ClearBufferiv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params)
-{
-    d_3_0_Core->f.GetTexParameterIuiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetTexParameterIiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params)
-{
-    d_3_0_Core->f.TexParameterIuiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glTexParameterIiv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_3_0_Core->f.TexParameterIiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glUniform4uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform4uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glUniform3uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform3uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glUniform2uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform2uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glUniform1uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform1uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
-{
-    d_3_0_Core->f.Uniform4ui(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
-{
-    d_3_0_Core->f.Uniform3ui(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glUniform2ui(GLint location, GLuint v0, GLuint v1)
-{
-    d_3_0_Core->f.Uniform2ui(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glUniform1ui(GLint location, GLuint v0)
-{
-    d_3_0_Core->f.Uniform1ui(location, v0);
-}
-
-inline GLint QOpenGLFunctions_3_2_Core::glGetFragDataLocation(GLuint program, const GLchar *name)
-{
-    return d_3_0_Core->f.GetFragDataLocation(program, name);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name)
-{
-    d_3_0_Core->f.BindFragDataLocation(program, color, name);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGetUniformuiv(GLuint program, GLint location, GLuint *params)
-{
-    d_3_0_Core->f.GetUniformuiv(program, location, params);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
-{
-    d_3_0_Core->f.GetVertexAttribIuiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetVertexAttribIiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_3_0_Core->f.VertexAttribIPointer(index, size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glEndConditionalRender()
-{
-    d_3_0_Core->f.EndConditionalRender();
-}
-
-inline void QOpenGLFunctions_3_2_Core::glBeginConditionalRender(GLuint id, GLenum mode)
-{
-    d_3_0_Core->f.BeginConditionalRender(id, mode);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glClampColor(GLenum target, GLenum clamp)
-{
-    d_3_0_Core->f.ClampColor(target, clamp);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
-{
-    d_3_0_Core->f.GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode)
-{
-    d_3_0_Core->f.TransformFeedbackVaryings(program, count, varyings, bufferMode);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
-{
-    d_3_0_Core->f.BindBufferBase(target, index, buffer);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
-{
-    d_3_0_Core->f.BindBufferRange(target, index, buffer, offset, size);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glEndTransformFeedback()
-{
-    d_3_0_Core->f.EndTransformFeedback();
-}
-
-inline void QOpenGLFunctions_3_2_Core::glBeginTransformFeedback(GLenum primitiveMode)
-{
-    d_3_0_Core->f.BeginTransformFeedback(primitiveMode);
-}
-
-inline GLboolean QOpenGLFunctions_3_2_Core::glIsEnabledi(GLenum target, GLuint index)
-{
-    return d_3_0_Core->f.IsEnabledi(target, index);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glDisablei(GLenum target, GLuint index)
-{
-    d_3_0_Core->f.Disablei(target, index);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glEnablei(GLenum target, GLuint index)
-{
-    d_3_0_Core->f.Enablei(target, index);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGetIntegeri_v(GLenum target, GLuint index, GLint *data)
-{
-    d_3_0_Core->f.GetIntegeri_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGetBooleani_v(GLenum target, GLuint index, GLboolean *data)
-{
-    d_3_0_Core->f.GetBooleani_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
-{
-    d_3_0_Core->f.ColorMaski(index, r, g, b, a);
-}
-
-
-// OpenGL 3.1 core functions
-inline void QOpenGLFunctions_3_2_Core::glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
-{
-    d_3_1_Core->f.CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
-{
-    d_3_1_Core->f.UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
-{
-    d_3_1_Core->f.GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params)
-{
-    d_3_1_Core->f.GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
-}
-
-inline GLuint QOpenGLFunctions_3_2_Core::glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName)
-{
-    return d_3_1_Core->f.GetUniformBlockIndex(program, uniformBlockName);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName)
-{
-    d_3_1_Core->f.GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params)
-{
-    d_3_1_Core->f.GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const *uniformNames, GLuint *uniformIndices)
-{
-    d_3_1_Core->f.GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glPrimitiveRestartIndex(GLuint index)
-{
-    d_3_1_Core->f.PrimitiveRestartIndex(index);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer)
-{
-    d_3_1_Core->f.TexBuffer(target, internalformat, buffer);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount)
-{
-    d_3_1_Core->f.DrawElementsInstanced(mode, count, type, indices, instancecount);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount)
-{
-    d_3_1_Core->f.DrawArraysInstanced(mode, first, count, instancecount);
-}
-
-
-// OpenGL 3.2 core functions
-inline void QOpenGLFunctions_3_2_Core::glSampleMaski(GLuint index, GLbitfield mask)
-{
-    d_3_2_Core->f.SampleMaski(index, mask);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val)
-{
-    d_3_2_Core->f.GetMultisamplefv(pname, index, val);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glTexImage3DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
-{
-    d_3_2_Core->f.TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glTexImage2DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
-{
-    d_3_2_Core->f.TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values)
-{
-    d_3_2_Core->f.GetSynciv(sync, pname, bufSize, length, values);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGetInteger64v(GLenum pname, GLint64 *params)
-{
-    d_3_2_Core->f.GetInteger64v(pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
-{
-    d_3_2_Core->f.WaitSync(sync, flags, timeout);
-}
-
-inline GLenum QOpenGLFunctions_3_2_Core::glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
-{
-    return d_3_2_Core->f.ClientWaitSync(sync, flags, timeout);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glDeleteSync(GLsync sync)
-{
-    d_3_2_Core->f.DeleteSync(sync);
-}
-
-inline GLboolean QOpenGLFunctions_3_2_Core::glIsSync(GLsync sync)
-{
-    return d_3_2_Core->f.IsSync(sync);
-}
-
-inline GLsync QOpenGLFunctions_3_2_Core::glFenceSync(GLenum condition, GLbitfield flags)
-{
-    return d_3_2_Core->f.FenceSync(condition, flags);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glProvokingVertex(GLenum mode)
-{
-    d_3_2_Core->f.ProvokingVertex(mode);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glMultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount, const GLint *basevertex)
-{
-    d_3_2_Core->f.MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount, GLint basevertex)
-{
-    d_3_2_Core->f.DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)
-{
-    d_3_2_Core->f.DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)
-{
-    d_3_2_Core->f.DrawElementsBaseVertex(mode, count, type, indices, basevertex);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level)
-{
-    d_3_2_Core->f.FramebufferTexture(target, attachment, texture, level);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params)
-{
-    d_3_2_Core->f.GetBufferParameteri64v(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_2_Core::glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data)
-{
-    d_3_2_Core->f.GetInteger64i_v(target, index, data);
-}
-
-
-
-QT_END_NAMESPACE
-
-#endif // QT_NO_OPENGL && !QT_OPENGL_ES_2
-
-#endif
diff --git a/src/gui/opengl/qopenglfunctions_3_3_compatibility.cpp b/src/gui/opengl/qopenglfunctions_3_3_compatibility.cpp
deleted file mode 100644
index a26d7d99b1..0000000000
--- a/src/gui/opengl/qopenglfunctions_3_3_compatibility.cpp
+++ /dev/null
@@ -1,282 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#include "qopenglfunctions_3_3_compatibility.h"
-#include "qopenglcontext.h"
-
-QT_BEGIN_NAMESPACE
-
-/*!
-    \class QOpenGLFunctions_3_3_Compatibility
-    \inmodule QtGui
-    \since 5.1
-    \wrapper
-    \brief The QOpenGLFunctions_3_3_Compatibility class provides all functions for OpenGL 3.3 compatibility profile.
-
-    This class is a wrapper for functions from OpenGL 3.3 compatibility profile.
-    See reference pages on \l {http://www.opengl.org/sdk/docs/}{opengl.org}
-    for function documentation.
-
-    \sa QAbstractOpenGLFunctions
-*/
-
-QOpenGLFunctions_3_3_Compatibility::QOpenGLFunctions_3_3_Compatibility()
- : QAbstractOpenGLFunctions()
- , d_1_0_Core(nullptr)
- , d_1_1_Core(nullptr)
- , d_1_2_Core(nullptr)
- , d_1_3_Core(nullptr)
- , d_1_4_Core(nullptr)
- , d_1_5_Core(nullptr)
- , d_2_0_Core(nullptr)
- , d_2_1_Core(nullptr)
- , d_3_0_Core(nullptr)
- , d_3_1_Core(nullptr)
- , d_3_2_Core(nullptr)
- , d_3_3_Core(nullptr)
- , d_1_0_Deprecated(nullptr)
- , d_1_1_Deprecated(nullptr)
- , d_1_2_Deprecated(nullptr)
- , d_1_3_Deprecated(nullptr)
- , d_1_4_Deprecated(nullptr)
- , m_reserved_2_0_Deprecated(nullptr)
- , d_3_3_Deprecated(nullptr)
-{
-}
-
-QOpenGLFunctions_3_3_Compatibility::~QOpenGLFunctions_3_3_Compatibility()
-{
-    if (d_1_0_Core) {
-        d_1_0_Core->refs.deref();
-        Q_ASSERT(d_1_0_Core->refs.loadRelaxed());
-    }
-    if (d_1_1_Core) {
-        d_1_1_Core->refs.deref();
-        Q_ASSERT(d_1_1_Core->refs.loadRelaxed());
-    }
-    if (d_1_2_Core) {
-        d_1_2_Core->refs.deref();
-        Q_ASSERT(d_1_2_Core->refs.loadRelaxed());
-    }
-    if (d_1_3_Core) {
-        d_1_3_Core->refs.deref();
-        Q_ASSERT(d_1_3_Core->refs.loadRelaxed());
-    }
-    if (d_1_4_Core) {
-        d_1_4_Core->refs.deref();
-        Q_ASSERT(d_1_4_Core->refs.loadRelaxed());
-    }
-    if (d_1_5_Core) {
-        d_1_5_Core->refs.deref();
-        Q_ASSERT(d_1_5_Core->refs.loadRelaxed());
-    }
-    if (d_2_0_Core) {
-        d_2_0_Core->refs.deref();
-        Q_ASSERT(d_2_0_Core->refs.loadRelaxed());
-    }
-    if (d_2_1_Core) {
-        d_2_1_Core->refs.deref();
-        Q_ASSERT(d_2_1_Core->refs.loadRelaxed());
-    }
-    if (d_3_0_Core) {
-        d_3_0_Core->refs.deref();
-        Q_ASSERT(d_3_0_Core->refs.loadRelaxed());
-    }
-    if (d_3_1_Core) {
-        d_3_1_Core->refs.deref();
-        Q_ASSERT(d_3_1_Core->refs.loadRelaxed());
-    }
-    if (d_3_2_Core) {
-        d_3_2_Core->refs.deref();
-        Q_ASSERT(d_3_2_Core->refs.loadRelaxed());
-    }
-    if (d_3_3_Core) {
-        d_3_3_Core->refs.deref();
-        Q_ASSERT(d_3_3_Core->refs.loadRelaxed());
-    }
-    if (d_1_0_Deprecated) {
-        d_1_0_Deprecated->refs.deref();
-        Q_ASSERT(d_1_0_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_1_Deprecated) {
-        d_1_1_Deprecated->refs.deref();
-        Q_ASSERT(d_1_1_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_2_Deprecated) {
-        d_1_2_Deprecated->refs.deref();
-        Q_ASSERT(d_1_2_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_3_Deprecated) {
-        d_1_3_Deprecated->refs.deref();
-        Q_ASSERT(d_1_3_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_4_Deprecated) {
-        d_1_4_Deprecated->refs.deref();
-        Q_ASSERT(d_1_4_Deprecated->refs.loadRelaxed());
-    }
-    if (d_3_3_Deprecated) {
-        d_3_3_Deprecated->refs.deref();
-        Q_ASSERT(d_3_3_Deprecated->refs.loadRelaxed());
-    }
-}
-
-bool QOpenGLFunctions_3_3_Compatibility::initializeOpenGLFunctions()
-{
-    if ( isInitialized() )
-        return true;
-
-    QOpenGLContext* context = QOpenGLContext::currentContext();
-
-    // If owned by a context object make sure it is current.
-    // Also check that current context is capable of resolving all needed functions
-    if (((owningContext() && owningContext() == context) || !owningContext())
-        && QOpenGLFunctions_3_3_Compatibility::isContextCompatible(context))
-    {
-        // Associate with private implementation, creating if necessary
-        // Function pointers in the backends are resolved at creation time
-        QOpenGLVersionFunctionsBackend* d = nullptr;
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        d_1_3_Core = static_cast<QOpenGLFunctions_1_3_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        d_1_4_Core = static_cast<QOpenGLFunctions_1_4_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        d_1_5_Core = static_cast<QOpenGLFunctions_1_5_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        d_2_0_Core = static_cast<QOpenGLFunctions_2_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        d_2_1_Core = static_cast<QOpenGLFunctions_2_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        d_3_0_Core = static_cast<QOpenGLFunctions_3_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
-        d_3_1_Core = static_cast<QOpenGLFunctions_3_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
-        d_3_2_Core = static_cast<QOpenGLFunctions_3_2_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_CoreBackend::versionStatus());
-        d_3_3_Core = static_cast<QOpenGLFunctions_3_3_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
-        d_1_0_Deprecated = static_cast<QOpenGLFunctions_1_0_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
-        d_1_1_Deprecated = static_cast<QOpenGLFunctions_1_1_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus());
-        d_1_2_Deprecated = static_cast<QOpenGLFunctions_1_2_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus());
-        d_1_3_Deprecated = static_cast<QOpenGLFunctions_1_3_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
-        d_1_4_Deprecated = static_cast<QOpenGLFunctions_1_4_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_DeprecatedBackend::versionStatus());
-        d_3_3_Deprecated = static_cast<QOpenGLFunctions_3_3_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        QAbstractOpenGLFunctions::initializeOpenGLFunctions();
-    }
-    return isInitialized();
-}
-
-bool QOpenGLFunctions_3_3_Compatibility::isContextCompatible(QOpenGLContext *context)
-{
-    Q_ASSERT(context);
-    QSurfaceFormat f = context->format();
-    const QPair<int, int> v = qMakePair(f.majorVersion(), f.minorVersion());
-    if (v < qMakePair(3, 3))
-        return false;
-
-    if (f.profile() == QSurfaceFormat::CoreProfile)
-        return false;
-
-    return true;
-}
-
-QOpenGLVersionProfile QOpenGLFunctions_3_3_Compatibility::versionProfile()
-{
-    QOpenGLVersionProfile v;
-    v.setVersion(3, 3);
-    v.setProfile(QSurfaceFormat::CompatibilityProfile);
-    return v;
-}
-
-QT_END_NAMESPACE
diff --git a/src/gui/opengl/qopenglfunctions_3_3_compatibility.h b/src/gui/opengl/qopenglfunctions_3_3_compatibility.h
deleted file mode 100644
index 185dd5aab4..0000000000
--- a/src/gui/opengl/qopenglfunctions_3_3_compatibility.h
+++ /dev/null
@@ -1,4734 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#ifndef QOPENGLVERSIONFUNCTIONS_3_3_COMPATIBILITY_H
-#define QOPENGLVERSIONFUNCTIONS_3_3_COMPATIBILITY_H
-
-#include <QtGui/qtguiglobal.h>
-
-#if !defined(QT_NO_OPENGL) && !defined(QT_OPENGL_ES_2)
-
-#include <QtGui/QOpenGLVersionFunctions>
-#include <QtGui/qopenglcontext.h>
-
-QT_BEGIN_NAMESPACE
-
-class Q_GUI_EXPORT QOpenGLFunctions_3_3_Compatibility : public QAbstractOpenGLFunctions
-{
-public:
-    QOpenGLFunctions_3_3_Compatibility();
-    ~QOpenGLFunctions_3_3_Compatibility();
-
-    bool initializeOpenGLFunctions() override;
-
-    // OpenGL 1.0 core functions
-    void glViewport(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glDepthRange(GLdouble nearVal, GLdouble farVal);
-    GLboolean glIsEnabled(GLenum cap);
-    void glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params);
-    void glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params);
-    void glGetTexParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
-    const GLubyte * glGetString(GLenum name);
-    void glGetIntegerv(GLenum pname, GLint *params);
-    void glGetFloatv(GLenum pname, GLfloat *params);
-    GLenum glGetError();
-    void glGetDoublev(GLenum pname, GLdouble *params);
-    void glGetBooleanv(GLenum pname, GLboolean *params);
-    void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
-    void glReadBuffer(GLenum mode);
-    void glPixelStorei(GLenum pname, GLint param);
-    void glPixelStoref(GLenum pname, GLfloat param);
-    void glDepthFunc(GLenum func);
-    void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass);
-    void glStencilFunc(GLenum func, GLint ref, GLuint mask);
-    void glLogicOp(GLenum opcode);
-    void glBlendFunc(GLenum sfactor, GLenum dfactor);
-    void glFlush();
-    void glFinish();
-    void glEnable(GLenum cap);
-    void glDisable(GLenum cap);
-    void glDepthMask(GLboolean flag);
-    void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
-    void glStencilMask(GLuint mask);
-    void glClearDepth(GLdouble depth);
-    void glClearStencil(GLint s);
-    void glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glClear(GLbitfield mask);
-    void glDrawBuffer(GLenum mode);
-    void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glTexParameteri(GLenum target, GLenum pname, GLint param);
-    void glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glTexParameterf(GLenum target, GLenum pname, GLfloat param);
-    void glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glPolygonMode(GLenum face, GLenum mode);
-    void glPointSize(GLfloat size);
-    void glLineWidth(GLfloat width);
-    void glHint(GLenum target, GLenum mode);
-    void glFrontFace(GLenum mode);
-    void glCullFace(GLenum mode);
-
-    // OpenGL 1.1 core functions
-    void glIndexubv(const GLubyte *c);
-    void glIndexub(GLubyte c);
-    GLboolean glIsTexture(GLuint texture);
-    void glGenTextures(GLsizei n, GLuint *textures);
-    void glDeleteTextures(GLsizei n, const GLuint *textures);
-    void glBindTexture(GLenum target, GLuint texture);
-    void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
-    void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
-    void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
-    void glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
-    void glPolygonOffset(GLfloat factor, GLfloat units);
-    void glGetPointerv(GLenum pname, GLvoid* *params);
-    void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
-    void glDrawArrays(GLenum mode, GLint first, GLsizei count);
-
-    // OpenGL 1.2 core functions
-    void glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices);
-    void glBlendEquation(GLenum mode);
-    void glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-
-    // OpenGL 1.3 core functions
-    void glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img);
-    void glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glSampleCoverage(GLfloat value, GLboolean invert);
-    void glActiveTexture(GLenum texture);
-
-    // OpenGL 1.4 core functions
-    void glPointParameteriv(GLenum pname, const GLint *params);
-    void glPointParameteri(GLenum pname, GLint param);
-    void glPointParameterfv(GLenum pname, const GLfloat *params);
-    void glPointParameterf(GLenum pname, GLfloat param);
-    void glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount);
-    void glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount);
-    void glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
-
-    // OpenGL 1.5 core functions
-    void glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params);
-    void glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params);
-    GLboolean glUnmapBuffer(GLenum target);
-    GLvoid* glMapBuffer(GLenum target, GLenum access);
-    void glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data);
-    void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data);
-    void glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage);
-    GLboolean glIsBuffer(GLuint buffer);
-    void glGenBuffers(GLsizei n, GLuint *buffers);
-    void glDeleteBuffers(GLsizei n, const GLuint *buffers);
-    void glBindBuffer(GLenum target, GLuint buffer);
-    void glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params);
-    void glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params);
-    void glGetQueryiv(GLenum target, GLenum pname, GLint *params);
-    void glEndQuery(GLenum target);
-    void glBeginQuery(GLenum target, GLuint id);
-    GLboolean glIsQuery(GLuint id);
-    void glDeleteQueries(GLsizei n, const GLuint *ids);
-    void glGenQueries(GLsizei n, GLuint *ids);
-
-    // OpenGL 2.0 core functions
-    void glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer);
-    void glValidateProgram(GLuint program);
-    void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniform4iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform3iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform2iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform1iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform4fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform3fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform2fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform1fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
-    void glUniform3i(GLint location, GLint v0, GLint v1, GLint v2);
-    void glUniform2i(GLint location, GLint v0, GLint v1);
-    void glUniform1i(GLint location, GLint v0);
-    void glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
-    void glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
-    void glUniform2f(GLint location, GLfloat v0, GLfloat v1);
-    void glUniform1f(GLint location, GLfloat v0);
-    void glUseProgram(GLuint program);
-    void glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length);
-    void glLinkProgram(GLuint program);
-    GLboolean glIsShader(GLuint shader);
-    GLboolean glIsProgram(GLuint program);
-    void glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer);
-    void glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params);
-    void glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params);
-    void glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params);
-    void glGetUniformiv(GLuint program, GLint location, GLint *params);
-    void glGetUniformfv(GLuint program, GLint location, GLfloat *params);
-    GLint glGetUniformLocation(GLuint program, const GLchar *name);
-    void glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source);
-    void glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void glGetShaderiv(GLuint shader, GLenum pname, GLint *params);
-    void glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void glGetProgramiv(GLuint program, GLenum pname, GLint *params);
-    GLint glGetAttribLocation(GLuint program, const GLchar *name);
-    void glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj);
-    void glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
-    void glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
-    void glEnableVertexAttribArray(GLuint index);
-    void glDisableVertexAttribArray(GLuint index);
-    void glDetachShader(GLuint program, GLuint shader);
-    void glDeleteShader(GLuint shader);
-    void glDeleteProgram(GLuint program);
-    GLuint glCreateShader(GLenum type);
-    GLuint glCreateProgram();
-    void glCompileShader(GLuint shader);
-    void glBindAttribLocation(GLuint program, GLuint index, const GLchar *name);
-    void glAttachShader(GLuint program, GLuint shader);
-    void glStencilMaskSeparate(GLenum face, GLuint mask);
-    void glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask);
-    void glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);
-    void glDrawBuffers(GLsizei n, const GLenum *bufs);
-    void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha);
-
-    // OpenGL 2.1 core functions
-    void glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-
-    // OpenGL 3.0 core functions
-    GLboolean glIsVertexArray(GLuint array);
-    void glGenVertexArrays(GLsizei n, GLuint *arrays);
-    void glDeleteVertexArrays(GLsizei n, const GLuint *arrays);
-    void glBindVertexArray(GLuint array);
-    void glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length);
-    GLvoid* glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
-    void glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
-    void glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
-    void glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
-    void glGenerateMipmap(GLenum target);
-    void glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params);
-    void glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
-    void glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset);
-    void glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
-    void glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
-    GLenum glCheckFramebufferStatus(GLenum target);
-    void glGenFramebuffers(GLsizei n, GLuint *framebuffers);
-    void glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers);
-    void glBindFramebuffer(GLenum target, GLuint framebuffer);
-    GLboolean glIsFramebuffer(GLuint framebuffer);
-    void glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
-    void glGenRenderbuffers(GLsizei n, GLuint *renderbuffers);
-    void glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers);
-    void glBindRenderbuffer(GLenum target, GLuint renderbuffer);
-    GLboolean glIsRenderbuffer(GLuint renderbuffer);
-    const GLubyte * glGetStringi(GLenum name, GLuint index);
-    void glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
-    void glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value);
-    void glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value);
-    void glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value);
-    void glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params);
-    void glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params);
-    void glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params);
-    void glTexParameterIiv(GLenum target, GLenum pname, const GLint *params);
-    void glUniform4uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform3uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform2uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform1uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
-    void glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2);
-    void glUniform2ui(GLint location, GLuint v0, GLuint v1);
-    void glUniform1ui(GLint location, GLuint v0);
-    GLint glGetFragDataLocation(GLuint program, const GLchar *name);
-    void glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name);
-    void glGetUniformuiv(GLuint program, GLint location, GLuint *params);
-    void glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params);
-    void glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params);
-    void glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glEndConditionalRender();
-    void glBeginConditionalRender(GLuint id, GLenum mode);
-    void glClampColor(GLenum target, GLenum clamp);
-    void glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name);
-    void glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode);
-    void glBindBufferBase(GLenum target, GLuint index, GLuint buffer);
-    void glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
-    void glEndTransformFeedback();
-    void glBeginTransformFeedback(GLenum primitiveMode);
-    GLboolean glIsEnabledi(GLenum target, GLuint index);
-    void glDisablei(GLenum target, GLuint index);
-    void glEnablei(GLenum target, GLuint index);
-    void glGetIntegeri_v(GLenum target, GLuint index, GLint *data);
-    void glGetBooleani_v(GLenum target, GLuint index, GLboolean *data);
-    void glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a);
-
-    // OpenGL 3.1 core functions
-    void glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
-    void glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);
-    void glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName);
-    void glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params);
-    GLuint glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName);
-    void glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName);
-    void glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params);
-    void glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const *uniformNames, GLuint *uniformIndices);
-    void glPrimitiveRestartIndex(GLuint index);
-    void glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer);
-    void glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount);
-    void glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount);
-
-    // OpenGL 3.2 core functions
-    void glSampleMaski(GLuint index, GLbitfield mask);
-    void glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val);
-    void glTexImage3DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
-    void glTexImage2DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
-    void glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values);
-    void glGetInteger64v(GLenum pname, GLint64 *params);
-    void glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout);
-    GLenum glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout);
-    void glDeleteSync(GLsync sync);
-    GLboolean glIsSync(GLsync sync);
-    GLsync glFenceSync(GLenum condition, GLbitfield flags);
-    void glProvokingVertex(GLenum mode);
-    void glMultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount, const GLint *basevertex);
-    void glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount, GLint basevertex);
-    void glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex);
-    void glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex);
-    void glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level);
-    void glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params);
-    void glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data);
-
-    // OpenGL 3.3 core functions
-    void glVertexAttribP4uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glVertexAttribP3uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glVertexAttribP2uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glVertexAttribP1uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glSecondaryColorP3uiv(GLenum type, const GLuint *color);
-    void glSecondaryColorP3ui(GLenum type, GLuint color);
-    void glColorP4uiv(GLenum type, const GLuint *color);
-    void glColorP4ui(GLenum type, GLuint color);
-    void glColorP3uiv(GLenum type, const GLuint *color);
-    void glColorP3ui(GLenum type, GLuint color);
-    void glNormalP3uiv(GLenum type, const GLuint *coords);
-    void glNormalP3ui(GLenum type, GLuint coords);
-    void glMultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint *coords);
-    void glMultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords);
-    void glMultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint *coords);
-    void glMultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords);
-    void glMultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint *coords);
-    void glMultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords);
-    void glMultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint *coords);
-    void glMultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords);
-    void glTexCoordP4uiv(GLenum type, const GLuint *coords);
-    void glTexCoordP4ui(GLenum type, GLuint coords);
-    void glTexCoordP3uiv(GLenum type, const GLuint *coords);
-    void glTexCoordP3ui(GLenum type, GLuint coords);
-    void glTexCoordP2uiv(GLenum type, const GLuint *coords);
-    void glTexCoordP2ui(GLenum type, GLuint coords);
-    void glTexCoordP1uiv(GLenum type, const GLuint *coords);
-    void glTexCoordP1ui(GLenum type, GLuint coords);
-    void glVertexP4uiv(GLenum type, const GLuint *value);
-    void glVertexP4ui(GLenum type, GLuint value);
-    void glVertexP3uiv(GLenum type, const GLuint *value);
-    void glVertexP3ui(GLenum type, GLuint value);
-    void glVertexP2uiv(GLenum type, const GLuint *value);
-    void glVertexP2ui(GLenum type, GLuint value);
-    void glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params);
-    void glGetQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params);
-    void glQueryCounter(GLuint id, GLenum target);
-    void glGetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params);
-    void glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params);
-    void glGetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params);
-    void glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params);
-    void glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param);
-    void glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param);
-    void glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param);
-    void glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param);
-    void glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param);
-    void glSamplerParameteri(GLuint sampler, GLenum pname, GLint param);
-    void glBindSampler(GLuint unit, GLuint sampler);
-    GLboolean glIsSampler(GLuint sampler);
-    void glDeleteSamplers(GLsizei count, const GLuint *samplers);
-    void glGenSamplers(GLsizei count, GLuint *samplers);
-    GLint glGetFragDataIndex(GLuint program, const GLchar *name);
-    void glBindFragDataLocationIndexed(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name);
-    void glVertexAttribDivisor(GLuint index, GLuint divisor);
-
-    // OpenGL 1.0 deprecated functions
-    void glTranslatef(GLfloat x, GLfloat y, GLfloat z);
-    void glTranslated(GLdouble x, GLdouble y, GLdouble z);
-    void glScalef(GLfloat x, GLfloat y, GLfloat z);
-    void glScaled(GLdouble x, GLdouble y, GLdouble z);
-    void glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
-    void glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
-    void glPushMatrix();
-    void glPopMatrix();
-    void glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
-    void glMultMatrixd(const GLdouble *m);
-    void glMultMatrixf(const GLfloat *m);
-    void glMatrixMode(GLenum mode);
-    void glLoadMatrixd(const GLdouble *m);
-    void glLoadMatrixf(const GLfloat *m);
-    void glLoadIdentity();
-    void glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
-    GLboolean glIsList(GLuint list);
-    void glGetTexGeniv(GLenum coord, GLenum pname, GLint *params);
-    void glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params);
-    void glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params);
-    void glGetTexEnviv(GLenum target, GLenum pname, GLint *params);
-    void glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetPolygonStipple(GLubyte *mask);
-    void glGetPixelMapusv(GLenum map, GLushort *values);
-    void glGetPixelMapuiv(GLenum map, GLuint *values);
-    void glGetPixelMapfv(GLenum map, GLfloat *values);
-    void glGetMaterialiv(GLenum face, GLenum pname, GLint *params);
-    void glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params);
-    void glGetMapiv(GLenum target, GLenum query, GLint *v);
-    void glGetMapfv(GLenum target, GLenum query, GLfloat *v);
-    void glGetMapdv(GLenum target, GLenum query, GLdouble *v);
-    void glGetLightiv(GLenum light, GLenum pname, GLint *params);
-    void glGetLightfv(GLenum light, GLenum pname, GLfloat *params);
-    void glGetClipPlane(GLenum plane, GLdouble *equation);
-    void glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
-    void glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
-    void glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values);
-    void glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values);
-    void glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values);
-    void glPixelTransferi(GLenum pname, GLint param);
-    void glPixelTransferf(GLenum pname, GLfloat param);
-    void glPixelZoom(GLfloat xfactor, GLfloat yfactor);
-    void glAlphaFunc(GLenum func, GLfloat ref);
-    void glEvalPoint2(GLint i, GLint j);
-    void glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
-    void glEvalPoint1(GLint i);
-    void glEvalMesh1(GLenum mode, GLint i1, GLint i2);
-    void glEvalCoord2fv(const GLfloat *u);
-    void glEvalCoord2f(GLfloat u, GLfloat v);
-    void glEvalCoord2dv(const GLdouble *u);
-    void glEvalCoord2d(GLdouble u, GLdouble v);
-    void glEvalCoord1fv(const GLfloat *u);
-    void glEvalCoord1f(GLfloat u);
-    void glEvalCoord1dv(const GLdouble *u);
-    void glEvalCoord1d(GLdouble u);
-    void glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
-    void glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
-    void glMapGrid1f(GLint un, GLfloat u1, GLfloat u2);
-    void glMapGrid1d(GLint un, GLdouble u1, GLdouble u2);
-    void glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);
-    void glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);
-    void glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);
-    void glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);
-    void glPushAttrib(GLbitfield mask);
-    void glPopAttrib();
-    void glAccum(GLenum op, GLfloat value);
-    void glIndexMask(GLuint mask);
-    void glClearIndex(GLfloat c);
-    void glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glPushName(GLuint name);
-    void glPopName();
-    void glPassThrough(GLfloat token);
-    void glLoadName(GLuint name);
-    void glInitNames();
-    GLint glRenderMode(GLenum mode);
-    void glSelectBuffer(GLsizei size, GLuint *buffer);
-    void glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer);
-    void glTexGeniv(GLenum coord, GLenum pname, const GLint *params);
-    void glTexGeni(GLenum coord, GLenum pname, GLint param);
-    void glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params);
-    void glTexGenf(GLenum coord, GLenum pname, GLfloat param);
-    void glTexGendv(GLenum coord, GLenum pname, const GLdouble *params);
-    void glTexGend(GLenum coord, GLenum pname, GLdouble param);
-    void glTexEnviv(GLenum target, GLenum pname, const GLint *params);
-    void glTexEnvi(GLenum target, GLenum pname, GLint param);
-    void glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glTexEnvf(GLenum target, GLenum pname, GLfloat param);
-    void glShadeModel(GLenum mode);
-    void glPolygonStipple(const GLubyte *mask);
-    void glMaterialiv(GLenum face, GLenum pname, const GLint *params);
-    void glMateriali(GLenum face, GLenum pname, GLint param);
-    void glMaterialfv(GLenum face, GLenum pname, const GLfloat *params);
-    void glMaterialf(GLenum face, GLenum pname, GLfloat param);
-    void glLineStipple(GLint factor, GLushort pattern);
-    void glLightModeliv(GLenum pname, const GLint *params);
-    void glLightModeli(GLenum pname, GLint param);
-    void glLightModelfv(GLenum pname, const GLfloat *params);
-    void glLightModelf(GLenum pname, GLfloat param);
-    void glLightiv(GLenum light, GLenum pname, const GLint *params);
-    void glLighti(GLenum light, GLenum pname, GLint param);
-    void glLightfv(GLenum light, GLenum pname, const GLfloat *params);
-    void glLightf(GLenum light, GLenum pname, GLfloat param);
-    void glFogiv(GLenum pname, const GLint *params);
-    void glFogi(GLenum pname, GLint param);
-    void glFogfv(GLenum pname, const GLfloat *params);
-    void glFogf(GLenum pname, GLfloat param);
-    void glColorMaterial(GLenum face, GLenum mode);
-    void glClipPlane(GLenum plane, const GLdouble *equation);
-    void glVertex4sv(const GLshort *v);
-    void glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w);
-    void glVertex4iv(const GLint *v);
-    void glVertex4i(GLint x, GLint y, GLint z, GLint w);
-    void glVertex4fv(const GLfloat *v);
-    void glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void glVertex4dv(const GLdouble *v);
-    void glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glVertex3sv(const GLshort *v);
-    void glVertex3s(GLshort x, GLshort y, GLshort z);
-    void glVertex3iv(const GLint *v);
-    void glVertex3i(GLint x, GLint y, GLint z);
-    void glVertex3fv(const GLfloat *v);
-    void glVertex3f(GLfloat x, GLfloat y, GLfloat z);
-    void glVertex3dv(const GLdouble *v);
-    void glVertex3d(GLdouble x, GLdouble y, GLdouble z);
-    void glVertex2sv(const GLshort *v);
-    void glVertex2s(GLshort x, GLshort y);
-    void glVertex2iv(const GLint *v);
-    void glVertex2i(GLint x, GLint y);
-    void glVertex2fv(const GLfloat *v);
-    void glVertex2f(GLfloat x, GLfloat y);
-    void glVertex2dv(const GLdouble *v);
-    void glVertex2d(GLdouble x, GLdouble y);
-    void glTexCoord4sv(const GLshort *v);
-    void glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q);
-    void glTexCoord4iv(const GLint *v);
-    void glTexCoord4i(GLint s, GLint t, GLint r, GLint q);
-    void glTexCoord4fv(const GLfloat *v);
-    void glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
-    void glTexCoord4dv(const GLdouble *v);
-    void glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q);
-    void glTexCoord3sv(const GLshort *v);
-    void glTexCoord3s(GLshort s, GLshort t, GLshort r);
-    void glTexCoord3iv(const GLint *v);
-    void glTexCoord3i(GLint s, GLint t, GLint r);
-    void glTexCoord3fv(const GLfloat *v);
-    void glTexCoord3f(GLfloat s, GLfloat t, GLfloat r);
-    void glTexCoord3dv(const GLdouble *v);
-    void glTexCoord3d(GLdouble s, GLdouble t, GLdouble r);
-    void glTexCoord2sv(const GLshort *v);
-    void glTexCoord2s(GLshort s, GLshort t);
-    void glTexCoord2iv(const GLint *v);
-    void glTexCoord2i(GLint s, GLint t);
-    void glTexCoord2fv(const GLfloat *v);
-    void glTexCoord2f(GLfloat s, GLfloat t);
-    void glTexCoord2dv(const GLdouble *v);
-    void glTexCoord2d(GLdouble s, GLdouble t);
-    void glTexCoord1sv(const GLshort *v);
-    void glTexCoord1s(GLshort s);
-    void glTexCoord1iv(const GLint *v);
-    void glTexCoord1i(GLint s);
-    void glTexCoord1fv(const GLfloat *v);
-    void glTexCoord1f(GLfloat s);
-    void glTexCoord1dv(const GLdouble *v);
-    void glTexCoord1d(GLdouble s);
-    void glRectsv(const GLshort *v1, const GLshort *v2);
-    void glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
-    void glRectiv(const GLint *v1, const GLint *v2);
-    void glRecti(GLint x1, GLint y1, GLint x2, GLint y2);
-    void glRectfv(const GLfloat *v1, const GLfloat *v2);
-    void glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
-    void glRectdv(const GLdouble *v1, const GLdouble *v2);
-    void glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
-    void glRasterPos4sv(const GLshort *v);
-    void glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w);
-    void glRasterPos4iv(const GLint *v);
-    void glRasterPos4i(GLint x, GLint y, GLint z, GLint w);
-    void glRasterPos4fv(const GLfloat *v);
-    void glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void glRasterPos4dv(const GLdouble *v);
-    void glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glRasterPos3sv(const GLshort *v);
-    void glRasterPos3s(GLshort x, GLshort y, GLshort z);
-    void glRasterPos3iv(const GLint *v);
-    void glRasterPos3i(GLint x, GLint y, GLint z);
-    void glRasterPos3fv(const GLfloat *v);
-    void glRasterPos3f(GLfloat x, GLfloat y, GLfloat z);
-    void glRasterPos3dv(const GLdouble *v);
-    void glRasterPos3d(GLdouble x, GLdouble y, GLdouble z);
-    void glRasterPos2sv(const GLshort *v);
-    void glRasterPos2s(GLshort x, GLshort y);
-    void glRasterPos2iv(const GLint *v);
-    void glRasterPos2i(GLint x, GLint y);
-    void glRasterPos2fv(const GLfloat *v);
-    void glRasterPos2f(GLfloat x, GLfloat y);
-    void glRasterPos2dv(const GLdouble *v);
-    void glRasterPos2d(GLdouble x, GLdouble y);
-    void glNormal3sv(const GLshort *v);
-    void glNormal3s(GLshort nx, GLshort ny, GLshort nz);
-    void glNormal3iv(const GLint *v);
-    void glNormal3i(GLint nx, GLint ny, GLint nz);
-    void glNormal3fv(const GLfloat *v);
-    void glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz);
-    void glNormal3dv(const GLdouble *v);
-    void glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz);
-    void glNormal3bv(const GLbyte *v);
-    void glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz);
-    void glIndexsv(const GLshort *c);
-    void glIndexs(GLshort c);
-    void glIndexiv(const GLint *c);
-    void glIndexi(GLint c);
-    void glIndexfv(const GLfloat *c);
-    void glIndexf(GLfloat c);
-    void glIndexdv(const GLdouble *c);
-    void glIndexd(GLdouble c);
-    void glEnd();
-    void glEdgeFlagv(const GLboolean *flag);
-    void glEdgeFlag(GLboolean flag);
-    void glColor4usv(const GLushort *v);
-    void glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha);
-    void glColor4uiv(const GLuint *v);
-    void glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha);
-    void glColor4ubv(const GLubyte *v);
-    void glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
-    void glColor4sv(const GLshort *v);
-    void glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha);
-    void glColor4iv(const GLint *v);
-    void glColor4i(GLint red, GLint green, GLint blue, GLint alpha);
-    void glColor4fv(const GLfloat *v);
-    void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glColor4dv(const GLdouble *v);
-    void glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
-    void glColor4bv(const GLbyte *v);
-    void glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
-    void glColor3usv(const GLushort *v);
-    void glColor3us(GLushort red, GLushort green, GLushort blue);
-    void glColor3uiv(const GLuint *v);
-    void glColor3ui(GLuint red, GLuint green, GLuint blue);
-    void glColor3ubv(const GLubyte *v);
-    void glColor3ub(GLubyte red, GLubyte green, GLubyte blue);
-    void glColor3sv(const GLshort *v);
-    void glColor3s(GLshort red, GLshort green, GLshort blue);
-    void glColor3iv(const GLint *v);
-    void glColor3i(GLint red, GLint green, GLint blue);
-    void glColor3fv(const GLfloat *v);
-    void glColor3f(GLfloat red, GLfloat green, GLfloat blue);
-    void glColor3dv(const GLdouble *v);
-    void glColor3d(GLdouble red, GLdouble green, GLdouble blue);
-    void glColor3bv(const GLbyte *v);
-    void glColor3b(GLbyte red, GLbyte green, GLbyte blue);
-    void glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap);
-    void glBegin(GLenum mode);
-    void glListBase(GLuint base);
-    GLuint glGenLists(GLsizei range);
-    void glDeleteLists(GLuint list, GLsizei range);
-    void glCallLists(GLsizei n, GLenum type, const GLvoid *lists);
-    void glCallList(GLuint list);
-    void glEndList();
-    void glNewList(GLuint list, GLenum mode);
-
-    // OpenGL 1.1 deprecated functions
-    void glPushClientAttrib(GLbitfield mask);
-    void glPopClientAttrib();
-    void glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities);
-    GLboolean glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences);
-    void glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer);
-    void glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glEnableClientState(GLenum array);
-    void glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer);
-    void glDisableClientState(GLenum array);
-    void glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glArrayElement(GLint i);
-
-    // OpenGL 1.2 deprecated functions
-    void glResetMinmax(GLenum target);
-    void glResetHistogram(GLenum target);
-    void glMinmax(GLenum target, GLenum internalformat, GLboolean sink);
-    void glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink);
-    void glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
-    void glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
-    void glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column);
-    void glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span);
-    void glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image);
-    void glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
-    void glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glConvolutionParameteri(GLenum target, GLenum pname, GLint params);
-    void glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params);
-    void glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image);
-    void glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image);
-    void glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width);
-    void glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data);
-    void glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table);
-    void glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
-    void glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table);
-
-    // OpenGL 1.3 deprecated functions
-    void glMultTransposeMatrixd(const GLdouble *m);
-    void glMultTransposeMatrixf(const GLfloat *m);
-    void glLoadTransposeMatrixd(const GLdouble *m);
-    void glLoadTransposeMatrixf(const GLfloat *m);
-    void glMultiTexCoord4sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);
-    void glMultiTexCoord4iv(GLenum target, const GLint *v);
-    void glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q);
-    void glMultiTexCoord4fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
-    void glMultiTexCoord4dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
-    void glMultiTexCoord3sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r);
-    void glMultiTexCoord3iv(GLenum target, const GLint *v);
-    void glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r);
-    void glMultiTexCoord3fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r);
-    void glMultiTexCoord3dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r);
-    void glMultiTexCoord2sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord2s(GLenum target, GLshort s, GLshort t);
-    void glMultiTexCoord2iv(GLenum target, const GLint *v);
-    void glMultiTexCoord2i(GLenum target, GLint s, GLint t);
-    void glMultiTexCoord2fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t);
-    void glMultiTexCoord2dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t);
-    void glMultiTexCoord1sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord1s(GLenum target, GLshort s);
-    void glMultiTexCoord1iv(GLenum target, const GLint *v);
-    void glMultiTexCoord1i(GLenum target, GLint s);
-    void glMultiTexCoord1fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord1f(GLenum target, GLfloat s);
-    void glMultiTexCoord1dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord1d(GLenum target, GLdouble s);
-    void glClientActiveTexture(GLenum texture);
-
-    // OpenGL 1.4 deprecated functions
-    void glWindowPos3sv(const GLshort *v);
-    void glWindowPos3s(GLshort x, GLshort y, GLshort z);
-    void glWindowPos3iv(const GLint *v);
-    void glWindowPos3i(GLint x, GLint y, GLint z);
-    void glWindowPos3fv(const GLfloat *v);
-    void glWindowPos3f(GLfloat x, GLfloat y, GLfloat z);
-    void glWindowPos3dv(const GLdouble *v);
-    void glWindowPos3d(GLdouble x, GLdouble y, GLdouble z);
-    void glWindowPos2sv(const GLshort *v);
-    void glWindowPos2s(GLshort x, GLshort y);
-    void glWindowPos2iv(const GLint *v);
-    void glWindowPos2i(GLint x, GLint y);
-    void glWindowPos2fv(const GLfloat *v);
-    void glWindowPos2f(GLfloat x, GLfloat y);
-    void glWindowPos2dv(const GLdouble *v);
-    void glWindowPos2d(GLdouble x, GLdouble y);
-    void glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glSecondaryColor3usv(const GLushort *v);
-    void glSecondaryColor3us(GLushort red, GLushort green, GLushort blue);
-    void glSecondaryColor3uiv(const GLuint *v);
-    void glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue);
-    void glSecondaryColor3ubv(const GLubyte *v);
-    void glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue);
-    void glSecondaryColor3sv(const GLshort *v);
-    void glSecondaryColor3s(GLshort red, GLshort green, GLshort blue);
-    void glSecondaryColor3iv(const GLint *v);
-    void glSecondaryColor3i(GLint red, GLint green, GLint blue);
-    void glSecondaryColor3fv(const GLfloat *v);
-    void glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue);
-    void glSecondaryColor3dv(const GLdouble *v);
-    void glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue);
-    void glSecondaryColor3bv(const GLbyte *v);
-    void glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue);
-    void glFogCoordPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glFogCoorddv(const GLdouble *coord);
-    void glFogCoordd(GLdouble coord);
-    void glFogCoordfv(const GLfloat *coord);
-    void glFogCoordf(GLfloat coord);
-
-    // OpenGL 1.5 deprecated functions
-
-    // OpenGL 2.0 deprecated functions
-    void glVertexAttrib4usv(GLuint index, const GLushort *v);
-    void glVertexAttrib4uiv(GLuint index, const GLuint *v);
-    void glVertexAttrib4ubv(GLuint index, const GLubyte *v);
-    void glVertexAttrib4sv(GLuint index, const GLshort *v);
-    void glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
-    void glVertexAttrib4iv(GLuint index, const GLint *v);
-    void glVertexAttrib4fv(GLuint index, const GLfloat *v);
-    void glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void glVertexAttrib4dv(GLuint index, const GLdouble *v);
-    void glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glVertexAttrib4bv(GLuint index, const GLbyte *v);
-    void glVertexAttrib4Nusv(GLuint index, const GLushort *v);
-    void glVertexAttrib4Nuiv(GLuint index, const GLuint *v);
-    void glVertexAttrib4Nubv(GLuint index, const GLubyte *v);
-    void glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
-    void glVertexAttrib4Nsv(GLuint index, const GLshort *v);
-    void glVertexAttrib4Niv(GLuint index, const GLint *v);
-    void glVertexAttrib4Nbv(GLuint index, const GLbyte *v);
-    void glVertexAttrib3sv(GLuint index, const GLshort *v);
-    void glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z);
-    void glVertexAttrib3fv(GLuint index, const GLfloat *v);
-    void glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z);
-    void glVertexAttrib3dv(GLuint index, const GLdouble *v);
-    void glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z);
-    void glVertexAttrib2sv(GLuint index, const GLshort *v);
-    void glVertexAttrib2s(GLuint index, GLshort x, GLshort y);
-    void glVertexAttrib2fv(GLuint index, const GLfloat *v);
-    void glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y);
-    void glVertexAttrib2dv(GLuint index, const GLdouble *v);
-    void glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y);
-    void glVertexAttrib1sv(GLuint index, const GLshort *v);
-    void glVertexAttrib1s(GLuint index, GLshort x);
-    void glVertexAttrib1fv(GLuint index, const GLfloat *v);
-    void glVertexAttrib1f(GLuint index, GLfloat x);
-    void glVertexAttrib1dv(GLuint index, const GLdouble *v);
-    void glVertexAttrib1d(GLuint index, GLdouble x);
-
-    // OpenGL 2.1 deprecated functions
-
-    // OpenGL 3.0 deprecated functions
-    void glVertexAttribI4usv(GLuint index, const GLushort *v);
-    void glVertexAttribI4ubv(GLuint index, const GLubyte *v);
-    void glVertexAttribI4sv(GLuint index, const GLshort *v);
-    void glVertexAttribI4bv(GLuint index, const GLbyte *v);
-    void glVertexAttribI4uiv(GLuint index, const GLuint *v);
-    void glVertexAttribI3uiv(GLuint index, const GLuint *v);
-    void glVertexAttribI2uiv(GLuint index, const GLuint *v);
-    void glVertexAttribI1uiv(GLuint index, const GLuint *v);
-    void glVertexAttribI4iv(GLuint index, const GLint *v);
-    void glVertexAttribI3iv(GLuint index, const GLint *v);
-    void glVertexAttribI2iv(GLuint index, const GLint *v);
-    void glVertexAttribI1iv(GLuint index, const GLint *v);
-    void glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
-    void glVertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z);
-    void glVertexAttribI2ui(GLuint index, GLuint x, GLuint y);
-    void glVertexAttribI1ui(GLuint index, GLuint x);
-    void glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w);
-    void glVertexAttribI3i(GLuint index, GLint x, GLint y, GLint z);
-    void glVertexAttribI2i(GLuint index, GLint x, GLint y);
-    void glVertexAttribI1i(GLuint index, GLint x);
-
-    // OpenGL 3.1 deprecated functions
-
-    // OpenGL 3.2 deprecated functions
-
-    // OpenGL 3.3 deprecated functions
-
-private:
-    friend class QOpenGLContext;
-
-    static bool isContextCompatible(QOpenGLContext *context);
-    static QOpenGLVersionProfile versionProfile();
-
-    QOpenGLFunctions_1_0_CoreBackend* d_1_0_Core;
-    QOpenGLFunctions_1_1_CoreBackend* d_1_1_Core;
-    QOpenGLFunctions_1_2_CoreBackend* d_1_2_Core;
-    QOpenGLFunctions_1_3_CoreBackend* d_1_3_Core;
-    QOpenGLFunctions_1_4_CoreBackend* d_1_4_Core;
-    QOpenGLFunctions_1_5_CoreBackend* d_1_5_Core;
-    QOpenGLFunctions_2_0_CoreBackend* d_2_0_Core;
-    QOpenGLFunctions_2_1_CoreBackend* d_2_1_Core;
-    QOpenGLFunctions_3_0_CoreBackend* d_3_0_Core;
-    QOpenGLFunctions_3_1_CoreBackend* d_3_1_Core;
-    QOpenGLFunctions_3_2_CoreBackend* d_3_2_Core;
-    QOpenGLFunctions_3_3_CoreBackend* d_3_3_Core;
-    QOpenGLFunctions_1_0_DeprecatedBackend* d_1_0_Deprecated;
-    QOpenGLFunctions_1_1_DeprecatedBackend* d_1_1_Deprecated;
-    QOpenGLFunctions_1_2_DeprecatedBackend* d_1_2_Deprecated;
-    QOpenGLFunctions_1_3_DeprecatedBackend* d_1_3_Deprecated;
-    QOpenGLFunctions_1_4_DeprecatedBackend* d_1_4_Deprecated;
-    void *m_reserved_2_0_Deprecated; // To maintain BC
-    QOpenGLFunctions_3_3_DeprecatedBackend* d_3_3_Deprecated;
-};
-
-// OpenGL 1.0 core functions
-inline void QOpenGLFunctions_3_3_Compatibility::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_0_Core->f.Viewport(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glDepthRange(GLdouble nearVal, GLdouble farVal)
-{
-    d_1_0_Core->f.DepthRange(nearVal, farVal);
-}
-
-inline GLboolean QOpenGLFunctions_3_3_Compatibility::glIsEnabled(GLenum cap)
-{
-    return d_1_0_Core->f.IsEnabled(cap);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetTexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetTexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
-{
-    d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
-}
-
-inline const GLubyte * QOpenGLFunctions_3_3_Compatibility::glGetString(GLenum name)
-{
-    return d_1_0_Core->f.GetString(name);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetIntegerv(GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetIntegerv(pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetFloatv(GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetFloatv(pname, params);
-}
-
-inline GLenum QOpenGLFunctions_3_3_Compatibility::glGetError()
-{
-    return d_1_0_Core->f.GetError();
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetDoublev(GLenum pname, GLdouble *params)
-{
-    d_1_0_Core->f.GetDoublev(pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetBooleanv(GLenum pname, GLboolean *params)
-{
-    d_1_0_Core->f.GetBooleanv(pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
-{
-    d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glReadBuffer(GLenum mode)
-{
-    d_1_0_Core->f.ReadBuffer(mode);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glPixelStorei(GLenum pname, GLint param)
-{
-    d_1_0_Core->f.PixelStorei(pname, param);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glPixelStoref(GLenum pname, GLfloat param)
-{
-    d_1_0_Core->f.PixelStoref(pname, param);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glDepthFunc(GLenum func)
-{
-    d_1_0_Core->f.DepthFunc(func);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
-{
-    d_1_0_Core->f.StencilOp(fail, zfail, zpass);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glStencilFunc(GLenum func, GLint ref, GLuint mask)
-{
-    d_1_0_Core->f.StencilFunc(func, ref, mask);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glLogicOp(GLenum opcode)
-{
-    d_1_0_Core->f.LogicOp(opcode);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glBlendFunc(GLenum sfactor, GLenum dfactor)
-{
-    d_1_0_Core->f.BlendFunc(sfactor, dfactor);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glFlush()
-{
-    d_1_0_Core->f.Flush();
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glFinish()
-{
-    d_1_0_Core->f.Finish();
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glEnable(GLenum cap)
-{
-    d_1_0_Core->f.Enable(cap);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glDisable(GLenum cap)
-{
-    d_1_0_Core->f.Disable(cap);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glDepthMask(GLboolean flag)
-{
-    d_1_0_Core->f.DepthMask(flag);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
-{
-    d_1_0_Core->f.ColorMask(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glStencilMask(GLuint mask)
-{
-    d_1_0_Core->f.StencilMask(mask);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glClearDepth(GLdouble depth)
-{
-    d_1_0_Core->f.ClearDepth(depth);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glClearStencil(GLint s)
-{
-    d_1_0_Core->f.ClearStencil(s);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Core->f.ClearColor(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glClear(GLbitfield mask)
-{
-    d_1_0_Core->f.Clear(mask);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glDrawBuffer(GLenum mode)
-{
-    d_1_0_Core->f.DrawBuffer(mode);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Core->f.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Core->f.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_0_Core->f.TexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexParameteri(GLenum target, GLenum pname, GLint param)
-{
-    d_1_0_Core->f.TexParameteri(target, pname, param);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Core->f.TexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
-{
-    d_1_0_Core->f.TexParameterf(target, pname, param);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_0_Core->f.Scissor(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glPolygonMode(GLenum face, GLenum mode)
-{
-    d_1_0_Core->f.PolygonMode(face, mode);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glPointSize(GLfloat size)
-{
-    d_1_0_Core->f.PointSize(size);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glLineWidth(GLfloat width)
-{
-    d_1_0_Core->f.LineWidth(width);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glHint(GLenum target, GLenum mode)
-{
-    d_1_0_Core->f.Hint(target, mode);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glFrontFace(GLenum mode)
-{
-    d_1_0_Core->f.FrontFace(mode);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glCullFace(GLenum mode)
-{
-    d_1_0_Core->f.CullFace(mode);
-}
-
-
-// OpenGL 1.1 core functions
-inline void QOpenGLFunctions_3_3_Compatibility::glIndexubv(const GLubyte *c)
-{
-    d_1_1_Deprecated->f.Indexubv(c);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glIndexub(GLubyte c)
-{
-    d_1_1_Deprecated->f.Indexub(c);
-}
-
-inline GLboolean QOpenGLFunctions_3_3_Compatibility::glIsTexture(GLuint texture)
-{
-    return d_1_1_Core->f.IsTexture(texture);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGenTextures(GLsizei n, GLuint *textures)
-{
-    d_1_1_Core->f.GenTextures(n, textures);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glDeleteTextures(GLsizei n, const GLuint *textures)
-{
-    d_1_1_Core->f.DeleteTextures(n, textures);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glBindTexture(GLenum target, GLuint texture)
-{
-    d_1_1_Core->f.BindTexture(target, texture);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_1_Core->f.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_1_Core->f.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_1_Core->f.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
-{
-    d_1_1_Core->f.CopyTexSubImage1D(target, level, xoffset, x, y, width);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
-{
-    d_1_1_Core->f.CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
-{
-    d_1_1_Core->f.CopyTexImage1D(target, level, internalformat, x, y, width, border);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glPolygonOffset(GLfloat factor, GLfloat units)
-{
-    d_1_1_Core->f.PolygonOffset(factor, units);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetPointerv(GLenum pname, GLvoid* *params)
-{
-    d_1_1_Deprecated->f.GetPointerv(pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
-{
-    d_1_1_Core->f.DrawElements(mode, count, type, indices);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glDrawArrays(GLenum mode, GLint first, GLsizei count)
-{
-    d_1_1_Core->f.DrawArrays(mode, first, count);
-}
-
-
-// OpenGL 1.2 core functions
-inline void QOpenGLFunctions_3_3_Compatibility::glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_2_Core->f.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_2_Core->f.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_2_Core->f.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
-{
-    d_1_2_Core->f.DrawRangeElements(mode, start, end, count, type, indices);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glBlendEquation(GLenum mode)
-{
-    d_1_2_Core->f.BlendEquation(mode);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_2_Core->f.BlendColor(red, green, blue, alpha);
-}
-
-
-// OpenGL 1.3 core functions
-inline void QOpenGLFunctions_3_3_Compatibility::glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img)
-{
-    d_1_3_Core->f.GetCompressedTexImage(target, level, img);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glSampleCoverage(GLfloat value, GLboolean invert)
-{
-    d_1_3_Core->f.SampleCoverage(value, invert);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glActiveTexture(GLenum texture)
-{
-    d_1_3_Core->f.ActiveTexture(texture);
-}
-
-
-// OpenGL 1.4 core functions
-inline void QOpenGLFunctions_3_3_Compatibility::glPointParameteriv(GLenum pname, const GLint *params)
-{
-    d_1_4_Core->f.PointParameteriv(pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glPointParameteri(GLenum pname, GLint param)
-{
-    d_1_4_Core->f.PointParameteri(pname, param);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glPointParameterfv(GLenum pname, const GLfloat *params)
-{
-    d_1_4_Core->f.PointParameterfv(pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glPointParameterf(GLenum pname, GLfloat param)
-{
-    d_1_4_Core->f.PointParameterf(pname, param);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount)
-{
-    d_1_4_Core->f.MultiDrawElements(mode, count, type, indices, drawcount);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
-{
-    d_1_4_Core->f.MultiDrawArrays(mode, first, count, drawcount);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
-{
-    d_1_4_Core->f.BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
-}
-
-
-// OpenGL 1.5 core functions
-inline void QOpenGLFunctions_3_3_Compatibility::glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params)
-{
-    d_1_5_Core->f.GetBufferPointerv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetBufferParameteriv(target, pname, params);
-}
-
-inline GLboolean QOpenGLFunctions_3_3_Compatibility::glUnmapBuffer(GLenum target)
-{
-    return d_1_5_Core->f.UnmapBuffer(target);
-}
-
-inline GLvoid* QOpenGLFunctions_3_3_Compatibility::glMapBuffer(GLenum target, GLenum access)
-{
-    return d_1_5_Core->f.MapBuffer(target, access);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data)
-{
-    d_1_5_Core->f.GetBufferSubData(target, offset, size, data);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data)
-{
-    d_1_5_Core->f.BufferSubData(target, offset, size, data);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)
-{
-    d_1_5_Core->f.BufferData(target, size, data, usage);
-}
-
-inline GLboolean QOpenGLFunctions_3_3_Compatibility::glIsBuffer(GLuint buffer)
-{
-    return d_1_5_Core->f.IsBuffer(buffer);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGenBuffers(GLsizei n, GLuint *buffers)
-{
-    d_1_5_Core->f.GenBuffers(n, buffers);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glDeleteBuffers(GLsizei n, const GLuint *buffers)
-{
-    d_1_5_Core->f.DeleteBuffers(n, buffers);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glBindBuffer(GLenum target, GLuint buffer)
-{
-    d_1_5_Core->f.BindBuffer(target, buffer);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
-{
-    d_1_5_Core->f.GetQueryObjectuiv(id, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetQueryObjectiv(id, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetQueryiv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetQueryiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glEndQuery(GLenum target)
-{
-    d_1_5_Core->f.EndQuery(target);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glBeginQuery(GLenum target, GLuint id)
-{
-    d_1_5_Core->f.BeginQuery(target, id);
-}
-
-inline GLboolean QOpenGLFunctions_3_3_Compatibility::glIsQuery(GLuint id)
-{
-    return d_1_5_Core->f.IsQuery(id);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glDeleteQueries(GLsizei n, const GLuint *ids)
-{
-    d_1_5_Core->f.DeleteQueries(n, ids);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGenQueries(GLsizei n, GLuint *ids)
-{
-    d_1_5_Core->f.GenQueries(n, ids);
-}
-
-
-// OpenGL 2.0 core functions
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer)
-{
-    d_2_0_Core->f.VertexAttribPointer(index, size, type, normalized, stride, pointer);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glValidateProgram(GLuint program)
-{
-    d_2_0_Core->f.ValidateProgram(program);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix3fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glUniform4iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform4iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glUniform3iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform3iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glUniform2iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform2iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glUniform1iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform1iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glUniform4fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform4fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glUniform3fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform3fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glUniform2fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform2fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glUniform1fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform1fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
-{
-    d_2_0_Core->f.Uniform4i(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glUniform3i(GLint location, GLint v0, GLint v1, GLint v2)
-{
-    d_2_0_Core->f.Uniform3i(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glUniform2i(GLint location, GLint v0, GLint v1)
-{
-    d_2_0_Core->f.Uniform2i(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glUniform1i(GLint location, GLint v0)
-{
-    d_2_0_Core->f.Uniform1i(location, v0);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
-{
-    d_2_0_Core->f.Uniform4f(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
-{
-    d_2_0_Core->f.Uniform3f(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glUniform2f(GLint location, GLfloat v0, GLfloat v1)
-{
-    d_2_0_Core->f.Uniform2f(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glUniform1f(GLint location, GLfloat v0)
-{
-    d_2_0_Core->f.Uniform1f(location, v0);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glUseProgram(GLuint program)
-{
-    d_2_0_Core->f.UseProgram(program);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length)
-{
-    d_2_0_Core->f.ShaderSource(shader, count, string, length);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glLinkProgram(GLuint program)
-{
-    d_2_0_Core->f.LinkProgram(program);
-}
-
-inline GLboolean QOpenGLFunctions_3_3_Compatibility::glIsShader(GLuint shader)
-{
-    return d_2_0_Core->f.IsShader(shader);
-}
-
-inline GLboolean QOpenGLFunctions_3_3_Compatibility::glIsProgram(GLuint program)
-{
-    return d_2_0_Core->f.IsProgram(program);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer)
-{
-    d_2_0_Core->f.GetVertexAttribPointerv(index, pname, pointer);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetVertexAttribiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
-{
-    d_2_0_Core->f.GetVertexAttribfv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
-{
-    d_2_0_Core->f.GetVertexAttribdv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetUniformiv(GLuint program, GLint location, GLint *params)
-{
-    d_2_0_Core->f.GetUniformiv(program, location, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetUniformfv(GLuint program, GLint location, GLfloat *params)
-{
-    d_2_0_Core->f.GetUniformfv(program, location, params);
-}
-
-inline GLint QOpenGLFunctions_3_3_Compatibility::glGetUniformLocation(GLuint program, const GLchar *name)
-{
-    return d_2_0_Core->f.GetUniformLocation(program, name);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
-{
-    d_2_0_Core->f.GetShaderSource(shader, bufSize, length, source);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-{
-    d_2_0_Core->f.GetShaderInfoLog(shader, bufSize, length, infoLog);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetShaderiv(GLuint shader, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetShaderiv(shader, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-{
-    d_2_0_Core->f.GetProgramInfoLog(program, bufSize, length, infoLog);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetProgramiv(GLuint program, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetProgramiv(program, pname, params);
-}
-
-inline GLint QOpenGLFunctions_3_3_Compatibility::glGetAttribLocation(GLuint program, const GLchar *name)
-{
-    return d_2_0_Core->f.GetAttribLocation(program, name);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj)
-{
-    d_2_0_Core->f.GetAttachedShaders(program, maxCount, count, obj);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
-{
-    d_2_0_Core->f.GetActiveUniform(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
-{
-    d_2_0_Core->f.GetActiveAttrib(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glEnableVertexAttribArray(GLuint index)
-{
-    d_2_0_Core->f.EnableVertexAttribArray(index);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glDisableVertexAttribArray(GLuint index)
-{
-    d_2_0_Core->f.DisableVertexAttribArray(index);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glDetachShader(GLuint program, GLuint shader)
-{
-    d_2_0_Core->f.DetachShader(program, shader);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glDeleteShader(GLuint shader)
-{
-    d_2_0_Core->f.DeleteShader(shader);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glDeleteProgram(GLuint program)
-{
-    d_2_0_Core->f.DeleteProgram(program);
-}
-
-inline GLuint QOpenGLFunctions_3_3_Compatibility::glCreateShader(GLenum type)
-{
-    return d_2_0_Core->f.CreateShader(type);
-}
-
-inline GLuint QOpenGLFunctions_3_3_Compatibility::glCreateProgram()
-{
-    return d_2_0_Core->f.CreateProgram();
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glCompileShader(GLuint shader)
-{
-    d_2_0_Core->f.CompileShader(shader);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glBindAttribLocation(GLuint program, GLuint index, const GLchar *name)
-{
-    d_2_0_Core->f.BindAttribLocation(program, index, name);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glAttachShader(GLuint program, GLuint shader)
-{
-    d_2_0_Core->f.AttachShader(program, shader);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glStencilMaskSeparate(GLenum face, GLuint mask)
-{
-    d_2_0_Core->f.StencilMaskSeparate(face, mask);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
-{
-    d_2_0_Core->f.StencilFuncSeparate(face, func, ref, mask);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
-{
-    d_2_0_Core->f.StencilOpSeparate(face, sfail, dpfail, dppass);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glDrawBuffers(GLsizei n, const GLenum *bufs)
-{
-    d_2_0_Core->f.DrawBuffers(n, bufs);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
-{
-    d_2_0_Core->f.BlendEquationSeparate(modeRGB, modeAlpha);
-}
-
-
-// OpenGL 2.1 core functions
-inline void QOpenGLFunctions_3_3_Compatibility::glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix4x3fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix3x4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix4x2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix2x4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix3x2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix2x3fv(location, count, transpose, value);
-}
-
-
-// OpenGL 3.0 core functions
-inline GLboolean QOpenGLFunctions_3_3_Compatibility::glIsVertexArray(GLuint array)
-{
-    return d_3_0_Core->f.IsVertexArray(array);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGenVertexArrays(GLsizei n, GLuint *arrays)
-{
-    d_3_0_Core->f.GenVertexArrays(n, arrays);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glDeleteVertexArrays(GLsizei n, const GLuint *arrays)
-{
-    d_3_0_Core->f.DeleteVertexArrays(n, arrays);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glBindVertexArray(GLuint array)
-{
-    d_3_0_Core->f.BindVertexArray(array);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
-{
-    d_3_0_Core->f.FlushMappedBufferRange(target, offset, length);
-}
-
-inline GLvoid* QOpenGLFunctions_3_3_Compatibility::glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
-{
-    return d_3_0_Core->f.MapBufferRange(target, offset, length, access);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
-{
-    d_3_0_Core->f.FramebufferTextureLayer(target, attachment, texture, level, layer);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    d_3_0_Core->f.RenderbufferStorageMultisample(target, samples, internalformat, width, height);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
-{
-    d_3_0_Core->f.BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGenerateMipmap(GLenum target)
-{
-    d_3_0_Core->f.GenerateMipmap(target);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
-{
-    d_3_0_Core->f.FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
-{
-    d_3_0_Core->f.FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
-{
-    d_3_0_Core->f.FramebufferTexture2D(target, attachment, textarget, texture, level);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
-{
-    d_3_0_Core->f.FramebufferTexture1D(target, attachment, textarget, texture, level);
-}
-
-inline GLenum QOpenGLFunctions_3_3_Compatibility::glCheckFramebufferStatus(GLenum target)
-{
-    return d_3_0_Core->f.CheckFramebufferStatus(target);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGenFramebuffers(GLsizei n, GLuint *framebuffers)
-{
-    d_3_0_Core->f.GenFramebuffers(n, framebuffers);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
-{
-    d_3_0_Core->f.DeleteFramebuffers(n, framebuffers);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glBindFramebuffer(GLenum target, GLuint framebuffer)
-{
-    d_3_0_Core->f.BindFramebuffer(target, framebuffer);
-}
-
-inline GLboolean QOpenGLFunctions_3_3_Compatibility::glIsFramebuffer(GLuint framebuffer)
-{
-    return d_3_0_Core->f.IsFramebuffer(framebuffer);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetRenderbufferParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    d_3_0_Core->f.RenderbufferStorage(target, internalformat, width, height);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGenRenderbuffers(GLsizei n, GLuint *renderbuffers)
-{
-    d_3_0_Core->f.GenRenderbuffers(n, renderbuffers);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
-{
-    d_3_0_Core->f.DeleteRenderbuffers(n, renderbuffers);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glBindRenderbuffer(GLenum target, GLuint renderbuffer)
-{
-    d_3_0_Core->f.BindRenderbuffer(target, renderbuffer);
-}
-
-inline GLboolean QOpenGLFunctions_3_3_Compatibility::glIsRenderbuffer(GLuint renderbuffer)
-{
-    return d_3_0_Core->f.IsRenderbuffer(renderbuffer);
-}
-
-inline const GLubyte * QOpenGLFunctions_3_3_Compatibility::glGetStringi(GLenum name, GLuint index)
-{
-    return d_3_0_Core->f.GetStringi(name, index);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
-{
-    d_3_0_Core->f.ClearBufferfi(buffer, drawbuffer, depth, stencil);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
-{
-    d_3_0_Core->f.ClearBufferfv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
-{
-    d_3_0_Core->f.ClearBufferuiv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
-{
-    d_3_0_Core->f.ClearBufferiv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params)
-{
-    d_3_0_Core->f.GetTexParameterIuiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetTexParameterIiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params)
-{
-    d_3_0_Core->f.TexParameterIuiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexParameterIiv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_3_0_Core->f.TexParameterIiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glUniform4uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform4uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glUniform3uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform3uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glUniform2uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform2uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glUniform1uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform1uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
-{
-    d_3_0_Core->f.Uniform4ui(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
-{
-    d_3_0_Core->f.Uniform3ui(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glUniform2ui(GLint location, GLuint v0, GLuint v1)
-{
-    d_3_0_Core->f.Uniform2ui(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glUniform1ui(GLint location, GLuint v0)
-{
-    d_3_0_Core->f.Uniform1ui(location, v0);
-}
-
-inline GLint QOpenGLFunctions_3_3_Compatibility::glGetFragDataLocation(GLuint program, const GLchar *name)
-{
-    return d_3_0_Core->f.GetFragDataLocation(program, name);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name)
-{
-    d_3_0_Core->f.BindFragDataLocation(program, color, name);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetUniformuiv(GLuint program, GLint location, GLuint *params)
-{
-    d_3_0_Core->f.GetUniformuiv(program, location, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
-{
-    d_3_0_Core->f.GetVertexAttribIuiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetVertexAttribIiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_3_0_Core->f.VertexAttribIPointer(index, size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glEndConditionalRender()
-{
-    d_3_0_Core->f.EndConditionalRender();
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glBeginConditionalRender(GLuint id, GLenum mode)
-{
-    d_3_0_Core->f.BeginConditionalRender(id, mode);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glClampColor(GLenum target, GLenum clamp)
-{
-    d_3_0_Core->f.ClampColor(target, clamp);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
-{
-    d_3_0_Core->f.GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode)
-{
-    d_3_0_Core->f.TransformFeedbackVaryings(program, count, varyings, bufferMode);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
-{
-    d_3_0_Core->f.BindBufferBase(target, index, buffer);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
-{
-    d_3_0_Core->f.BindBufferRange(target, index, buffer, offset, size);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glEndTransformFeedback()
-{
-    d_3_0_Core->f.EndTransformFeedback();
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glBeginTransformFeedback(GLenum primitiveMode)
-{
-    d_3_0_Core->f.BeginTransformFeedback(primitiveMode);
-}
-
-inline GLboolean QOpenGLFunctions_3_3_Compatibility::glIsEnabledi(GLenum target, GLuint index)
-{
-    return d_3_0_Core->f.IsEnabledi(target, index);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glDisablei(GLenum target, GLuint index)
-{
-    d_3_0_Core->f.Disablei(target, index);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glEnablei(GLenum target, GLuint index)
-{
-    d_3_0_Core->f.Enablei(target, index);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetIntegeri_v(GLenum target, GLuint index, GLint *data)
-{
-    d_3_0_Core->f.GetIntegeri_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetBooleani_v(GLenum target, GLuint index, GLboolean *data)
-{
-    d_3_0_Core->f.GetBooleani_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
-{
-    d_3_0_Core->f.ColorMaski(index, r, g, b, a);
-}
-
-
-// OpenGL 3.1 core functions
-inline void QOpenGLFunctions_3_3_Compatibility::glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
-{
-    d_3_1_Core->f.CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
-{
-    d_3_1_Core->f.UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
-{
-    d_3_1_Core->f.GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params)
-{
-    d_3_1_Core->f.GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
-}
-
-inline GLuint QOpenGLFunctions_3_3_Compatibility::glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName)
-{
-    return d_3_1_Core->f.GetUniformBlockIndex(program, uniformBlockName);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName)
-{
-    d_3_1_Core->f.GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params)
-{
-    d_3_1_Core->f.GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const *uniformNames, GLuint *uniformIndices)
-{
-    d_3_1_Core->f.GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glPrimitiveRestartIndex(GLuint index)
-{
-    d_3_1_Core->f.PrimitiveRestartIndex(index);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer)
-{
-    d_3_1_Core->f.TexBuffer(target, internalformat, buffer);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount)
-{
-    d_3_1_Core->f.DrawElementsInstanced(mode, count, type, indices, instancecount);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount)
-{
-    d_3_1_Core->f.DrawArraysInstanced(mode, first, count, instancecount);
-}
-
-
-// OpenGL 3.2 core functions
-inline void QOpenGLFunctions_3_3_Compatibility::glSampleMaski(GLuint index, GLbitfield mask)
-{
-    d_3_2_Core->f.SampleMaski(index, mask);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val)
-{
-    d_3_2_Core->f.GetMultisamplefv(pname, index, val);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexImage3DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
-{
-    d_3_2_Core->f.TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexImage2DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
-{
-    d_3_2_Core->f.TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values)
-{
-    d_3_2_Core->f.GetSynciv(sync, pname, bufSize, length, values);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetInteger64v(GLenum pname, GLint64 *params)
-{
-    d_3_2_Core->f.GetInteger64v(pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
-{
-    d_3_2_Core->f.WaitSync(sync, flags, timeout);
-}
-
-inline GLenum QOpenGLFunctions_3_3_Compatibility::glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
-{
-    return d_3_2_Core->f.ClientWaitSync(sync, flags, timeout);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glDeleteSync(GLsync sync)
-{
-    d_3_2_Core->f.DeleteSync(sync);
-}
-
-inline GLboolean QOpenGLFunctions_3_3_Compatibility::glIsSync(GLsync sync)
-{
-    return d_3_2_Core->f.IsSync(sync);
-}
-
-inline GLsync QOpenGLFunctions_3_3_Compatibility::glFenceSync(GLenum condition, GLbitfield flags)
-{
-    return d_3_2_Core->f.FenceSync(condition, flags);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glProvokingVertex(GLenum mode)
-{
-    d_3_2_Core->f.ProvokingVertex(mode);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount, const GLint *basevertex)
-{
-    d_3_2_Core->f.MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount, GLint basevertex)
-{
-    d_3_2_Core->f.DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)
-{
-    d_3_2_Core->f.DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)
-{
-    d_3_2_Core->f.DrawElementsBaseVertex(mode, count, type, indices, basevertex);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level)
-{
-    d_3_2_Core->f.FramebufferTexture(target, attachment, texture, level);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params)
-{
-    d_3_2_Core->f.GetBufferParameteri64v(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data)
-{
-    d_3_2_Core->f.GetInteger64i_v(target, index, data);
-}
-
-
-// OpenGL 3.3 core functions
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribP4uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP4uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP4ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribP3uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP3uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP3ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribP2uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP2uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP2ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribP1uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP1uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP1ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glSecondaryColorP3uiv(GLenum type, const GLuint *color)
-{
-    d_3_3_Deprecated->f.SecondaryColorP3uiv(type, color);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glSecondaryColorP3ui(GLenum type, GLuint color)
-{
-    d_3_3_Deprecated->f.SecondaryColorP3ui(type, color);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glColorP4uiv(GLenum type, const GLuint *color)
-{
-    d_3_3_Deprecated->f.ColorP4uiv(type, color);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glColorP4ui(GLenum type, GLuint color)
-{
-    d_3_3_Deprecated->f.ColorP4ui(type, color);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glColorP3uiv(GLenum type, const GLuint *color)
-{
-    d_3_3_Deprecated->f.ColorP3uiv(type, color);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glColorP3ui(GLenum type, GLuint color)
-{
-    d_3_3_Deprecated->f.ColorP3ui(type, color);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glNormalP3uiv(GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.NormalP3uiv(type, coords);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glNormalP3ui(GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.NormalP3ui(type, coords);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP4uiv(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP4ui(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP3uiv(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP3ui(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP2uiv(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP2ui(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP1uiv(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP1ui(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexCoordP4uiv(GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.TexCoordP4uiv(type, coords);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexCoordP4ui(GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.TexCoordP4ui(type, coords);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexCoordP3uiv(GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.TexCoordP3uiv(type, coords);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexCoordP3ui(GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.TexCoordP3ui(type, coords);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexCoordP2uiv(GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.TexCoordP2uiv(type, coords);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexCoordP2ui(GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.TexCoordP2ui(type, coords);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexCoordP1uiv(GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.TexCoordP1uiv(type, coords);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexCoordP1ui(GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.TexCoordP1ui(type, coords);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexP4uiv(GLenum type, const GLuint *value)
-{
-    d_3_3_Deprecated->f.VertexP4uiv(type, value);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexP4ui(GLenum type, GLuint value)
-{
-    d_3_3_Deprecated->f.VertexP4ui(type, value);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexP3uiv(GLenum type, const GLuint *value)
-{
-    d_3_3_Deprecated->f.VertexP3uiv(type, value);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexP3ui(GLenum type, GLuint value)
-{
-    d_3_3_Deprecated->f.VertexP3ui(type, value);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexP2uiv(GLenum type, const GLuint *value)
-{
-    d_3_3_Deprecated->f.VertexP2uiv(type, value);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexP2ui(GLenum type, GLuint value)
-{
-    d_3_3_Deprecated->f.VertexP2ui(type, value);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params)
-{
-    d_3_3_Core->f.GetQueryObjectui64v(id, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params)
-{
-    d_3_3_Core->f.GetQueryObjecti64v(id, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glQueryCounter(GLuint id, GLenum target)
-{
-    d_3_3_Core->f.QueryCounter(id, target);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params)
-{
-    d_3_3_Core->f.GetSamplerParameterIuiv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params)
-{
-    d_3_3_Core->f.GetSamplerParameterfv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params)
-{
-    d_3_3_Core->f.GetSamplerParameterIiv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params)
-{
-    d_3_3_Core->f.GetSamplerParameteriv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param)
-{
-    d_3_3_Core->f.SamplerParameterIuiv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param)
-{
-    d_3_3_Core->f.SamplerParameterIiv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param)
-{
-    d_3_3_Core->f.SamplerParameterfv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
-{
-    d_3_3_Core->f.SamplerParameterf(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param)
-{
-    d_3_3_Core->f.SamplerParameteriv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glSamplerParameteri(GLuint sampler, GLenum pname, GLint param)
-{
-    d_3_3_Core->f.SamplerParameteri(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glBindSampler(GLuint unit, GLuint sampler)
-{
-    d_3_3_Core->f.BindSampler(unit, sampler);
-}
-
-inline GLboolean QOpenGLFunctions_3_3_Compatibility::glIsSampler(GLuint sampler)
-{
-    return d_3_3_Core->f.IsSampler(sampler);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glDeleteSamplers(GLsizei count, const GLuint *samplers)
-{
-    d_3_3_Core->f.DeleteSamplers(count, samplers);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGenSamplers(GLsizei count, GLuint *samplers)
-{
-    d_3_3_Core->f.GenSamplers(count, samplers);
-}
-
-inline GLint QOpenGLFunctions_3_3_Compatibility::glGetFragDataIndex(GLuint program, const GLchar *name)
-{
-    return d_3_3_Core->f.GetFragDataIndex(program, name);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glBindFragDataLocationIndexed(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name)
-{
-    d_3_3_Core->f.BindFragDataLocationIndexed(program, colorNumber, index, name);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribDivisor(GLuint index, GLuint divisor)
-{
-    d_3_3_Core->f.VertexAttribDivisor(index, divisor);
-}
-
-
-// OpenGL 1.0 deprecated functions
-inline void QOpenGLFunctions_3_3_Compatibility::glTranslatef(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Translatef(x, y, z);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTranslated(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Translated(x, y, z);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glScalef(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Scalef(x, y, z);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glScaled(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Scaled(x, y, z);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Rotatef(angle, x, y, z);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Rotated(angle, x, y, z);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glPushMatrix()
-{
-    d_1_0_Deprecated->f.PushMatrix();
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glPopMatrix()
-{
-    d_1_0_Deprecated->f.PopMatrix();
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
-{
-    d_1_0_Deprecated->f.Ortho(left, right, bottom, top, zNear, zFar);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMultMatrixd(const GLdouble *m)
-{
-    d_1_0_Deprecated->f.MultMatrixd(m);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMultMatrixf(const GLfloat *m)
-{
-    d_1_0_Deprecated->f.MultMatrixf(m);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMatrixMode(GLenum mode)
-{
-    d_1_0_Deprecated->f.MatrixMode(mode);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glLoadMatrixd(const GLdouble *m)
-{
-    d_1_0_Deprecated->f.LoadMatrixd(m);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glLoadMatrixf(const GLfloat *m)
-{
-    d_1_0_Deprecated->f.LoadMatrixf(m);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glLoadIdentity()
-{
-    d_1_0_Deprecated->f.LoadIdentity();
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
-{
-    d_1_0_Deprecated->f.Frustum(left, right, bottom, top, zNear, zFar);
-}
-
-inline GLboolean QOpenGLFunctions_3_3_Compatibility::glIsList(GLuint list)
-{
-    return d_1_0_Deprecated->f.IsList(list);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetTexGeniv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetTexGenfv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
-{
-    d_1_0_Deprecated->f.GetTexGendv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetTexEnviv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetTexEnviv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetTexEnvfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetPolygonStipple(GLubyte *mask)
-{
-    d_1_0_Deprecated->f.GetPolygonStipple(mask);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetPixelMapusv(GLenum map, GLushort *values)
-{
-    d_1_0_Deprecated->f.GetPixelMapusv(map, values);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetPixelMapuiv(GLenum map, GLuint *values)
-{
-    d_1_0_Deprecated->f.GetPixelMapuiv(map, values);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetPixelMapfv(GLenum map, GLfloat *values)
-{
-    d_1_0_Deprecated->f.GetPixelMapfv(map, values);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetMaterialiv(GLenum face, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetMaterialiv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetMaterialfv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetMapiv(GLenum target, GLenum query, GLint *v)
-{
-    d_1_0_Deprecated->f.GetMapiv(target, query, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetMapfv(GLenum target, GLenum query, GLfloat *v)
-{
-    d_1_0_Deprecated->f.GetMapfv(target, query, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetMapdv(GLenum target, GLenum query, GLdouble *v)
-{
-    d_1_0_Deprecated->f.GetMapdv(target, query, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetLightiv(GLenum light, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetLightiv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetLightfv(GLenum light, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetLightfv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetClipPlane(GLenum plane, GLdouble *equation)
-{
-    d_1_0_Deprecated->f.GetClipPlane(plane, equation);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Deprecated->f.DrawPixels(width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
-{
-    d_1_0_Deprecated->f.CopyPixels(x, y, width, height, type);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values)
-{
-    d_1_0_Deprecated->f.PixelMapusv(map, mapsize, values);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values)
-{
-    d_1_0_Deprecated->f.PixelMapuiv(map, mapsize, values);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values)
-{
-    d_1_0_Deprecated->f.PixelMapfv(map, mapsize, values);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glPixelTransferi(GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.PixelTransferi(pname, param);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glPixelTransferf(GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.PixelTransferf(pname, param);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glPixelZoom(GLfloat xfactor, GLfloat yfactor)
-{
-    d_1_0_Deprecated->f.PixelZoom(xfactor, yfactor);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glAlphaFunc(GLenum func, GLfloat ref)
-{
-    d_1_0_Deprecated->f.AlphaFunc(func, ref);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glEvalPoint2(GLint i, GLint j)
-{
-    d_1_0_Deprecated->f.EvalPoint2(i, j);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
-{
-    d_1_0_Deprecated->f.EvalMesh2(mode, i1, i2, j1, j2);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glEvalPoint1(GLint i)
-{
-    d_1_0_Deprecated->f.EvalPoint1(i);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glEvalMesh1(GLenum mode, GLint i1, GLint i2)
-{
-    d_1_0_Deprecated->f.EvalMesh1(mode, i1, i2);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glEvalCoord2fv(const GLfloat *u)
-{
-    d_1_0_Deprecated->f.EvalCoord2fv(u);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glEvalCoord2f(GLfloat u, GLfloat v)
-{
-    d_1_0_Deprecated->f.EvalCoord2f(u, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glEvalCoord2dv(const GLdouble *u)
-{
-    d_1_0_Deprecated->f.EvalCoord2dv(u);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glEvalCoord2d(GLdouble u, GLdouble v)
-{
-    d_1_0_Deprecated->f.EvalCoord2d(u, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glEvalCoord1fv(const GLfloat *u)
-{
-    d_1_0_Deprecated->f.EvalCoord1fv(u);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glEvalCoord1f(GLfloat u)
-{
-    d_1_0_Deprecated->f.EvalCoord1f(u);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glEvalCoord1dv(const GLdouble *u)
-{
-    d_1_0_Deprecated->f.EvalCoord1dv(u);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glEvalCoord1d(GLdouble u)
-{
-    d_1_0_Deprecated->f.EvalCoord1d(u);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
-{
-    d_1_0_Deprecated->f.MapGrid2f(un, u1, u2, vn, v1, v2);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
-{
-    d_1_0_Deprecated->f.MapGrid2d(un, u1, u2, vn, v1, v2);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
-{
-    d_1_0_Deprecated->f.MapGrid1f(un, u1, u2);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
-{
-    d_1_0_Deprecated->f.MapGrid1d(un, u1, u2);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
-{
-    d_1_0_Deprecated->f.Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
-{
-    d_1_0_Deprecated->f.Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
-{
-    d_1_0_Deprecated->f.Map1f(target, u1, u2, stride, order, points);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
-{
-    d_1_0_Deprecated->f.Map1d(target, u1, u2, stride, order, points);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glPushAttrib(GLbitfield mask)
-{
-    d_1_0_Deprecated->f.PushAttrib(mask);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glPopAttrib()
-{
-    d_1_0_Deprecated->f.PopAttrib();
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glAccum(GLenum op, GLfloat value)
-{
-    d_1_0_Deprecated->f.Accum(op, value);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glIndexMask(GLuint mask)
-{
-    d_1_0_Deprecated->f.IndexMask(mask);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glClearIndex(GLfloat c)
-{
-    d_1_0_Deprecated->f.ClearIndex(c);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Deprecated->f.ClearAccum(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glPushName(GLuint name)
-{
-    d_1_0_Deprecated->f.PushName(name);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glPopName()
-{
-    d_1_0_Deprecated->f.PopName();
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glPassThrough(GLfloat token)
-{
-    d_1_0_Deprecated->f.PassThrough(token);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glLoadName(GLuint name)
-{
-    d_1_0_Deprecated->f.LoadName(name);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glInitNames()
-{
-    d_1_0_Deprecated->f.InitNames();
-}
-
-inline GLint QOpenGLFunctions_3_3_Compatibility::glRenderMode(GLenum mode)
-{
-    return d_1_0_Deprecated->f.RenderMode(mode);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glSelectBuffer(GLsizei size, GLuint *buffer)
-{
-    d_1_0_Deprecated->f.SelectBuffer(size, buffer);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
-{
-    d_1_0_Deprecated->f.FeedbackBuffer(size, type, buffer);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexGeniv(GLenum coord, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.TexGeniv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexGeni(GLenum coord, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.TexGeni(coord, pname, param);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.TexGenfv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexGenf(GLenum coord, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.TexGenf(coord, pname, param);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
-{
-    d_1_0_Deprecated->f.TexGendv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexGend(GLenum coord, GLenum pname, GLdouble param)
-{
-    d_1_0_Deprecated->f.TexGend(coord, pname, param);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexEnviv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.TexEnviv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexEnvi(GLenum target, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.TexEnvi(target, pname, param);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.TexEnvfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexEnvf(GLenum target, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.TexEnvf(target, pname, param);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glShadeModel(GLenum mode)
-{
-    d_1_0_Deprecated->f.ShadeModel(mode);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glPolygonStipple(const GLubyte *mask)
-{
-    d_1_0_Deprecated->f.PolygonStipple(mask);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMaterialiv(GLenum face, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.Materialiv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMateriali(GLenum face, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.Materiali(face, pname, param);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.Materialfv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMaterialf(GLenum face, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.Materialf(face, pname, param);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glLineStipple(GLint factor, GLushort pattern)
-{
-    d_1_0_Deprecated->f.LineStipple(factor, pattern);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glLightModeliv(GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.LightModeliv(pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glLightModeli(GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.LightModeli(pname, param);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glLightModelfv(GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.LightModelfv(pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glLightModelf(GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.LightModelf(pname, param);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glLightiv(GLenum light, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.Lightiv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glLighti(GLenum light, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.Lighti(light, pname, param);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glLightfv(GLenum light, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.Lightfv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glLightf(GLenum light, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.Lightf(light, pname, param);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glFogiv(GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.Fogiv(pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glFogi(GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.Fogi(pname, param);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glFogfv(GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.Fogfv(pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glFogf(GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.Fogf(pname, param);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glColorMaterial(GLenum face, GLenum mode)
-{
-    d_1_0_Deprecated->f.ColorMaterial(face, mode);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glClipPlane(GLenum plane, const GLdouble *equation)
-{
-    d_1_0_Deprecated->f.ClipPlane(plane, equation);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertex4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Vertex4sv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
-{
-    d_1_0_Deprecated->f.Vertex4s(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertex4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Vertex4iv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertex4i(GLint x, GLint y, GLint z, GLint w)
-{
-    d_1_0_Deprecated->f.Vertex4i(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertex4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Vertex4fv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    d_1_0_Deprecated->f.Vertex4f(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertex4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Vertex4dv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_1_0_Deprecated->f.Vertex4d(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertex3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Vertex3sv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertex3s(GLshort x, GLshort y, GLshort z)
-{
-    d_1_0_Deprecated->f.Vertex3s(x, y, z);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertex3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Vertex3iv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertex3i(GLint x, GLint y, GLint z)
-{
-    d_1_0_Deprecated->f.Vertex3i(x, y, z);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertex3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Vertex3fv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertex3f(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Vertex3f(x, y, z);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertex3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Vertex3dv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertex3d(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Vertex3d(x, y, z);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertex2sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Vertex2sv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertex2s(GLshort x, GLshort y)
-{
-    d_1_0_Deprecated->f.Vertex2s(x, y);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertex2iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Vertex2iv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertex2i(GLint x, GLint y)
-{
-    d_1_0_Deprecated->f.Vertex2i(x, y);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertex2fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Vertex2fv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertex2f(GLfloat x, GLfloat y)
-{
-    d_1_0_Deprecated->f.Vertex2f(x, y);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertex2dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Vertex2dv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertex2d(GLdouble x, GLdouble y)
-{
-    d_1_0_Deprecated->f.Vertex2d(x, y);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord4sv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
-{
-    d_1_0_Deprecated->f.TexCoord4s(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord4iv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
-{
-    d_1_0_Deprecated->f.TexCoord4i(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord4fv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
-{
-    d_1_0_Deprecated->f.TexCoord4f(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord4dv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
-{
-    d_1_0_Deprecated->f.TexCoord4d(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord3sv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord3s(GLshort s, GLshort t, GLshort r)
-{
-    d_1_0_Deprecated->f.TexCoord3s(s, t, r);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord3iv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord3i(GLint s, GLint t, GLint r)
-{
-    d_1_0_Deprecated->f.TexCoord3i(s, t, r);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord3fv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
-{
-    d_1_0_Deprecated->f.TexCoord3f(s, t, r);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord3dv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
-{
-    d_1_0_Deprecated->f.TexCoord3d(s, t, r);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord2sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord2sv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord2s(GLshort s, GLshort t)
-{
-    d_1_0_Deprecated->f.TexCoord2s(s, t);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord2iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord2iv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord2i(GLint s, GLint t)
-{
-    d_1_0_Deprecated->f.TexCoord2i(s, t);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord2fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord2fv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord2f(GLfloat s, GLfloat t)
-{
-    d_1_0_Deprecated->f.TexCoord2f(s, t);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord2dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord2dv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord2d(GLdouble s, GLdouble t)
-{
-    d_1_0_Deprecated->f.TexCoord2d(s, t);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord1sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord1sv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord1s(GLshort s)
-{
-    d_1_0_Deprecated->f.TexCoord1s(s);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord1iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord1iv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord1i(GLint s)
-{
-    d_1_0_Deprecated->f.TexCoord1i(s);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord1fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord1fv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord1f(GLfloat s)
-{
-    d_1_0_Deprecated->f.TexCoord1f(s);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord1dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord1dv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord1d(GLdouble s)
-{
-    d_1_0_Deprecated->f.TexCoord1d(s);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glRectsv(const GLshort *v1, const GLshort *v2)
-{
-    d_1_0_Deprecated->f.Rectsv(v1, v2);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
-{
-    d_1_0_Deprecated->f.Rects(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glRectiv(const GLint *v1, const GLint *v2)
-{
-    d_1_0_Deprecated->f.Rectiv(v1, v2);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
-{
-    d_1_0_Deprecated->f.Recti(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glRectfv(const GLfloat *v1, const GLfloat *v2)
-{
-    d_1_0_Deprecated->f.Rectfv(v1, v2);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
-{
-    d_1_0_Deprecated->f.Rectf(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glRectdv(const GLdouble *v1, const GLdouble *v2)
-{
-    d_1_0_Deprecated->f.Rectdv(v1, v2);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
-{
-    d_1_0_Deprecated->f.Rectd(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glRasterPos4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.RasterPos4sv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
-{
-    d_1_0_Deprecated->f.RasterPos4s(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glRasterPos4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.RasterPos4iv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
-{
-    d_1_0_Deprecated->f.RasterPos4i(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glRasterPos4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.RasterPos4fv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    d_1_0_Deprecated->f.RasterPos4f(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glRasterPos4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.RasterPos4dv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_1_0_Deprecated->f.RasterPos4d(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glRasterPos3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.RasterPos3sv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glRasterPos3s(GLshort x, GLshort y, GLshort z)
-{
-    d_1_0_Deprecated->f.RasterPos3s(x, y, z);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glRasterPos3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.RasterPos3iv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glRasterPos3i(GLint x, GLint y, GLint z)
-{
-    d_1_0_Deprecated->f.RasterPos3i(x, y, z);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glRasterPos3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.RasterPos3fv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.RasterPos3f(x, y, z);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glRasterPos3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.RasterPos3dv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.RasterPos3d(x, y, z);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glRasterPos2sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.RasterPos2sv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glRasterPos2s(GLshort x, GLshort y)
-{
-    d_1_0_Deprecated->f.RasterPos2s(x, y);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glRasterPos2iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.RasterPos2iv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glRasterPos2i(GLint x, GLint y)
-{
-    d_1_0_Deprecated->f.RasterPos2i(x, y);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glRasterPos2fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.RasterPos2fv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glRasterPos2f(GLfloat x, GLfloat y)
-{
-    d_1_0_Deprecated->f.RasterPos2f(x, y);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glRasterPos2dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.RasterPos2dv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glRasterPos2d(GLdouble x, GLdouble y)
-{
-    d_1_0_Deprecated->f.RasterPos2d(x, y);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glNormal3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Normal3sv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glNormal3s(GLshort nx, GLshort ny, GLshort nz)
-{
-    d_1_0_Deprecated->f.Normal3s(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glNormal3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Normal3iv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glNormal3i(GLint nx, GLint ny, GLint nz)
-{
-    d_1_0_Deprecated->f.Normal3i(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glNormal3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Normal3fv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
-{
-    d_1_0_Deprecated->f.Normal3f(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glNormal3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Normal3dv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
-{
-    d_1_0_Deprecated->f.Normal3d(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glNormal3bv(const GLbyte *v)
-{
-    d_1_0_Deprecated->f.Normal3bv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
-{
-    d_1_0_Deprecated->f.Normal3b(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glIndexsv(const GLshort *c)
-{
-    d_1_0_Deprecated->f.Indexsv(c);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glIndexs(GLshort c)
-{
-    d_1_0_Deprecated->f.Indexs(c);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glIndexiv(const GLint *c)
-{
-    d_1_0_Deprecated->f.Indexiv(c);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glIndexi(GLint c)
-{
-    d_1_0_Deprecated->f.Indexi(c);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glIndexfv(const GLfloat *c)
-{
-    d_1_0_Deprecated->f.Indexfv(c);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glIndexf(GLfloat c)
-{
-    d_1_0_Deprecated->f.Indexf(c);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glIndexdv(const GLdouble *c)
-{
-    d_1_0_Deprecated->f.Indexdv(c);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glIndexd(GLdouble c)
-{
-    d_1_0_Deprecated->f.Indexd(c);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glEnd()
-{
-    d_1_0_Deprecated->f.End();
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glEdgeFlagv(const GLboolean *flag)
-{
-    d_1_0_Deprecated->f.EdgeFlagv(flag);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glEdgeFlag(GLboolean flag)
-{
-    d_1_0_Deprecated->f.EdgeFlag(flag);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glColor4usv(const GLushort *v)
-{
-    d_1_0_Deprecated->f.Color4usv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
-{
-    d_1_0_Deprecated->f.Color4us(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glColor4uiv(const GLuint *v)
-{
-    d_1_0_Deprecated->f.Color4uiv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
-{
-    d_1_0_Deprecated->f.Color4ui(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glColor4ubv(const GLubyte *v)
-{
-    d_1_0_Deprecated->f.Color4ubv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
-{
-    d_1_0_Deprecated->f.Color4ub(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glColor4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Color4sv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
-{
-    d_1_0_Deprecated->f.Color4s(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glColor4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Color4iv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
-{
-    d_1_0_Deprecated->f.Color4i(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glColor4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Color4fv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Deprecated->f.Color4f(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glColor4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Color4dv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
-{
-    d_1_0_Deprecated->f.Color4d(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glColor4bv(const GLbyte *v)
-{
-    d_1_0_Deprecated->f.Color4bv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
-{
-    d_1_0_Deprecated->f.Color4b(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glColor3usv(const GLushort *v)
-{
-    d_1_0_Deprecated->f.Color3usv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glColor3us(GLushort red, GLushort green, GLushort blue)
-{
-    d_1_0_Deprecated->f.Color3us(red, green, blue);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glColor3uiv(const GLuint *v)
-{
-    d_1_0_Deprecated->f.Color3uiv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glColor3ui(GLuint red, GLuint green, GLuint blue)
-{
-    d_1_0_Deprecated->f.Color3ui(red, green, blue);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glColor3ubv(const GLubyte *v)
-{
-    d_1_0_Deprecated->f.Color3ubv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
-{
-    d_1_0_Deprecated->f.Color3ub(red, green, blue);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glColor3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Color3sv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glColor3s(GLshort red, GLshort green, GLshort blue)
-{
-    d_1_0_Deprecated->f.Color3s(red, green, blue);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glColor3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Color3iv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glColor3i(GLint red, GLint green, GLint blue)
-{
-    d_1_0_Deprecated->f.Color3i(red, green, blue);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glColor3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Color3fv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glColor3f(GLfloat red, GLfloat green, GLfloat blue)
-{
-    d_1_0_Deprecated->f.Color3f(red, green, blue);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glColor3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Color3dv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glColor3d(GLdouble red, GLdouble green, GLdouble blue)
-{
-    d_1_0_Deprecated->f.Color3d(red, green, blue);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glColor3bv(const GLbyte *v)
-{
-    d_1_0_Deprecated->f.Color3bv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glColor3b(GLbyte red, GLbyte green, GLbyte blue)
-{
-    d_1_0_Deprecated->f.Color3b(red, green, blue);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
-{
-    d_1_0_Deprecated->f.Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glBegin(GLenum mode)
-{
-    d_1_0_Deprecated->f.Begin(mode);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glListBase(GLuint base)
-{
-    d_1_0_Deprecated->f.ListBase(base);
-}
-
-inline GLuint QOpenGLFunctions_3_3_Compatibility::glGenLists(GLsizei range)
-{
-    return d_1_0_Deprecated->f.GenLists(range);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glDeleteLists(GLuint list, GLsizei range)
-{
-    d_1_0_Deprecated->f.DeleteLists(list, range);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glCallLists(GLsizei n, GLenum type, const GLvoid *lists)
-{
-    d_1_0_Deprecated->f.CallLists(n, type, lists);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glCallList(GLuint list)
-{
-    d_1_0_Deprecated->f.CallList(list);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glEndList()
-{
-    d_1_0_Deprecated->f.EndList();
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glNewList(GLuint list, GLenum mode)
-{
-    d_1_0_Deprecated->f.NewList(list, mode);
-}
-
-
-// OpenGL 1.1 deprecated functions
-inline void QOpenGLFunctions_3_3_Compatibility::glPushClientAttrib(GLbitfield mask)
-{
-    d_1_1_Deprecated->f.PushClientAttrib(mask);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glPopClientAttrib()
-{
-    d_1_1_Deprecated->f.PopClientAttrib();
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities)
-{
-    d_1_1_Deprecated->f.PrioritizeTextures(n, textures, priorities);
-}
-
-inline GLboolean QOpenGLFunctions_3_3_Compatibility::glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
-{
-    return d_1_1_Deprecated->f.AreTexturesResident(n, textures, residences);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.VertexPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.TexCoordPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.NormalPointer(type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.InterleavedArrays(format, stride, pointer);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.IndexPointer(type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glEnableClientState(GLenum array)
-{
-    d_1_1_Deprecated->f.EnableClientState(array);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.EdgeFlagPointer(stride, pointer);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glDisableClientState(GLenum array)
-{
-    d_1_1_Deprecated->f.DisableClientState(array);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.ColorPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glArrayElement(GLint i)
-{
-    d_1_1_Deprecated->f.ArrayElement(i);
-}
-
-
-// OpenGL 1.2 deprecated functions
-inline void QOpenGLFunctions_3_3_Compatibility::glResetMinmax(GLenum target)
-{
-    d_1_2_Deprecated->f.ResetMinmax(target);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glResetHistogram(GLenum target)
-{
-    d_1_2_Deprecated->f.ResetHistogram(target);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMinmax(GLenum target, GLenum internalformat, GLboolean sink)
-{
-    d_1_2_Deprecated->f.Minmax(target, internalformat, sink);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
-{
-    d_1_2_Deprecated->f.Histogram(target, width, internalformat, sink);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetMinmaxParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetMinmaxParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
-{
-    d_1_2_Deprecated->f.GetMinmax(target, reset, format, type, values);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetHistogramParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetHistogramParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
-{
-    d_1_2_Deprecated->f.GetHistogram(target, reset, format, type, values);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column)
-{
-    d_1_2_Deprecated->f.SeparableFilter2D(target, internalformat, width, height, format, type, row, column);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span)
-{
-    d_1_2_Deprecated->f.GetSeparableFilter(target, format, type, row, column, span);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetConvolutionParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetConvolutionParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image)
-{
-    d_1_2_Deprecated->f.GetConvolutionFilter(target, format, type, image);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_2_Deprecated->f.CopyConvolutionFilter2D(target, internalformat, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
-{
-    d_1_2_Deprecated->f.CopyConvolutionFilter1D(target, internalformat, x, y, width);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glConvolutionParameteri(GLenum target, GLenum pname, GLint params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameteri(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameterf(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image)
-{
-    d_1_2_Deprecated->f.ConvolutionFilter2D(target, internalformat, width, height, format, type, image);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image)
-{
-    d_1_2_Deprecated->f.ConvolutionFilter1D(target, internalformat, width, format, type, image);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
-{
-    d_1_2_Deprecated->f.CopyColorSubTable(target, start, x, y, width);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data)
-{
-    d_1_2_Deprecated->f.ColorSubTable(target, start, count, format, type, data);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetColorTableParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetColorTableParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table)
-{
-    d_1_2_Deprecated->f.GetColorTable(target, format, type, table);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
-{
-    d_1_2_Deprecated->f.CopyColorTable(target, internalformat, x, y, width);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_2_Deprecated->f.ColorTableParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_2_Deprecated->f.ColorTableParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table)
-{
-    d_1_2_Deprecated->f.ColorTable(target, internalformat, width, format, type, table);
-}
-
-
-// OpenGL 1.3 deprecated functions
-inline void QOpenGLFunctions_3_3_Compatibility::glMultTransposeMatrixd(const GLdouble *m)
-{
-    d_1_3_Deprecated->f.MultTransposeMatrixd(m);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMultTransposeMatrixf(const GLfloat *m)
-{
-    d_1_3_Deprecated->f.MultTransposeMatrixf(m);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glLoadTransposeMatrixd(const GLdouble *m)
-{
-    d_1_3_Deprecated->f.LoadTransposeMatrixd(m);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glLoadTransposeMatrixf(const GLfloat *m)
-{
-    d_1_3_Deprecated->f.LoadTransposeMatrixf(m);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord4sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4sv(target, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4s(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord4iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4iv(target, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4i(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord4fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4fv(target, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4f(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord4dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4dv(target, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4d(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord3sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3sv(target, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3s(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord3iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3iv(target, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3i(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord3fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3fv(target, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3f(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord3dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3dv(target, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3d(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord2sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2sv(target, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord2s(GLenum target, GLshort s, GLshort t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2s(target, s, t);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord2iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2iv(target, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord2i(GLenum target, GLint s, GLint t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2i(target, s, t);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord2fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2fv(target, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2f(target, s, t);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord2dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2dv(target, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2d(target, s, t);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord1sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1sv(target, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord1s(GLenum target, GLshort s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1s(target, s);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord1iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1iv(target, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord1i(GLenum target, GLint s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1i(target, s);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord1fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1fv(target, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord1f(GLenum target, GLfloat s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1f(target, s);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord1dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1dv(target, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord1d(GLenum target, GLdouble s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1d(target, s);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glClientActiveTexture(GLenum texture)
-{
-    d_1_3_Deprecated->f.ClientActiveTexture(texture);
-}
-
-
-// OpenGL 1.4 deprecated functions
-inline void QOpenGLFunctions_3_3_Compatibility::glWindowPos3sv(const GLshort *v)
-{
-    d_1_4_Deprecated->f.WindowPos3sv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glWindowPos3s(GLshort x, GLshort y, GLshort z)
-{
-    d_1_4_Deprecated->f.WindowPos3s(x, y, z);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glWindowPos3iv(const GLint *v)
-{
-    d_1_4_Deprecated->f.WindowPos3iv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glWindowPos3i(GLint x, GLint y, GLint z)
-{
-    d_1_4_Deprecated->f.WindowPos3i(x, y, z);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glWindowPos3fv(const GLfloat *v)
-{
-    d_1_4_Deprecated->f.WindowPos3fv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glWindowPos3f(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_4_Deprecated->f.WindowPos3f(x, y, z);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glWindowPos3dv(const GLdouble *v)
-{
-    d_1_4_Deprecated->f.WindowPos3dv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glWindowPos3d(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_4_Deprecated->f.WindowPos3d(x, y, z);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glWindowPos2sv(const GLshort *v)
-{
-    d_1_4_Deprecated->f.WindowPos2sv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glWindowPos2s(GLshort x, GLshort y)
-{
-    d_1_4_Deprecated->f.WindowPos2s(x, y);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glWindowPos2iv(const GLint *v)
-{
-    d_1_4_Deprecated->f.WindowPos2iv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glWindowPos2i(GLint x, GLint y)
-{
-    d_1_4_Deprecated->f.WindowPos2i(x, y);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glWindowPos2fv(const GLfloat *v)
-{
-    d_1_4_Deprecated->f.WindowPos2fv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glWindowPos2f(GLfloat x, GLfloat y)
-{
-    d_1_4_Deprecated->f.WindowPos2f(x, y);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glWindowPos2dv(const GLdouble *v)
-{
-    d_1_4_Deprecated->f.WindowPos2dv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glWindowPos2d(GLdouble x, GLdouble y)
-{
-    d_1_4_Deprecated->f.WindowPos2d(x, y);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_4_Deprecated->f.SecondaryColorPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glSecondaryColor3usv(const GLushort *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3usv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glSecondaryColor3us(GLushort red, GLushort green, GLushort blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3us(red, green, blue);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glSecondaryColor3uiv(const GLuint *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3uiv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3ui(red, green, blue);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glSecondaryColor3ubv(const GLubyte *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3ubv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3ub(red, green, blue);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glSecondaryColor3sv(const GLshort *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3sv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glSecondaryColor3s(GLshort red, GLshort green, GLshort blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3s(red, green, blue);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glSecondaryColor3iv(const GLint *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3iv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glSecondaryColor3i(GLint red, GLint green, GLint blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3i(red, green, blue);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glSecondaryColor3fv(const GLfloat *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3fv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3f(red, green, blue);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glSecondaryColor3dv(const GLdouble *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3dv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3d(red, green, blue);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glSecondaryColor3bv(const GLbyte *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3bv(v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3b(red, green, blue);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glFogCoordPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_4_Deprecated->f.FogCoordPointer(type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glFogCoorddv(const GLdouble *coord)
-{
-    d_1_4_Deprecated->f.FogCoorddv(coord);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glFogCoordd(GLdouble coord)
-{
-    d_1_4_Deprecated->f.FogCoordd(coord);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glFogCoordfv(const GLfloat *coord)
-{
-    d_1_4_Deprecated->f.FogCoordfv(coord);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glFogCoordf(GLfloat coord)
-{
-    d_1_4_Deprecated->f.FogCoordf(coord);
-}
-
-
-// OpenGL 1.5 deprecated functions
-
-// OpenGL 2.0 deprecated functions
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4usv(GLuint index, const GLushort *v)
-{
-    d_2_0_Core->f.VertexAttrib4usv(index, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4uiv(GLuint index, const GLuint *v)
-{
-    d_2_0_Core->f.VertexAttrib4uiv(index, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4ubv(GLuint index, const GLubyte *v)
-{
-    d_2_0_Core->f.VertexAttrib4ubv(index, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4sv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib4sv(index, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
-{
-    d_2_0_Core->f.VertexAttrib4s(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4iv(GLuint index, const GLint *v)
-{
-    d_2_0_Core->f.VertexAttrib4iv(index, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4fv(GLuint index, const GLfloat *v)
-{
-    d_2_0_Core->f.VertexAttrib4fv(index, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    d_2_0_Core->f.VertexAttrib4f(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4dv(GLuint index, const GLdouble *v)
-{
-    d_2_0_Core->f.VertexAttrib4dv(index, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_2_0_Core->f.VertexAttrib4d(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4bv(GLuint index, const GLbyte *v)
-{
-    d_2_0_Core->f.VertexAttrib4bv(index, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4Nusv(GLuint index, const GLushort *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nusv(index, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4Nuiv(GLuint index, const GLuint *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nuiv(index, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4Nubv(GLuint index, const GLubyte *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nubv(index, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
-{
-    d_2_0_Core->f.VertexAttrib4Nub(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4Nsv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nsv(index, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4Niv(GLuint index, const GLint *v)
-{
-    d_2_0_Core->f.VertexAttrib4Niv(index, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4Nbv(GLuint index, const GLbyte *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nbv(index, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib3sv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib3sv(index, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
-{
-    d_2_0_Core->f.VertexAttrib3s(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib3fv(GLuint index, const GLfloat *v)
-{
-    d_2_0_Core->f.VertexAttrib3fv(index, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
-{
-    d_2_0_Core->f.VertexAttrib3f(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib3dv(GLuint index, const GLdouble *v)
-{
-    d_2_0_Core->f.VertexAttrib3dv(index, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
-{
-    d_2_0_Core->f.VertexAttrib3d(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib2sv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib2sv(index, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib2s(GLuint index, GLshort x, GLshort y)
-{
-    d_2_0_Core->f.VertexAttrib2s(index, x, y);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib2fv(GLuint index, const GLfloat *v)
-{
-    d_2_0_Core->f.VertexAttrib2fv(index, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
-{
-    d_2_0_Core->f.VertexAttrib2f(index, x, y);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib2dv(GLuint index, const GLdouble *v)
-{
-    d_2_0_Core->f.VertexAttrib2dv(index, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
-{
-    d_2_0_Core->f.VertexAttrib2d(index, x, y);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib1sv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib1sv(index, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib1s(GLuint index, GLshort x)
-{
-    d_2_0_Core->f.VertexAttrib1s(index, x);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib1fv(GLuint index, const GLfloat *v)
-{
-    d_2_0_Core->f.VertexAttrib1fv(index, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib1f(GLuint index, GLfloat x)
-{
-    d_2_0_Core->f.VertexAttrib1f(index, x);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib1dv(GLuint index, const GLdouble *v)
-{
-    d_2_0_Core->f.VertexAttrib1dv(index, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib1d(GLuint index, GLdouble x)
-{
-    d_2_0_Core->f.VertexAttrib1d(index, x);
-}
-
-
-// OpenGL 2.1 deprecated functions
-
-// OpenGL 3.0 deprecated functions
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI4usv(GLuint index, const GLushort *v)
-{
-    d_3_0_Core->f.VertexAttribI4usv(index, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI4ubv(GLuint index, const GLubyte *v)
-{
-    d_3_0_Core->f.VertexAttribI4ubv(index, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI4sv(GLuint index, const GLshort *v)
-{
-    d_3_0_Core->f.VertexAttribI4sv(index, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI4bv(GLuint index, const GLbyte *v)
-{
-    d_3_0_Core->f.VertexAttribI4bv(index, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI4uiv(GLuint index, const GLuint *v)
-{
-    d_3_0_Core->f.VertexAttribI4uiv(index, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI3uiv(GLuint index, const GLuint *v)
-{
-    d_3_0_Core->f.VertexAttribI3uiv(index, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI2uiv(GLuint index, const GLuint *v)
-{
-    d_3_0_Core->f.VertexAttribI2uiv(index, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI1uiv(GLuint index, const GLuint *v)
-{
-    d_3_0_Core->f.VertexAttribI1uiv(index, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI4iv(GLuint index, const GLint *v)
-{
-    d_3_0_Core->f.VertexAttribI4iv(index, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI3iv(GLuint index, const GLint *v)
-{
-    d_3_0_Core->f.VertexAttribI3iv(index, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI2iv(GLuint index, const GLint *v)
-{
-    d_3_0_Core->f.VertexAttribI2iv(index, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI1iv(GLuint index, const GLint *v)
-{
-    d_3_0_Core->f.VertexAttribI1iv(index, v);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
-{
-    d_3_0_Core->f.VertexAttribI4ui(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z)
-{
-    d_3_0_Core->f.VertexAttribI3ui(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI2ui(GLuint index, GLuint x, GLuint y)
-{
-    d_3_0_Core->f.VertexAttribI2ui(index, x, y);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI1ui(GLuint index, GLuint x)
-{
-    d_3_0_Core->f.VertexAttribI1ui(index, x);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
-{
-    d_3_0_Core->f.VertexAttribI4i(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI3i(GLuint index, GLint x, GLint y, GLint z)
-{
-    d_3_0_Core->f.VertexAttribI3i(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI2i(GLuint index, GLint x, GLint y)
-{
-    d_3_0_Core->f.VertexAttribI2i(index, x, y);
-}
-
-inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI1i(GLuint index, GLint x)
-{
-    d_3_0_Core->f.VertexAttribI1i(index, x);
-}
-
-
-// OpenGL 3.1 deprecated functions
-
-// OpenGL 3.2 deprecated functions
-
-// OpenGL 3.3 deprecated functions
-
-
-QT_END_NAMESPACE
-
-#endif // QT_NO_OPENGL && !QT_OPENGL_ES_2
-
-#endif
diff --git a/src/gui/opengl/qopenglfunctions_3_3_core.cpp b/src/gui/opengl/qopenglfunctions_3_3_core.cpp
deleted file mode 100644
index 277ad1eb14..0000000000
--- a/src/gui/opengl/qopenglfunctions_3_3_core.cpp
+++ /dev/null
@@ -1,224 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#include "qopenglfunctions_3_3_core.h"
-#include "qopenglcontext.h"
-
-QT_BEGIN_NAMESPACE
-
-/*!
-    \class QOpenGLFunctions_3_3_Core
-    \inmodule QtGui
-    \since 5.1
-    \wrapper
-    \brief The QOpenGLFunctions_3_3_Core class provides all functions for OpenGL 3.3 core profile.
-
-    This class is a wrapper for functions from OpenGL 3.3 core profile.
-    See reference pages on \l {http://www.opengl.org/sdk/docs/}{opengl.org}
-    for function documentation.
-
-    \sa QAbstractOpenGLFunctions
-*/
-
-QOpenGLFunctions_3_3_Core::QOpenGLFunctions_3_3_Core()
- : QAbstractOpenGLFunctions()
- , d_1_0_Core(nullptr)
- , d_1_1_Core(nullptr)
- , d_1_2_Core(nullptr)
- , d_1_3_Core(nullptr)
- , d_1_4_Core(nullptr)
- , d_1_5_Core(nullptr)
- , d_2_0_Core(nullptr)
- , d_2_1_Core(nullptr)
- , d_3_0_Core(nullptr)
- , d_3_1_Core(nullptr)
- , d_3_2_Core(nullptr)
- , d_3_3_Core(nullptr)
-{
-}
-
-QOpenGLFunctions_3_3_Core::~QOpenGLFunctions_3_3_Core()
-{
-    if (d_1_0_Core) {
-        d_1_0_Core->refs.deref();
-        Q_ASSERT(d_1_0_Core->refs.loadRelaxed());
-    }
-    if (d_1_1_Core) {
-        d_1_1_Core->refs.deref();
-        Q_ASSERT(d_1_1_Core->refs.loadRelaxed());
-    }
-    if (d_1_2_Core) {
-        d_1_2_Core->refs.deref();
-        Q_ASSERT(d_1_2_Core->refs.loadRelaxed());
-    }
-    if (d_1_3_Core) {
-        d_1_3_Core->refs.deref();
-        Q_ASSERT(d_1_3_Core->refs.loadRelaxed());
-    }
-    if (d_1_4_Core) {
-        d_1_4_Core->refs.deref();
-        Q_ASSERT(d_1_4_Core->refs.loadRelaxed());
-    }
-    if (d_1_5_Core) {
-        d_1_5_Core->refs.deref();
-        Q_ASSERT(d_1_5_Core->refs.loadRelaxed());
-    }
-    if (d_2_0_Core) {
-        d_2_0_Core->refs.deref();
-        Q_ASSERT(d_2_0_Core->refs.loadRelaxed());
-    }
-    if (d_2_1_Core) {
-        d_2_1_Core->refs.deref();
-        Q_ASSERT(d_2_1_Core->refs.loadRelaxed());
-    }
-    if (d_3_0_Core) {
-        d_3_0_Core->refs.deref();
-        Q_ASSERT(d_3_0_Core->refs.loadRelaxed());
-    }
-    if (d_3_1_Core) {
-        d_3_1_Core->refs.deref();
-        Q_ASSERT(d_3_1_Core->refs.loadRelaxed());
-    }
-    if (d_3_2_Core) {
-        d_3_2_Core->refs.deref();
-        Q_ASSERT(d_3_2_Core->refs.loadRelaxed());
-    }
-    if (d_3_3_Core) {
-        d_3_3_Core->refs.deref();
-        Q_ASSERT(d_3_3_Core->refs.loadRelaxed());
-    }
-}
-
-bool QOpenGLFunctions_3_3_Core::initializeOpenGLFunctions()
-{
-    if ( isInitialized() )
-        return true;
-
-    QOpenGLContext* context = QOpenGLContext::currentContext();
-
-    // If owned by a context object make sure it is current.
-    // Also check that current context is capable of resolving all needed functions
-    if (((owningContext() && owningContext() == context) || !owningContext())
-        && QOpenGLFunctions_3_3_Core::isContextCompatible(context))
-    {
-        // Associate with private implementation, creating if necessary
-        // Function pointers in the backends are resolved at creation time
-        QOpenGLVersionFunctionsBackend* d = nullptr;
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        d_1_3_Core = static_cast<QOpenGLFunctions_1_3_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        d_1_4_Core = static_cast<QOpenGLFunctions_1_4_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        d_1_5_Core = static_cast<QOpenGLFunctions_1_5_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        d_2_0_Core = static_cast<QOpenGLFunctions_2_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        d_2_1_Core = static_cast<QOpenGLFunctions_2_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        d_3_0_Core = static_cast<QOpenGLFunctions_3_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
-        d_3_1_Core = static_cast<QOpenGLFunctions_3_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
-        d_3_2_Core = static_cast<QOpenGLFunctions_3_2_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_CoreBackend::versionStatus());
-        d_3_3_Core = static_cast<QOpenGLFunctions_3_3_CoreBackend*>(d);
-        d->refs.ref();
-
-        QAbstractOpenGLFunctions::initializeOpenGLFunctions();
-    }
-    return isInitialized();
-}
-
-bool QOpenGLFunctions_3_3_Core::isContextCompatible(QOpenGLContext *context)
-{
-    Q_ASSERT(context);
-    QSurfaceFormat f = context->format();
-    const QPair<int, int> v = qMakePair(f.majorVersion(), f.minorVersion());
-    if (v < qMakePair(3, 3))
-        return false;
-
-    return true;
-}
-
-QOpenGLVersionProfile QOpenGLFunctions_3_3_Core::versionProfile()
-{
-    QOpenGLVersionProfile v;
-    v.setVersion(3, 3);
-    v.setProfile(QSurfaceFormat::CoreProfile);
-    return v;
-}
-
-QT_END_NAMESPACE
diff --git a/src/gui/opengl/qopenglfunctions_3_3_core.h b/src/gui/opengl/qopenglfunctions_3_3_core.h
deleted file mode 100644
index 47d54d717e..0000000000
--- a/src/gui/opengl/qopenglfunctions_3_3_core.h
+++ /dev/null
@@ -1,2141 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#ifndef QOPENGLVERSIONFUNCTIONS_3_3_CORE_H
-#define QOPENGLVERSIONFUNCTIONS_3_3_CORE_H
-
-#include <QtGui/qtguiglobal.h>
-
-#if !defined(QT_NO_OPENGL) && !defined(QT_OPENGL_ES_2)
-
-#include <QtGui/QOpenGLVersionFunctions>
-#include <QtGui/qopenglcontext.h>
-
-QT_BEGIN_NAMESPACE
-
-class Q_GUI_EXPORT QOpenGLFunctions_3_3_Core : public QAbstractOpenGLFunctions
-{
-public:
-    QOpenGLFunctions_3_3_Core();
-    ~QOpenGLFunctions_3_3_Core();
-
-    bool initializeOpenGLFunctions() override;
-
-    // OpenGL 1.0 core functions
-    void glViewport(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glDepthRange(GLdouble nearVal, GLdouble farVal);
-    GLboolean glIsEnabled(GLenum cap);
-    void glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params);
-    void glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params);
-    void glGetTexParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
-    const GLubyte * glGetString(GLenum name);
-    void glGetIntegerv(GLenum pname, GLint *params);
-    void glGetFloatv(GLenum pname, GLfloat *params);
-    GLenum glGetError();
-    void glGetDoublev(GLenum pname, GLdouble *params);
-    void glGetBooleanv(GLenum pname, GLboolean *params);
-    void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
-    void glReadBuffer(GLenum mode);
-    void glPixelStorei(GLenum pname, GLint param);
-    void glPixelStoref(GLenum pname, GLfloat param);
-    void glDepthFunc(GLenum func);
-    void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass);
-    void glStencilFunc(GLenum func, GLint ref, GLuint mask);
-    void glLogicOp(GLenum opcode);
-    void glBlendFunc(GLenum sfactor, GLenum dfactor);
-    void glFlush();
-    void glFinish();
-    void glEnable(GLenum cap);
-    void glDisable(GLenum cap);
-    void glDepthMask(GLboolean flag);
-    void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
-    void glStencilMask(GLuint mask);
-    void glClearDepth(GLdouble depth);
-    void glClearStencil(GLint s);
-    void glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glClear(GLbitfield mask);
-    void glDrawBuffer(GLenum mode);
-    void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glTexParameteri(GLenum target, GLenum pname, GLint param);
-    void glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glTexParameterf(GLenum target, GLenum pname, GLfloat param);
-    void glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glPolygonMode(GLenum face, GLenum mode);
-    void glPointSize(GLfloat size);
-    void glLineWidth(GLfloat width);
-    void glHint(GLenum target, GLenum mode);
-    void glFrontFace(GLenum mode);
-    void glCullFace(GLenum mode);
-
-    // OpenGL 1.1 core functions
-    void glIndexubv(const GLubyte *c);
-    void glIndexub(GLubyte c);
-    GLboolean glIsTexture(GLuint texture);
-    void glGenTextures(GLsizei n, GLuint *textures);
-    void glDeleteTextures(GLsizei n, const GLuint *textures);
-    void glBindTexture(GLenum target, GLuint texture);
-    void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
-    void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
-    void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
-    void glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
-    void glPolygonOffset(GLfloat factor, GLfloat units);
-    void glGetPointerv(GLenum pname, GLvoid* *params);
-    void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
-    void glDrawArrays(GLenum mode, GLint first, GLsizei count);
-
-    // OpenGL 1.2 core functions
-    void glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices);
-    void glBlendEquation(GLenum mode);
-    void glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-
-    // OpenGL 1.3 core functions
-    void glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img);
-    void glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glSampleCoverage(GLfloat value, GLboolean invert);
-    void glActiveTexture(GLenum texture);
-
-    // OpenGL 1.4 core functions
-    void glPointParameteriv(GLenum pname, const GLint *params);
-    void glPointParameteri(GLenum pname, GLint param);
-    void glPointParameterfv(GLenum pname, const GLfloat *params);
-    void glPointParameterf(GLenum pname, GLfloat param);
-    void glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount);
-    void glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount);
-    void glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
-
-    // OpenGL 1.5 core functions
-    void glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params);
-    void glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params);
-    GLboolean glUnmapBuffer(GLenum target);
-    GLvoid* glMapBuffer(GLenum target, GLenum access);
-    void glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data);
-    void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data);
-    void glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage);
-    GLboolean glIsBuffer(GLuint buffer);
-    void glGenBuffers(GLsizei n, GLuint *buffers);
-    void glDeleteBuffers(GLsizei n, const GLuint *buffers);
-    void glBindBuffer(GLenum target, GLuint buffer);
-    void glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params);
-    void glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params);
-    void glGetQueryiv(GLenum target, GLenum pname, GLint *params);
-    void glEndQuery(GLenum target);
-    void glBeginQuery(GLenum target, GLuint id);
-    GLboolean glIsQuery(GLuint id);
-    void glDeleteQueries(GLsizei n, const GLuint *ids);
-    void glGenQueries(GLsizei n, GLuint *ids);
-
-    // OpenGL 2.0 core functions
-    void glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer);
-    void glValidateProgram(GLuint program);
-    void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniform4iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform3iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform2iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform1iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform4fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform3fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform2fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform1fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
-    void glUniform3i(GLint location, GLint v0, GLint v1, GLint v2);
-    void glUniform2i(GLint location, GLint v0, GLint v1);
-    void glUniform1i(GLint location, GLint v0);
-    void glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
-    void glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
-    void glUniform2f(GLint location, GLfloat v0, GLfloat v1);
-    void glUniform1f(GLint location, GLfloat v0);
-    void glUseProgram(GLuint program);
-    void glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length);
-    void glLinkProgram(GLuint program);
-    GLboolean glIsShader(GLuint shader);
-    GLboolean glIsProgram(GLuint program);
-    void glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer);
-    void glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params);
-    void glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params);
-    void glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params);
-    void glGetUniformiv(GLuint program, GLint location, GLint *params);
-    void glGetUniformfv(GLuint program, GLint location, GLfloat *params);
-    GLint glGetUniformLocation(GLuint program, const GLchar *name);
-    void glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source);
-    void glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void glGetShaderiv(GLuint shader, GLenum pname, GLint *params);
-    void glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void glGetProgramiv(GLuint program, GLenum pname, GLint *params);
-    GLint glGetAttribLocation(GLuint program, const GLchar *name);
-    void glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj);
-    void glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
-    void glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
-    void glEnableVertexAttribArray(GLuint index);
-    void glDisableVertexAttribArray(GLuint index);
-    void glDetachShader(GLuint program, GLuint shader);
-    void glDeleteShader(GLuint shader);
-    void glDeleteProgram(GLuint program);
-    GLuint glCreateShader(GLenum type);
-    GLuint glCreateProgram();
-    void glCompileShader(GLuint shader);
-    void glBindAttribLocation(GLuint program, GLuint index, const GLchar *name);
-    void glAttachShader(GLuint program, GLuint shader);
-    void glStencilMaskSeparate(GLenum face, GLuint mask);
-    void glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask);
-    void glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);
-    void glDrawBuffers(GLsizei n, const GLenum *bufs);
-    void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha);
-
-    // OpenGL 2.1 core functions
-    void glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-
-    // OpenGL 3.0 core functions
-    GLboolean glIsVertexArray(GLuint array);
-    void glGenVertexArrays(GLsizei n, GLuint *arrays);
-    void glDeleteVertexArrays(GLsizei n, const GLuint *arrays);
-    void glBindVertexArray(GLuint array);
-    void glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length);
-    GLvoid* glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
-    void glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
-    void glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
-    void glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
-    void glGenerateMipmap(GLenum target);
-    void glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params);
-    void glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
-    void glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset);
-    void glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
-    void glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
-    GLenum glCheckFramebufferStatus(GLenum target);
-    void glGenFramebuffers(GLsizei n, GLuint *framebuffers);
-    void glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers);
-    void glBindFramebuffer(GLenum target, GLuint framebuffer);
-    GLboolean glIsFramebuffer(GLuint framebuffer);
-    void glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
-    void glGenRenderbuffers(GLsizei n, GLuint *renderbuffers);
-    void glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers);
-    void glBindRenderbuffer(GLenum target, GLuint renderbuffer);
-    GLboolean glIsRenderbuffer(GLuint renderbuffer);
-    const GLubyte * glGetStringi(GLenum name, GLuint index);
-    void glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
-    void glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value);
-    void glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value);
-    void glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value);
-    void glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params);
-    void glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params);
-    void glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params);
-    void glTexParameterIiv(GLenum target, GLenum pname, const GLint *params);
-    void glUniform4uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform3uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform2uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform1uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
-    void glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2);
-    void glUniform2ui(GLint location, GLuint v0, GLuint v1);
-    void glUniform1ui(GLint location, GLuint v0);
-    GLint glGetFragDataLocation(GLuint program, const GLchar *name);
-    void glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name);
-    void glGetUniformuiv(GLuint program, GLint location, GLuint *params);
-    void glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params);
-    void glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params);
-    void glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glEndConditionalRender();
-    void glBeginConditionalRender(GLuint id, GLenum mode);
-    void glClampColor(GLenum target, GLenum clamp);
-    void glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name);
-    void glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode);
-    void glBindBufferBase(GLenum target, GLuint index, GLuint buffer);
-    void glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
-    void glEndTransformFeedback();
-    void glBeginTransformFeedback(GLenum primitiveMode);
-    GLboolean glIsEnabledi(GLenum target, GLuint index);
-    void glDisablei(GLenum target, GLuint index);
-    void glEnablei(GLenum target, GLuint index);
-    void glGetIntegeri_v(GLenum target, GLuint index, GLint *data);
-    void glGetBooleani_v(GLenum target, GLuint index, GLboolean *data);
-    void glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a);
-
-    // OpenGL 3.1 core functions
-    void glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
-    void glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);
-    void glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName);
-    void glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params);
-    GLuint glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName);
-    void glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName);
-    void glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params);
-    void glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const *uniformNames, GLuint *uniformIndices);
-    void glPrimitiveRestartIndex(GLuint index);
-    void glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer);
-    void glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount);
-    void glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount);
-
-    // OpenGL 3.2 core functions
-    void glSampleMaski(GLuint index, GLbitfield mask);
-    void glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val);
-    void glTexImage3DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
-    void glTexImage2DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
-    void glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values);
-    void glGetInteger64v(GLenum pname, GLint64 *params);
-    void glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout);
-    GLenum glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout);
-    void glDeleteSync(GLsync sync);
-    GLboolean glIsSync(GLsync sync);
-    GLsync glFenceSync(GLenum condition, GLbitfield flags);
-    void glProvokingVertex(GLenum mode);
-    void glMultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount, const GLint *basevertex);
-    void glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount, GLint basevertex);
-    void glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex);
-    void glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex);
-    void glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level);
-    void glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params);
-    void glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data);
-
-    // OpenGL 3.3 core functions
-    void glVertexAttribP4uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glVertexAttribP3uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glVertexAttribP2uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glVertexAttribP1uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glSecondaryColorP3uiv(GLenum type, const GLuint *color);
-    void glSecondaryColorP3ui(GLenum type, GLuint color);
-    void glColorP4uiv(GLenum type, const GLuint *color);
-    void glColorP4ui(GLenum type, GLuint color);
-    void glColorP3uiv(GLenum type, const GLuint *color);
-    void glColorP3ui(GLenum type, GLuint color);
-    void glNormalP3uiv(GLenum type, const GLuint *coords);
-    void glNormalP3ui(GLenum type, GLuint coords);
-    void glMultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint *coords);
-    void glMultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords);
-    void glMultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint *coords);
-    void glMultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords);
-    void glMultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint *coords);
-    void glMultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords);
-    void glMultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint *coords);
-    void glMultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords);
-    void glTexCoordP4uiv(GLenum type, const GLuint *coords);
-    void glTexCoordP4ui(GLenum type, GLuint coords);
-    void glTexCoordP3uiv(GLenum type, const GLuint *coords);
-    void glTexCoordP3ui(GLenum type, GLuint coords);
-    void glTexCoordP2uiv(GLenum type, const GLuint *coords);
-    void glTexCoordP2ui(GLenum type, GLuint coords);
-    void glTexCoordP1uiv(GLenum type, const GLuint *coords);
-    void glTexCoordP1ui(GLenum type, GLuint coords);
-    void glVertexP4uiv(GLenum type, const GLuint *value);
-    void glVertexP4ui(GLenum type, GLuint value);
-    void glVertexP3uiv(GLenum type, const GLuint *value);
-    void glVertexP3ui(GLenum type, GLuint value);
-    void glVertexP2uiv(GLenum type, const GLuint *value);
-    void glVertexP2ui(GLenum type, GLuint value);
-    void glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params);
-    void glGetQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params);
-    void glQueryCounter(GLuint id, GLenum target);
-    void glGetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params);
-    void glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params);
-    void glGetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params);
-    void glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params);
-    void glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param);
-    void glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param);
-    void glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param);
-    void glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param);
-    void glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param);
-    void glSamplerParameteri(GLuint sampler, GLenum pname, GLint param);
-    void glBindSampler(GLuint unit, GLuint sampler);
-    GLboolean glIsSampler(GLuint sampler);
-    void glDeleteSamplers(GLsizei count, const GLuint *samplers);
-    void glGenSamplers(GLsizei count, GLuint *samplers);
-    GLint glGetFragDataIndex(GLuint program, const GLchar *name);
-    void glBindFragDataLocationIndexed(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name);
-    void glVertexAttribDivisor(GLuint index, GLuint divisor);
-
-private:
-    friend class QOpenGLContext;
-
-    static bool isContextCompatible(QOpenGLContext *context);
-    static QOpenGLVersionProfile versionProfile();
-
-    QOpenGLFunctions_1_0_CoreBackend* d_1_0_Core;
-    QOpenGLFunctions_1_1_CoreBackend* d_1_1_Core;
-    QOpenGLFunctions_1_2_CoreBackend* d_1_2_Core;
-    QOpenGLFunctions_1_3_CoreBackend* d_1_3_Core;
-    QOpenGLFunctions_1_4_CoreBackend* d_1_4_Core;
-    QOpenGLFunctions_1_5_CoreBackend* d_1_5_Core;
-    QOpenGLFunctions_2_0_CoreBackend* d_2_0_Core;
-    QOpenGLFunctions_2_1_CoreBackend* d_2_1_Core;
-    QOpenGLFunctions_3_0_CoreBackend* d_3_0_Core;
-    QOpenGLFunctions_3_1_CoreBackend* d_3_1_Core;
-    QOpenGLFunctions_3_2_CoreBackend* d_3_2_Core;
-    QOpenGLFunctions_3_3_CoreBackend* d_3_3_Core;
-};
-
-// OpenGL 1.0 core functions
-inline void QOpenGLFunctions_3_3_Core::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_0_Core->f.Viewport(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glDepthRange(GLdouble nearVal, GLdouble farVal)
-{
-    d_1_0_Core->f.DepthRange(nearVal, farVal);
-}
-
-inline GLboolean QOpenGLFunctions_3_3_Core::glIsEnabled(GLenum cap)
-{
-    return d_1_0_Core->f.IsEnabled(cap);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetTexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetTexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
-{
-    d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
-}
-
-inline const GLubyte * QOpenGLFunctions_3_3_Core::glGetString(GLenum name)
-{
-    return d_1_0_Core->f.GetString(name);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetIntegerv(GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetIntegerv(pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetFloatv(GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetFloatv(pname, params);
-}
-
-inline GLenum QOpenGLFunctions_3_3_Core::glGetError()
-{
-    return d_1_0_Core->f.GetError();
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetDoublev(GLenum pname, GLdouble *params)
-{
-    d_1_0_Core->f.GetDoublev(pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetBooleanv(GLenum pname, GLboolean *params)
-{
-    d_1_0_Core->f.GetBooleanv(pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
-{
-    d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glReadBuffer(GLenum mode)
-{
-    d_1_0_Core->f.ReadBuffer(mode);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glPixelStorei(GLenum pname, GLint param)
-{
-    d_1_0_Core->f.PixelStorei(pname, param);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glPixelStoref(GLenum pname, GLfloat param)
-{
-    d_1_0_Core->f.PixelStoref(pname, param);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glDepthFunc(GLenum func)
-{
-    d_1_0_Core->f.DepthFunc(func);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
-{
-    d_1_0_Core->f.StencilOp(fail, zfail, zpass);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glStencilFunc(GLenum func, GLint ref, GLuint mask)
-{
-    d_1_0_Core->f.StencilFunc(func, ref, mask);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glLogicOp(GLenum opcode)
-{
-    d_1_0_Core->f.LogicOp(opcode);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glBlendFunc(GLenum sfactor, GLenum dfactor)
-{
-    d_1_0_Core->f.BlendFunc(sfactor, dfactor);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glFlush()
-{
-    d_1_0_Core->f.Flush();
-}
-
-inline void QOpenGLFunctions_3_3_Core::glFinish()
-{
-    d_1_0_Core->f.Finish();
-}
-
-inline void QOpenGLFunctions_3_3_Core::glEnable(GLenum cap)
-{
-    d_1_0_Core->f.Enable(cap);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glDisable(GLenum cap)
-{
-    d_1_0_Core->f.Disable(cap);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glDepthMask(GLboolean flag)
-{
-    d_1_0_Core->f.DepthMask(flag);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
-{
-    d_1_0_Core->f.ColorMask(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glStencilMask(GLuint mask)
-{
-    d_1_0_Core->f.StencilMask(mask);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glClearDepth(GLdouble depth)
-{
-    d_1_0_Core->f.ClearDepth(depth);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glClearStencil(GLint s)
-{
-    d_1_0_Core->f.ClearStencil(s);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Core->f.ClearColor(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glClear(GLbitfield mask)
-{
-    d_1_0_Core->f.Clear(mask);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glDrawBuffer(GLenum mode)
-{
-    d_1_0_Core->f.DrawBuffer(mode);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Core->f.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Core->f.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_0_Core->f.TexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glTexParameteri(GLenum target, GLenum pname, GLint param)
-{
-    d_1_0_Core->f.TexParameteri(target, pname, param);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Core->f.TexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
-{
-    d_1_0_Core->f.TexParameterf(target, pname, param);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_0_Core->f.Scissor(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glPolygonMode(GLenum face, GLenum mode)
-{
-    d_1_0_Core->f.PolygonMode(face, mode);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glPointSize(GLfloat size)
-{
-    d_1_0_Core->f.PointSize(size);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glLineWidth(GLfloat width)
-{
-    d_1_0_Core->f.LineWidth(width);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glHint(GLenum target, GLenum mode)
-{
-    d_1_0_Core->f.Hint(target, mode);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glFrontFace(GLenum mode)
-{
-    d_1_0_Core->f.FrontFace(mode);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glCullFace(GLenum mode)
-{
-    d_1_0_Core->f.CullFace(mode);
-}
-
-
-// OpenGL 1.1 core functions
-inline void QOpenGLFunctions_3_3_Core::glIndexubv(const GLubyte *c)
-{
-    Q_UNUSED(c);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_3_3_Core::glIndexub(GLubyte c)
-{
-    Q_UNUSED(c);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline GLboolean QOpenGLFunctions_3_3_Core::glIsTexture(GLuint texture)
-{
-    return d_1_1_Core->f.IsTexture(texture);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGenTextures(GLsizei n, GLuint *textures)
-{
-    d_1_1_Core->f.GenTextures(n, textures);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glDeleteTextures(GLsizei n, const GLuint *textures)
-{
-    d_1_1_Core->f.DeleteTextures(n, textures);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glBindTexture(GLenum target, GLuint texture)
-{
-    d_1_1_Core->f.BindTexture(target, texture);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_1_Core->f.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_1_Core->f.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_1_Core->f.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
-{
-    d_1_1_Core->f.CopyTexSubImage1D(target, level, xoffset, x, y, width);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
-{
-    d_1_1_Core->f.CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
-{
-    d_1_1_Core->f.CopyTexImage1D(target, level, internalformat, x, y, width, border);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glPolygonOffset(GLfloat factor, GLfloat units)
-{
-    d_1_1_Core->f.PolygonOffset(factor, units);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetPointerv(GLenum pname, GLvoid* *params)
-{
-    Q_UNUSED(pname);
-    Q_UNUSED(params);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_3_3_Core::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
-{
-    d_1_1_Core->f.DrawElements(mode, count, type, indices);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glDrawArrays(GLenum mode, GLint first, GLsizei count)
-{
-    d_1_1_Core->f.DrawArrays(mode, first, count);
-}
-
-
-// OpenGL 1.2 core functions
-inline void QOpenGLFunctions_3_3_Core::glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_2_Core->f.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_2_Core->f.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_2_Core->f.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
-{
-    d_1_2_Core->f.DrawRangeElements(mode, start, end, count, type, indices);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glBlendEquation(GLenum mode)
-{
-    d_1_2_Core->f.BlendEquation(mode);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_2_Core->f.BlendColor(red, green, blue, alpha);
-}
-
-
-// OpenGL 1.3 core functions
-inline void QOpenGLFunctions_3_3_Core::glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img)
-{
-    d_1_3_Core->f.GetCompressedTexImage(target, level, img);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glSampleCoverage(GLfloat value, GLboolean invert)
-{
-    d_1_3_Core->f.SampleCoverage(value, invert);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glActiveTexture(GLenum texture)
-{
-    d_1_3_Core->f.ActiveTexture(texture);
-}
-
-
-// OpenGL 1.4 core functions
-inline void QOpenGLFunctions_3_3_Core::glPointParameteriv(GLenum pname, const GLint *params)
-{
-    d_1_4_Core->f.PointParameteriv(pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glPointParameteri(GLenum pname, GLint param)
-{
-    d_1_4_Core->f.PointParameteri(pname, param);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glPointParameterfv(GLenum pname, const GLfloat *params)
-{
-    d_1_4_Core->f.PointParameterfv(pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glPointParameterf(GLenum pname, GLfloat param)
-{
-    d_1_4_Core->f.PointParameterf(pname, param);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount)
-{
-    d_1_4_Core->f.MultiDrawElements(mode, count, type, indices, drawcount);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
-{
-    d_1_4_Core->f.MultiDrawArrays(mode, first, count, drawcount);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
-{
-    d_1_4_Core->f.BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
-}
-
-
-// OpenGL 1.5 core functions
-inline void QOpenGLFunctions_3_3_Core::glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params)
-{
-    d_1_5_Core->f.GetBufferPointerv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetBufferParameteriv(target, pname, params);
-}
-
-inline GLboolean QOpenGLFunctions_3_3_Core::glUnmapBuffer(GLenum target)
-{
-    return d_1_5_Core->f.UnmapBuffer(target);
-}
-
-inline GLvoid* QOpenGLFunctions_3_3_Core::glMapBuffer(GLenum target, GLenum access)
-{
-    return d_1_5_Core->f.MapBuffer(target, access);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data)
-{
-    d_1_5_Core->f.GetBufferSubData(target, offset, size, data);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data)
-{
-    d_1_5_Core->f.BufferSubData(target, offset, size, data);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)
-{
-    d_1_5_Core->f.BufferData(target, size, data, usage);
-}
-
-inline GLboolean QOpenGLFunctions_3_3_Core::glIsBuffer(GLuint buffer)
-{
-    return d_1_5_Core->f.IsBuffer(buffer);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGenBuffers(GLsizei n, GLuint *buffers)
-{
-    d_1_5_Core->f.GenBuffers(n, buffers);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glDeleteBuffers(GLsizei n, const GLuint *buffers)
-{
-    d_1_5_Core->f.DeleteBuffers(n, buffers);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glBindBuffer(GLenum target, GLuint buffer)
-{
-    d_1_5_Core->f.BindBuffer(target, buffer);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
-{
-    d_1_5_Core->f.GetQueryObjectuiv(id, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetQueryObjectiv(id, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetQueryiv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetQueryiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glEndQuery(GLenum target)
-{
-    d_1_5_Core->f.EndQuery(target);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glBeginQuery(GLenum target, GLuint id)
-{
-    d_1_5_Core->f.BeginQuery(target, id);
-}
-
-inline GLboolean QOpenGLFunctions_3_3_Core::glIsQuery(GLuint id)
-{
-    return d_1_5_Core->f.IsQuery(id);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glDeleteQueries(GLsizei n, const GLuint *ids)
-{
-    d_1_5_Core->f.DeleteQueries(n, ids);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGenQueries(GLsizei n, GLuint *ids)
-{
-    d_1_5_Core->f.GenQueries(n, ids);
-}
-
-
-// OpenGL 2.0 core functions
-inline void QOpenGLFunctions_3_3_Core::glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer)
-{
-    d_2_0_Core->f.VertexAttribPointer(index, size, type, normalized, stride, pointer);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glValidateProgram(GLuint program)
-{
-    d_2_0_Core->f.ValidateProgram(program);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix3fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glUniform4iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform4iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glUniform3iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform3iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glUniform2iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform2iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glUniform1iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform1iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glUniform4fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform4fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glUniform3fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform3fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glUniform2fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform2fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glUniform1fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform1fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
-{
-    d_2_0_Core->f.Uniform4i(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glUniform3i(GLint location, GLint v0, GLint v1, GLint v2)
-{
-    d_2_0_Core->f.Uniform3i(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glUniform2i(GLint location, GLint v0, GLint v1)
-{
-    d_2_0_Core->f.Uniform2i(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glUniform1i(GLint location, GLint v0)
-{
-    d_2_0_Core->f.Uniform1i(location, v0);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
-{
-    d_2_0_Core->f.Uniform4f(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
-{
-    d_2_0_Core->f.Uniform3f(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glUniform2f(GLint location, GLfloat v0, GLfloat v1)
-{
-    d_2_0_Core->f.Uniform2f(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glUniform1f(GLint location, GLfloat v0)
-{
-    d_2_0_Core->f.Uniform1f(location, v0);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glUseProgram(GLuint program)
-{
-    d_2_0_Core->f.UseProgram(program);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length)
-{
-    d_2_0_Core->f.ShaderSource(shader, count, string, length);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glLinkProgram(GLuint program)
-{
-    d_2_0_Core->f.LinkProgram(program);
-}
-
-inline GLboolean QOpenGLFunctions_3_3_Core::glIsShader(GLuint shader)
-{
-    return d_2_0_Core->f.IsShader(shader);
-}
-
-inline GLboolean QOpenGLFunctions_3_3_Core::glIsProgram(GLuint program)
-{
-    return d_2_0_Core->f.IsProgram(program);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer)
-{
-    d_2_0_Core->f.GetVertexAttribPointerv(index, pname, pointer);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetVertexAttribiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
-{
-    d_2_0_Core->f.GetVertexAttribfv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
-{
-    d_2_0_Core->f.GetVertexAttribdv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetUniformiv(GLuint program, GLint location, GLint *params)
-{
-    d_2_0_Core->f.GetUniformiv(program, location, params);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetUniformfv(GLuint program, GLint location, GLfloat *params)
-{
-    d_2_0_Core->f.GetUniformfv(program, location, params);
-}
-
-inline GLint QOpenGLFunctions_3_3_Core::glGetUniformLocation(GLuint program, const GLchar *name)
-{
-    return d_2_0_Core->f.GetUniformLocation(program, name);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
-{
-    d_2_0_Core->f.GetShaderSource(shader, bufSize, length, source);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-{
-    d_2_0_Core->f.GetShaderInfoLog(shader, bufSize, length, infoLog);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetShaderiv(GLuint shader, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetShaderiv(shader, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-{
-    d_2_0_Core->f.GetProgramInfoLog(program, bufSize, length, infoLog);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetProgramiv(GLuint program, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetProgramiv(program, pname, params);
-}
-
-inline GLint QOpenGLFunctions_3_3_Core::glGetAttribLocation(GLuint program, const GLchar *name)
-{
-    return d_2_0_Core->f.GetAttribLocation(program, name);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj)
-{
-    d_2_0_Core->f.GetAttachedShaders(program, maxCount, count, obj);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
-{
-    d_2_0_Core->f.GetActiveUniform(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
-{
-    d_2_0_Core->f.GetActiveAttrib(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glEnableVertexAttribArray(GLuint index)
-{
-    d_2_0_Core->f.EnableVertexAttribArray(index);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glDisableVertexAttribArray(GLuint index)
-{
-    d_2_0_Core->f.DisableVertexAttribArray(index);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glDetachShader(GLuint program, GLuint shader)
-{
-    d_2_0_Core->f.DetachShader(program, shader);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glDeleteShader(GLuint shader)
-{
-    d_2_0_Core->f.DeleteShader(shader);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glDeleteProgram(GLuint program)
-{
-    d_2_0_Core->f.DeleteProgram(program);
-}
-
-inline GLuint QOpenGLFunctions_3_3_Core::glCreateShader(GLenum type)
-{
-    return d_2_0_Core->f.CreateShader(type);
-}
-
-inline GLuint QOpenGLFunctions_3_3_Core::glCreateProgram()
-{
-    return d_2_0_Core->f.CreateProgram();
-}
-
-inline void QOpenGLFunctions_3_3_Core::glCompileShader(GLuint shader)
-{
-    d_2_0_Core->f.CompileShader(shader);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glBindAttribLocation(GLuint program, GLuint index, const GLchar *name)
-{
-    d_2_0_Core->f.BindAttribLocation(program, index, name);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glAttachShader(GLuint program, GLuint shader)
-{
-    d_2_0_Core->f.AttachShader(program, shader);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glStencilMaskSeparate(GLenum face, GLuint mask)
-{
-    d_2_0_Core->f.StencilMaskSeparate(face, mask);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
-{
-    d_2_0_Core->f.StencilFuncSeparate(face, func, ref, mask);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
-{
-    d_2_0_Core->f.StencilOpSeparate(face, sfail, dpfail, dppass);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glDrawBuffers(GLsizei n, const GLenum *bufs)
-{
-    d_2_0_Core->f.DrawBuffers(n, bufs);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
-{
-    d_2_0_Core->f.BlendEquationSeparate(modeRGB, modeAlpha);
-}
-
-
-// OpenGL 2.1 core functions
-inline void QOpenGLFunctions_3_3_Core::glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix4x3fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix3x4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix4x2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix2x4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix3x2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix2x3fv(location, count, transpose, value);
-}
-
-
-// OpenGL 3.0 core functions
-inline GLboolean QOpenGLFunctions_3_3_Core::glIsVertexArray(GLuint array)
-{
-    return d_3_0_Core->f.IsVertexArray(array);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGenVertexArrays(GLsizei n, GLuint *arrays)
-{
-    d_3_0_Core->f.GenVertexArrays(n, arrays);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glDeleteVertexArrays(GLsizei n, const GLuint *arrays)
-{
-    d_3_0_Core->f.DeleteVertexArrays(n, arrays);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glBindVertexArray(GLuint array)
-{
-    d_3_0_Core->f.BindVertexArray(array);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
-{
-    d_3_0_Core->f.FlushMappedBufferRange(target, offset, length);
-}
-
-inline GLvoid* QOpenGLFunctions_3_3_Core::glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
-{
-    return d_3_0_Core->f.MapBufferRange(target, offset, length, access);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
-{
-    d_3_0_Core->f.FramebufferTextureLayer(target, attachment, texture, level, layer);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    d_3_0_Core->f.RenderbufferStorageMultisample(target, samples, internalformat, width, height);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
-{
-    d_3_0_Core->f.BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGenerateMipmap(GLenum target)
-{
-    d_3_0_Core->f.GenerateMipmap(target);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
-{
-    d_3_0_Core->f.FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
-{
-    d_3_0_Core->f.FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
-{
-    d_3_0_Core->f.FramebufferTexture2D(target, attachment, textarget, texture, level);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
-{
-    d_3_0_Core->f.FramebufferTexture1D(target, attachment, textarget, texture, level);
-}
-
-inline GLenum QOpenGLFunctions_3_3_Core::glCheckFramebufferStatus(GLenum target)
-{
-    return d_3_0_Core->f.CheckFramebufferStatus(target);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGenFramebuffers(GLsizei n, GLuint *framebuffers)
-{
-    d_3_0_Core->f.GenFramebuffers(n, framebuffers);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
-{
-    d_3_0_Core->f.DeleteFramebuffers(n, framebuffers);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glBindFramebuffer(GLenum target, GLuint framebuffer)
-{
-    d_3_0_Core->f.BindFramebuffer(target, framebuffer);
-}
-
-inline GLboolean QOpenGLFunctions_3_3_Core::glIsFramebuffer(GLuint framebuffer)
-{
-    return d_3_0_Core->f.IsFramebuffer(framebuffer);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetRenderbufferParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    d_3_0_Core->f.RenderbufferStorage(target, internalformat, width, height);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGenRenderbuffers(GLsizei n, GLuint *renderbuffers)
-{
-    d_3_0_Core->f.GenRenderbuffers(n, renderbuffers);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
-{
-    d_3_0_Core->f.DeleteRenderbuffers(n, renderbuffers);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glBindRenderbuffer(GLenum target, GLuint renderbuffer)
-{
-    d_3_0_Core->f.BindRenderbuffer(target, renderbuffer);
-}
-
-inline GLboolean QOpenGLFunctions_3_3_Core::glIsRenderbuffer(GLuint renderbuffer)
-{
-    return d_3_0_Core->f.IsRenderbuffer(renderbuffer);
-}
-
-inline const GLubyte * QOpenGLFunctions_3_3_Core::glGetStringi(GLenum name, GLuint index)
-{
-    return d_3_0_Core->f.GetStringi(name, index);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
-{
-    d_3_0_Core->f.ClearBufferfi(buffer, drawbuffer, depth, stencil);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
-{
-    d_3_0_Core->f.ClearBufferfv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
-{
-    d_3_0_Core->f.ClearBufferuiv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
-{
-    d_3_0_Core->f.ClearBufferiv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params)
-{
-    d_3_0_Core->f.GetTexParameterIuiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetTexParameterIiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params)
-{
-    d_3_0_Core->f.TexParameterIuiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glTexParameterIiv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_3_0_Core->f.TexParameterIiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glUniform4uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform4uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glUniform3uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform3uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glUniform2uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform2uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glUniform1uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform1uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
-{
-    d_3_0_Core->f.Uniform4ui(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
-{
-    d_3_0_Core->f.Uniform3ui(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glUniform2ui(GLint location, GLuint v0, GLuint v1)
-{
-    d_3_0_Core->f.Uniform2ui(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glUniform1ui(GLint location, GLuint v0)
-{
-    d_3_0_Core->f.Uniform1ui(location, v0);
-}
-
-inline GLint QOpenGLFunctions_3_3_Core::glGetFragDataLocation(GLuint program, const GLchar *name)
-{
-    return d_3_0_Core->f.GetFragDataLocation(program, name);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name)
-{
-    d_3_0_Core->f.BindFragDataLocation(program, color, name);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetUniformuiv(GLuint program, GLint location, GLuint *params)
-{
-    d_3_0_Core->f.GetUniformuiv(program, location, params);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
-{
-    d_3_0_Core->f.GetVertexAttribIuiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetVertexAttribIiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_3_0_Core->f.VertexAttribIPointer(index, size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glEndConditionalRender()
-{
-    d_3_0_Core->f.EndConditionalRender();
-}
-
-inline void QOpenGLFunctions_3_3_Core::glBeginConditionalRender(GLuint id, GLenum mode)
-{
-    d_3_0_Core->f.BeginConditionalRender(id, mode);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glClampColor(GLenum target, GLenum clamp)
-{
-    d_3_0_Core->f.ClampColor(target, clamp);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
-{
-    d_3_0_Core->f.GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode)
-{
-    d_3_0_Core->f.TransformFeedbackVaryings(program, count, varyings, bufferMode);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
-{
-    d_3_0_Core->f.BindBufferBase(target, index, buffer);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
-{
-    d_3_0_Core->f.BindBufferRange(target, index, buffer, offset, size);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glEndTransformFeedback()
-{
-    d_3_0_Core->f.EndTransformFeedback();
-}
-
-inline void QOpenGLFunctions_3_3_Core::glBeginTransformFeedback(GLenum primitiveMode)
-{
-    d_3_0_Core->f.BeginTransformFeedback(primitiveMode);
-}
-
-inline GLboolean QOpenGLFunctions_3_3_Core::glIsEnabledi(GLenum target, GLuint index)
-{
-    return d_3_0_Core->f.IsEnabledi(target, index);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glDisablei(GLenum target, GLuint index)
-{
-    d_3_0_Core->f.Disablei(target, index);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glEnablei(GLenum target, GLuint index)
-{
-    d_3_0_Core->f.Enablei(target, index);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetIntegeri_v(GLenum target, GLuint index, GLint *data)
-{
-    d_3_0_Core->f.GetIntegeri_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetBooleani_v(GLenum target, GLuint index, GLboolean *data)
-{
-    d_3_0_Core->f.GetBooleani_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
-{
-    d_3_0_Core->f.ColorMaski(index, r, g, b, a);
-}
-
-
-// OpenGL 3.1 core functions
-inline void QOpenGLFunctions_3_3_Core::glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
-{
-    d_3_1_Core->f.CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
-{
-    d_3_1_Core->f.UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
-{
-    d_3_1_Core->f.GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params)
-{
-    d_3_1_Core->f.GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
-}
-
-inline GLuint QOpenGLFunctions_3_3_Core::glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName)
-{
-    return d_3_1_Core->f.GetUniformBlockIndex(program, uniformBlockName);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName)
-{
-    d_3_1_Core->f.GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params)
-{
-    d_3_1_Core->f.GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const *uniformNames, GLuint *uniformIndices)
-{
-    d_3_1_Core->f.GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glPrimitiveRestartIndex(GLuint index)
-{
-    d_3_1_Core->f.PrimitiveRestartIndex(index);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer)
-{
-    d_3_1_Core->f.TexBuffer(target, internalformat, buffer);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount)
-{
-    d_3_1_Core->f.DrawElementsInstanced(mode, count, type, indices, instancecount);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount)
-{
-    d_3_1_Core->f.DrawArraysInstanced(mode, first, count, instancecount);
-}
-
-
-// OpenGL 3.2 core functions
-inline void QOpenGLFunctions_3_3_Core::glSampleMaski(GLuint index, GLbitfield mask)
-{
-    d_3_2_Core->f.SampleMaski(index, mask);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val)
-{
-    d_3_2_Core->f.GetMultisamplefv(pname, index, val);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glTexImage3DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
-{
-    d_3_2_Core->f.TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glTexImage2DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
-{
-    d_3_2_Core->f.TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values)
-{
-    d_3_2_Core->f.GetSynciv(sync, pname, bufSize, length, values);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetInteger64v(GLenum pname, GLint64 *params)
-{
-    d_3_2_Core->f.GetInteger64v(pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
-{
-    d_3_2_Core->f.WaitSync(sync, flags, timeout);
-}
-
-inline GLenum QOpenGLFunctions_3_3_Core::glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
-{
-    return d_3_2_Core->f.ClientWaitSync(sync, flags, timeout);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glDeleteSync(GLsync sync)
-{
-    d_3_2_Core->f.DeleteSync(sync);
-}
-
-inline GLboolean QOpenGLFunctions_3_3_Core::glIsSync(GLsync sync)
-{
-    return d_3_2_Core->f.IsSync(sync);
-}
-
-inline GLsync QOpenGLFunctions_3_3_Core::glFenceSync(GLenum condition, GLbitfield flags)
-{
-    return d_3_2_Core->f.FenceSync(condition, flags);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glProvokingVertex(GLenum mode)
-{
-    d_3_2_Core->f.ProvokingVertex(mode);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glMultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount, const GLint *basevertex)
-{
-    d_3_2_Core->f.MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount, GLint basevertex)
-{
-    d_3_2_Core->f.DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)
-{
-    d_3_2_Core->f.DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)
-{
-    d_3_2_Core->f.DrawElementsBaseVertex(mode, count, type, indices, basevertex);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level)
-{
-    d_3_2_Core->f.FramebufferTexture(target, attachment, texture, level);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params)
-{
-    d_3_2_Core->f.GetBufferParameteri64v(target, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data)
-{
-    d_3_2_Core->f.GetInteger64i_v(target, index, data);
-}
-
-
-// OpenGL 3.3 core functions
-inline void QOpenGLFunctions_3_3_Core::glVertexAttribP4uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP4uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glVertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP4ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glVertexAttribP3uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP3uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glVertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP3ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glVertexAttribP2uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP2uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glVertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP2ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glVertexAttribP1uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP1uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glVertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP1ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glSecondaryColorP3uiv(GLenum type, const GLuint *color)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(color);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_3_3_Core::glSecondaryColorP3ui(GLenum type, GLuint color)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(color);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_3_3_Core::glColorP4uiv(GLenum type, const GLuint *color)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(color);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_3_3_Core::glColorP4ui(GLenum type, GLuint color)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(color);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_3_3_Core::glColorP3uiv(GLenum type, const GLuint *color)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(color);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_3_3_Core::glColorP3ui(GLenum type, GLuint color)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(color);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_3_3_Core::glNormalP3uiv(GLenum type, const GLuint *coords)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_3_3_Core::glNormalP3ui(GLenum type, GLuint coords)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_3_3_Core::glMultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint *coords)
-{
-    Q_UNUSED(texture);
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_3_3_Core::glMultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords)
-{
-    Q_UNUSED(texture);
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_3_3_Core::glMultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint *coords)
-{
-    Q_UNUSED(texture);
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_3_3_Core::glMultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords)
-{
-    Q_UNUSED(texture);
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_3_3_Core::glMultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint *coords)
-{
-    Q_UNUSED(texture);
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_3_3_Core::glMultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords)
-{
-    Q_UNUSED(texture);
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_3_3_Core::glMultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint *coords)
-{
-    Q_UNUSED(texture);
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_3_3_Core::glMultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords)
-{
-    Q_UNUSED(texture);
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_3_3_Core::glTexCoordP4uiv(GLenum type, const GLuint *coords)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_3_3_Core::glTexCoordP4ui(GLenum type, GLuint coords)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_3_3_Core::glTexCoordP3uiv(GLenum type, const GLuint *coords)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_3_3_Core::glTexCoordP3ui(GLenum type, GLuint coords)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_3_3_Core::glTexCoordP2uiv(GLenum type, const GLuint *coords)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_3_3_Core::glTexCoordP2ui(GLenum type, GLuint coords)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_3_3_Core::glTexCoordP1uiv(GLenum type, const GLuint *coords)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_3_3_Core::glTexCoordP1ui(GLenum type, GLuint coords)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_3_3_Core::glVertexP4uiv(GLenum type, const GLuint *value)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(value);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_3_3_Core::glVertexP4ui(GLenum type, GLuint value)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(value);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_3_3_Core::glVertexP3uiv(GLenum type, const GLuint *value)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(value);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_3_3_Core::glVertexP3ui(GLenum type, GLuint value)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(value);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_3_3_Core::glVertexP2uiv(GLenum type, const GLuint *value)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(value);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_3_3_Core::glVertexP2ui(GLenum type, GLuint value)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(value);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params)
-{
-    d_3_3_Core->f.GetQueryObjectui64v(id, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params)
-{
-    d_3_3_Core->f.GetQueryObjecti64v(id, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glQueryCounter(GLuint id, GLenum target)
-{
-    d_3_3_Core->f.QueryCounter(id, target);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params)
-{
-    d_3_3_Core->f.GetSamplerParameterIuiv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params)
-{
-    d_3_3_Core->f.GetSamplerParameterfv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params)
-{
-    d_3_3_Core->f.GetSamplerParameterIiv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params)
-{
-    d_3_3_Core->f.GetSamplerParameteriv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param)
-{
-    d_3_3_Core->f.SamplerParameterIuiv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param)
-{
-    d_3_3_Core->f.SamplerParameterIiv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param)
-{
-    d_3_3_Core->f.SamplerParameterfv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
-{
-    d_3_3_Core->f.SamplerParameterf(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param)
-{
-    d_3_3_Core->f.SamplerParameteriv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glSamplerParameteri(GLuint sampler, GLenum pname, GLint param)
-{
-    d_3_3_Core->f.SamplerParameteri(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glBindSampler(GLuint unit, GLuint sampler)
-{
-    d_3_3_Core->f.BindSampler(unit, sampler);
-}
-
-inline GLboolean QOpenGLFunctions_3_3_Core::glIsSampler(GLuint sampler)
-{
-    return d_3_3_Core->f.IsSampler(sampler);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glDeleteSamplers(GLsizei count, const GLuint *samplers)
-{
-    d_3_3_Core->f.DeleteSamplers(count, samplers);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glGenSamplers(GLsizei count, GLuint *samplers)
-{
-    d_3_3_Core->f.GenSamplers(count, samplers);
-}
-
-inline GLint QOpenGLFunctions_3_3_Core::glGetFragDataIndex(GLuint program, const GLchar *name)
-{
-    return d_3_3_Core->f.GetFragDataIndex(program, name);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glBindFragDataLocationIndexed(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name)
-{
-    d_3_3_Core->f.BindFragDataLocationIndexed(program, colorNumber, index, name);
-}
-
-inline void QOpenGLFunctions_3_3_Core::glVertexAttribDivisor(GLuint index, GLuint divisor)
-{
-    d_3_3_Core->f.VertexAttribDivisor(index, divisor);
-}
-
-
-
-QT_END_NAMESPACE
-
-#endif // QT_NO_OPENGL && !QT_OPENGL_ES_2
-
-#endif
diff --git a/src/gui/opengl/qopenglfunctions_4_0_compatibility.cpp b/src/gui/opengl/qopenglfunctions_4_0_compatibility.cpp
deleted file mode 100644
index 655f1e6fd4..0000000000
--- a/src/gui/opengl/qopenglfunctions_4_0_compatibility.cpp
+++ /dev/null
@@ -1,291 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#include "qopenglfunctions_4_0_compatibility.h"
-#include "qopenglcontext.h"
-
-QT_BEGIN_NAMESPACE
-
-/*!
-    \class QOpenGLFunctions_4_0_Compatibility
-    \inmodule QtGui
-    \since 5.1
-    \wrapper
-    \brief The QOpenGLFunctions_4_0_Compatibility class provides all functions for OpenGL 4.0 compatibility profile.
-
-    This class is a wrapper for functions from OpenGL 4.0 compatibility profile.
-    See reference pages on \l {http://www.opengl.org/sdk/docs/}{opengl.org}
-    for function documentation.
-
-    \sa QAbstractOpenGLFunctions
-*/
-
-QOpenGLFunctions_4_0_Compatibility::QOpenGLFunctions_4_0_Compatibility()
- : QAbstractOpenGLFunctions()
- , d_1_0_Core(nullptr)
- , d_1_1_Core(nullptr)
- , d_1_2_Core(nullptr)
- , d_1_3_Core(nullptr)
- , d_1_4_Core(nullptr)
- , d_1_5_Core(nullptr)
- , d_2_0_Core(nullptr)
- , d_2_1_Core(nullptr)
- , d_3_0_Core(nullptr)
- , d_3_1_Core(nullptr)
- , d_3_2_Core(nullptr)
- , d_3_3_Core(nullptr)
- , d_4_0_Core(nullptr)
- , d_1_0_Deprecated(nullptr)
- , d_1_1_Deprecated(nullptr)
- , d_1_2_Deprecated(nullptr)
- , d_1_3_Deprecated(nullptr)
- , d_1_4_Deprecated(nullptr)
- , m_reserved_2_0_Deprecated(nullptr)
- , d_3_3_Deprecated(nullptr)
-{
-}
-
-QOpenGLFunctions_4_0_Compatibility::~QOpenGLFunctions_4_0_Compatibility()
-{
-    if (d_1_0_Core) {
-        d_1_0_Core->refs.deref();
-        Q_ASSERT(d_1_0_Core->refs.loadRelaxed());
-    }
-    if (d_1_1_Core) {
-        d_1_1_Core->refs.deref();
-        Q_ASSERT(d_1_1_Core->refs.loadRelaxed());
-    }
-    if (d_1_2_Core) {
-        d_1_2_Core->refs.deref();
-        Q_ASSERT(d_1_2_Core->refs.loadRelaxed());
-    }
-    if (d_1_3_Core) {
-        d_1_3_Core->refs.deref();
-        Q_ASSERT(d_1_3_Core->refs.loadRelaxed());
-    }
-    if (d_1_4_Core) {
-        d_1_4_Core->refs.deref();
-        Q_ASSERT(d_1_4_Core->refs.loadRelaxed());
-    }
-    if (d_1_5_Core) {
-        d_1_5_Core->refs.deref();
-        Q_ASSERT(d_1_5_Core->refs.loadRelaxed());
-    }
-    if (d_2_0_Core) {
-        d_2_0_Core->refs.deref();
-        Q_ASSERT(d_2_0_Core->refs.loadRelaxed());
-    }
-    if (d_2_1_Core) {
-        d_2_1_Core->refs.deref();
-        Q_ASSERT(d_2_1_Core->refs.loadRelaxed());
-    }
-    if (d_3_0_Core) {
-        d_3_0_Core->refs.deref();
-        Q_ASSERT(d_3_0_Core->refs.loadRelaxed());
-    }
-    if (d_3_1_Core) {
-        d_3_1_Core->refs.deref();
-        Q_ASSERT(d_3_1_Core->refs.loadRelaxed());
-    }
-    if (d_3_2_Core) {
-        d_3_2_Core->refs.deref();
-        Q_ASSERT(d_3_2_Core->refs.loadRelaxed());
-    }
-    if (d_3_3_Core) {
-        d_3_3_Core->refs.deref();
-        Q_ASSERT(d_3_3_Core->refs.loadRelaxed());
-    }
-    if (d_4_0_Core) {
-        d_4_0_Core->refs.deref();
-        Q_ASSERT(d_4_0_Core->refs.loadRelaxed());
-    }
-    if (d_1_0_Deprecated) {
-        d_1_0_Deprecated->refs.deref();
-        Q_ASSERT(d_1_0_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_1_Deprecated) {
-        d_1_1_Deprecated->refs.deref();
-        Q_ASSERT(d_1_1_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_2_Deprecated) {
-        d_1_2_Deprecated->refs.deref();
-        Q_ASSERT(d_1_2_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_3_Deprecated) {
-        d_1_3_Deprecated->refs.deref();
-        Q_ASSERT(d_1_3_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_4_Deprecated) {
-        d_1_4_Deprecated->refs.deref();
-        Q_ASSERT(d_1_4_Deprecated->refs.loadRelaxed());
-    }
-    if (d_3_3_Deprecated) {
-        d_3_3_Deprecated->refs.deref();
-        Q_ASSERT(d_3_3_Deprecated->refs.loadRelaxed());
-    }
-}
-
-bool QOpenGLFunctions_4_0_Compatibility::initializeOpenGLFunctions()
-{
-    if ( isInitialized() )
-        return true;
-
-    QOpenGLContext* context = QOpenGLContext::currentContext();
-
-    // If owned by a context object make sure it is current.
-    // Also check that current context is capable of resolving all needed functions
-    if (((owningContext() && owningContext() == context) || !owningContext())
-        && QOpenGLFunctions_4_0_Compatibility::isContextCompatible(context))
-    {
-        // Associate with private implementation, creating if necessary
-        // Function pointers in the backends are resolved at creation time
-        QOpenGLVersionFunctionsBackend* d = nullptr;
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        d_1_3_Core = static_cast<QOpenGLFunctions_1_3_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        d_1_4_Core = static_cast<QOpenGLFunctions_1_4_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        d_1_5_Core = static_cast<QOpenGLFunctions_1_5_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        d_2_0_Core = static_cast<QOpenGLFunctions_2_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        d_2_1_Core = static_cast<QOpenGLFunctions_2_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        d_3_0_Core = static_cast<QOpenGLFunctions_3_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
-        d_3_1_Core = static_cast<QOpenGLFunctions_3_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
-        d_3_2_Core = static_cast<QOpenGLFunctions_3_2_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_CoreBackend::versionStatus());
-        d_3_3_Core = static_cast<QOpenGLFunctions_3_3_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_0_CoreBackend::versionStatus());
-        d_4_0_Core = static_cast<QOpenGLFunctions_4_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
-        d_1_0_Deprecated = static_cast<QOpenGLFunctions_1_0_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
-        d_1_1_Deprecated = static_cast<QOpenGLFunctions_1_1_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus());
-        d_1_2_Deprecated = static_cast<QOpenGLFunctions_1_2_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus());
-        d_1_3_Deprecated = static_cast<QOpenGLFunctions_1_3_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
-        d_1_4_Deprecated = static_cast<QOpenGLFunctions_1_4_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_DeprecatedBackend::versionStatus());
-        d_3_3_Deprecated = static_cast<QOpenGLFunctions_3_3_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        QAbstractOpenGLFunctions::initializeOpenGLFunctions();
-    }
-    return isInitialized();
-}
-
-bool QOpenGLFunctions_4_0_Compatibility::isContextCompatible(QOpenGLContext *context)
-{
-    Q_ASSERT(context);
-    QSurfaceFormat f = context->format();
-    const QPair<int, int> v = qMakePair(f.majorVersion(), f.minorVersion());
-    if (v < qMakePair(4, 0))
-        return false;
-
-    if (f.profile() == QSurfaceFormat::CoreProfile)
-        return false;
-
-    return true;
-}
-
-QOpenGLVersionProfile QOpenGLFunctions_4_0_Compatibility::versionProfile()
-{
-    QOpenGLVersionProfile v;
-    v.setVersion(4, 0);
-    v.setProfile(QSurfaceFormat::CompatibilityProfile);
-    return v;
-}
-
-QT_END_NAMESPACE
diff --git a/src/gui/opengl/qopenglfunctions_4_0_compatibility.h b/src/gui/opengl/qopenglfunctions_4_0_compatibility.h
deleted file mode 100644
index c0e42443d3..0000000000
--- a/src/gui/opengl/qopenglfunctions_4_0_compatibility.h
+++ /dev/null
@@ -1,5019 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#ifndef QOPENGLVERSIONFUNCTIONS_4_0_COMPATIBILITY_H
-#define QOPENGLVERSIONFUNCTIONS_4_0_COMPATIBILITY_H
-
-#include <QtGui/qtguiglobal.h>
-
-#if !defined(QT_NO_OPENGL) && !defined(QT_OPENGL_ES_2)
-
-#include <QtGui/QOpenGLVersionFunctions>
-#include <QtGui/qopenglcontext.h>
-
-QT_BEGIN_NAMESPACE
-
-class Q_GUI_EXPORT QOpenGLFunctions_4_0_Compatibility : public QAbstractOpenGLFunctions
-{
-public:
-    QOpenGLFunctions_4_0_Compatibility();
-    ~QOpenGLFunctions_4_0_Compatibility();
-
-    bool initializeOpenGLFunctions() override;
-
-    // OpenGL 1.0 core functions
-    void glViewport(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glDepthRange(GLdouble nearVal, GLdouble farVal);
-    GLboolean glIsEnabled(GLenum cap);
-    void glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params);
-    void glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params);
-    void glGetTexParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
-    const GLubyte * glGetString(GLenum name);
-    void glGetIntegerv(GLenum pname, GLint *params);
-    void glGetFloatv(GLenum pname, GLfloat *params);
-    GLenum glGetError();
-    void glGetDoublev(GLenum pname, GLdouble *params);
-    void glGetBooleanv(GLenum pname, GLboolean *params);
-    void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
-    void glReadBuffer(GLenum mode);
-    void glPixelStorei(GLenum pname, GLint param);
-    void glPixelStoref(GLenum pname, GLfloat param);
-    void glDepthFunc(GLenum func);
-    void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass);
-    void glStencilFunc(GLenum func, GLint ref, GLuint mask);
-    void glLogicOp(GLenum opcode);
-    void glBlendFunc(GLenum sfactor, GLenum dfactor);
-    void glFlush();
-    void glFinish();
-    void glEnable(GLenum cap);
-    void glDisable(GLenum cap);
-    void glDepthMask(GLboolean flag);
-    void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
-    void glStencilMask(GLuint mask);
-    void glClearDepth(GLdouble depth);
-    void glClearStencil(GLint s);
-    void glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glClear(GLbitfield mask);
-    void glDrawBuffer(GLenum mode);
-    void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glTexParameteri(GLenum target, GLenum pname, GLint param);
-    void glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glTexParameterf(GLenum target, GLenum pname, GLfloat param);
-    void glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glPolygonMode(GLenum face, GLenum mode);
-    void glPointSize(GLfloat size);
-    void glLineWidth(GLfloat width);
-    void glHint(GLenum target, GLenum mode);
-    void glFrontFace(GLenum mode);
-    void glCullFace(GLenum mode);
-
-    // OpenGL 1.1 core functions
-    void glIndexubv(const GLubyte *c);
-    void glIndexub(GLubyte c);
-    GLboolean glIsTexture(GLuint texture);
-    void glGenTextures(GLsizei n, GLuint *textures);
-    void glDeleteTextures(GLsizei n, const GLuint *textures);
-    void glBindTexture(GLenum target, GLuint texture);
-    void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
-    void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
-    void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
-    void glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
-    void glPolygonOffset(GLfloat factor, GLfloat units);
-    void glGetPointerv(GLenum pname, GLvoid* *params);
-    void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
-    void glDrawArrays(GLenum mode, GLint first, GLsizei count);
-
-    // OpenGL 1.2 core functions
-    void glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices);
-    void glBlendEquation(GLenum mode);
-    void glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-
-    // OpenGL 1.3 core functions
-    void glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img);
-    void glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glSampleCoverage(GLfloat value, GLboolean invert);
-    void glActiveTexture(GLenum texture);
-
-    // OpenGL 1.4 core functions
-    void glPointParameteriv(GLenum pname, const GLint *params);
-    void glPointParameteri(GLenum pname, GLint param);
-    void glPointParameterfv(GLenum pname, const GLfloat *params);
-    void glPointParameterf(GLenum pname, GLfloat param);
-    void glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount);
-    void glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount);
-    void glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
-
-    // OpenGL 1.5 core functions
-    void glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params);
-    void glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params);
-    GLboolean glUnmapBuffer(GLenum target);
-    GLvoid* glMapBuffer(GLenum target, GLenum access);
-    void glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data);
-    void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data);
-    void glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage);
-    GLboolean glIsBuffer(GLuint buffer);
-    void glGenBuffers(GLsizei n, GLuint *buffers);
-    void glDeleteBuffers(GLsizei n, const GLuint *buffers);
-    void glBindBuffer(GLenum target, GLuint buffer);
-    void glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params);
-    void glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params);
-    void glGetQueryiv(GLenum target, GLenum pname, GLint *params);
-    void glEndQuery(GLenum target);
-    void glBeginQuery(GLenum target, GLuint id);
-    GLboolean glIsQuery(GLuint id);
-    void glDeleteQueries(GLsizei n, const GLuint *ids);
-    void glGenQueries(GLsizei n, GLuint *ids);
-
-    // OpenGL 2.0 core functions
-    void glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer);
-    void glValidateProgram(GLuint program);
-    void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniform4iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform3iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform2iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform1iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform4fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform3fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform2fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform1fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
-    void glUniform3i(GLint location, GLint v0, GLint v1, GLint v2);
-    void glUniform2i(GLint location, GLint v0, GLint v1);
-    void glUniform1i(GLint location, GLint v0);
-    void glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
-    void glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
-    void glUniform2f(GLint location, GLfloat v0, GLfloat v1);
-    void glUniform1f(GLint location, GLfloat v0);
-    void glUseProgram(GLuint program);
-    void glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length);
-    void glLinkProgram(GLuint program);
-    GLboolean glIsShader(GLuint shader);
-    GLboolean glIsProgram(GLuint program);
-    void glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer);
-    void glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params);
-    void glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params);
-    void glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params);
-    void glGetUniformiv(GLuint program, GLint location, GLint *params);
-    void glGetUniformfv(GLuint program, GLint location, GLfloat *params);
-    GLint glGetUniformLocation(GLuint program, const GLchar *name);
-    void glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source);
-    void glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void glGetShaderiv(GLuint shader, GLenum pname, GLint *params);
-    void glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void glGetProgramiv(GLuint program, GLenum pname, GLint *params);
-    GLint glGetAttribLocation(GLuint program, const GLchar *name);
-    void glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj);
-    void glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
-    void glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
-    void glEnableVertexAttribArray(GLuint index);
-    void glDisableVertexAttribArray(GLuint index);
-    void glDetachShader(GLuint program, GLuint shader);
-    void glDeleteShader(GLuint shader);
-    void glDeleteProgram(GLuint program);
-    GLuint glCreateShader(GLenum type);
-    GLuint glCreateProgram();
-    void glCompileShader(GLuint shader);
-    void glBindAttribLocation(GLuint program, GLuint index, const GLchar *name);
-    void glAttachShader(GLuint program, GLuint shader);
-    void glStencilMaskSeparate(GLenum face, GLuint mask);
-    void glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask);
-    void glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);
-    void glDrawBuffers(GLsizei n, const GLenum *bufs);
-    void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha);
-
-    // OpenGL 2.1 core functions
-    void glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-
-    // OpenGL 3.0 core functions
-    GLboolean glIsVertexArray(GLuint array);
-    void glGenVertexArrays(GLsizei n, GLuint *arrays);
-    void glDeleteVertexArrays(GLsizei n, const GLuint *arrays);
-    void glBindVertexArray(GLuint array);
-    void glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length);
-    GLvoid* glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
-    void glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
-    void glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
-    void glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
-    void glGenerateMipmap(GLenum target);
-    void glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params);
-    void glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
-    void glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset);
-    void glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
-    void glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
-    GLenum glCheckFramebufferStatus(GLenum target);
-    void glGenFramebuffers(GLsizei n, GLuint *framebuffers);
-    void glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers);
-    void glBindFramebuffer(GLenum target, GLuint framebuffer);
-    GLboolean glIsFramebuffer(GLuint framebuffer);
-    void glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
-    void glGenRenderbuffers(GLsizei n, GLuint *renderbuffers);
-    void glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers);
-    void glBindRenderbuffer(GLenum target, GLuint renderbuffer);
-    GLboolean glIsRenderbuffer(GLuint renderbuffer);
-    const GLubyte * glGetStringi(GLenum name, GLuint index);
-    void glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
-    void glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value);
-    void glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value);
-    void glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value);
-    void glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params);
-    void glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params);
-    void glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params);
-    void glTexParameterIiv(GLenum target, GLenum pname, const GLint *params);
-    void glUniform4uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform3uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform2uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform1uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
-    void glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2);
-    void glUniform2ui(GLint location, GLuint v0, GLuint v1);
-    void glUniform1ui(GLint location, GLuint v0);
-    GLint glGetFragDataLocation(GLuint program, const GLchar *name);
-    void glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name);
-    void glGetUniformuiv(GLuint program, GLint location, GLuint *params);
-    void glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params);
-    void glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params);
-    void glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glEndConditionalRender();
-    void glBeginConditionalRender(GLuint id, GLenum mode);
-    void glClampColor(GLenum target, GLenum clamp);
-    void glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name);
-    void glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode);
-    void glBindBufferBase(GLenum target, GLuint index, GLuint buffer);
-    void glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
-    void glEndTransformFeedback();
-    void glBeginTransformFeedback(GLenum primitiveMode);
-    GLboolean glIsEnabledi(GLenum target, GLuint index);
-    void glDisablei(GLenum target, GLuint index);
-    void glEnablei(GLenum target, GLuint index);
-    void glGetIntegeri_v(GLenum target, GLuint index, GLint *data);
-    void glGetBooleani_v(GLenum target, GLuint index, GLboolean *data);
-    void glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a);
-
-    // OpenGL 3.1 core functions
-    void glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
-    void glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);
-    void glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName);
-    void glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params);
-    GLuint glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName);
-    void glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName);
-    void glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params);
-    void glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const *uniformNames, GLuint *uniformIndices);
-    void glPrimitiveRestartIndex(GLuint index);
-    void glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer);
-    void glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount);
-    void glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount);
-
-    // OpenGL 3.2 core functions
-    void glSampleMaski(GLuint index, GLbitfield mask);
-    void glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val);
-    void glTexImage3DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
-    void glTexImage2DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
-    void glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values);
-    void glGetInteger64v(GLenum pname, GLint64 *params);
-    void glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout);
-    GLenum glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout);
-    void glDeleteSync(GLsync sync);
-    GLboolean glIsSync(GLsync sync);
-    GLsync glFenceSync(GLenum condition, GLbitfield flags);
-    void glProvokingVertex(GLenum mode);
-    void glMultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount, const GLint *basevertex);
-    void glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount, GLint basevertex);
-    void glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex);
-    void glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex);
-    void glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level);
-    void glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params);
-    void glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data);
-
-    // OpenGL 3.3 core functions
-    void glVertexAttribP4uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glVertexAttribP3uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glVertexAttribP2uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glVertexAttribP1uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glSecondaryColorP3uiv(GLenum type, const GLuint *color);
-    void glSecondaryColorP3ui(GLenum type, GLuint color);
-    void glColorP4uiv(GLenum type, const GLuint *color);
-    void glColorP4ui(GLenum type, GLuint color);
-    void glColorP3uiv(GLenum type, const GLuint *color);
-    void glColorP3ui(GLenum type, GLuint color);
-    void glNormalP3uiv(GLenum type, const GLuint *coords);
-    void glNormalP3ui(GLenum type, GLuint coords);
-    void glMultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint *coords);
-    void glMultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords);
-    void glMultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint *coords);
-    void glMultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords);
-    void glMultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint *coords);
-    void glMultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords);
-    void glMultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint *coords);
-    void glMultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords);
-    void glTexCoordP4uiv(GLenum type, const GLuint *coords);
-    void glTexCoordP4ui(GLenum type, GLuint coords);
-    void glTexCoordP3uiv(GLenum type, const GLuint *coords);
-    void glTexCoordP3ui(GLenum type, GLuint coords);
-    void glTexCoordP2uiv(GLenum type, const GLuint *coords);
-    void glTexCoordP2ui(GLenum type, GLuint coords);
-    void glTexCoordP1uiv(GLenum type, const GLuint *coords);
-    void glTexCoordP1ui(GLenum type, GLuint coords);
-    void glVertexP4uiv(GLenum type, const GLuint *value);
-    void glVertexP4ui(GLenum type, GLuint value);
-    void glVertexP3uiv(GLenum type, const GLuint *value);
-    void glVertexP3ui(GLenum type, GLuint value);
-    void glVertexP2uiv(GLenum type, const GLuint *value);
-    void glVertexP2ui(GLenum type, GLuint value);
-    void glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params);
-    void glGetQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params);
-    void glQueryCounter(GLuint id, GLenum target);
-    void glGetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params);
-    void glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params);
-    void glGetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params);
-    void glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params);
-    void glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param);
-    void glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param);
-    void glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param);
-    void glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param);
-    void glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param);
-    void glSamplerParameteri(GLuint sampler, GLenum pname, GLint param);
-    void glBindSampler(GLuint unit, GLuint sampler);
-    GLboolean glIsSampler(GLuint sampler);
-    void glDeleteSamplers(GLsizei count, const GLuint *samplers);
-    void glGenSamplers(GLsizei count, GLuint *samplers);
-    GLint glGetFragDataIndex(GLuint program, const GLchar *name);
-    void glBindFragDataLocationIndexed(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name);
-    void glVertexAttribDivisor(GLuint index, GLuint divisor);
-
-    // OpenGL 4.0 core functions
-    void glGetQueryIndexediv(GLenum target, GLuint index, GLenum pname, GLint *params);
-    void glEndQueryIndexed(GLenum target, GLuint index);
-    void glBeginQueryIndexed(GLenum target, GLuint index, GLuint id);
-    void glDrawTransformFeedbackStream(GLenum mode, GLuint id, GLuint stream);
-    void glDrawTransformFeedback(GLenum mode, GLuint id);
-    void glResumeTransformFeedback();
-    void glPauseTransformFeedback();
-    GLboolean glIsTransformFeedback(GLuint id);
-    void glGenTransformFeedbacks(GLsizei n, GLuint *ids);
-    void glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids);
-    void glBindTransformFeedback(GLenum target, GLuint id);
-    void glPatchParameterfv(GLenum pname, const GLfloat *values);
-    void glPatchParameteri(GLenum pname, GLint value);
-    void glGetProgramStageiv(GLuint program, GLenum shadertype, GLenum pname, GLint *values);
-    void glGetUniformSubroutineuiv(GLenum shadertype, GLint location, GLuint *params);
-    void glUniformSubroutinesuiv(GLenum shadertype, GLsizei count, const GLuint *indices);
-    void glGetActiveSubroutineName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name);
-    void glGetActiveSubroutineUniformName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name);
-    void glGetActiveSubroutineUniformiv(GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values);
-    GLuint glGetSubroutineIndex(GLuint program, GLenum shadertype, const GLchar *name);
-    GLint glGetSubroutineUniformLocation(GLuint program, GLenum shadertype, const GLchar *name);
-    void glGetUniformdv(GLuint program, GLint location, GLdouble *params);
-    void glUniformMatrix4x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix4x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix3x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix3x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix2x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix2x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniform4dv(GLint location, GLsizei count, const GLdouble *value);
-    void glUniform3dv(GLint location, GLsizei count, const GLdouble *value);
-    void glUniform2dv(GLint location, GLsizei count, const GLdouble *value);
-    void glUniform1dv(GLint location, GLsizei count, const GLdouble *value);
-    void glUniform4d(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glUniform3d(GLint location, GLdouble x, GLdouble y, GLdouble z);
-    void glUniform2d(GLint location, GLdouble x, GLdouble y);
-    void glUniform1d(GLint location, GLdouble x);
-    void glDrawElementsIndirect(GLenum mode, GLenum type, const GLvoid *indirect);
-    void glDrawArraysIndirect(GLenum mode, const GLvoid *indirect);
-    void glBlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
-    void glBlendFunci(GLuint buf, GLenum src, GLenum dst);
-    void glBlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha);
-    void glBlendEquationi(GLuint buf, GLenum mode);
-    void glMinSampleShading(GLfloat value);
-
-    // OpenGL 1.0 deprecated functions
-    void glTranslatef(GLfloat x, GLfloat y, GLfloat z);
-    void glTranslated(GLdouble x, GLdouble y, GLdouble z);
-    void glScalef(GLfloat x, GLfloat y, GLfloat z);
-    void glScaled(GLdouble x, GLdouble y, GLdouble z);
-    void glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
-    void glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
-    void glPushMatrix();
-    void glPopMatrix();
-    void glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
-    void glMultMatrixd(const GLdouble *m);
-    void glMultMatrixf(const GLfloat *m);
-    void glMatrixMode(GLenum mode);
-    void glLoadMatrixd(const GLdouble *m);
-    void glLoadMatrixf(const GLfloat *m);
-    void glLoadIdentity();
-    void glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
-    GLboolean glIsList(GLuint list);
-    void glGetTexGeniv(GLenum coord, GLenum pname, GLint *params);
-    void glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params);
-    void glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params);
-    void glGetTexEnviv(GLenum target, GLenum pname, GLint *params);
-    void glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetPolygonStipple(GLubyte *mask);
-    void glGetPixelMapusv(GLenum map, GLushort *values);
-    void glGetPixelMapuiv(GLenum map, GLuint *values);
-    void glGetPixelMapfv(GLenum map, GLfloat *values);
-    void glGetMaterialiv(GLenum face, GLenum pname, GLint *params);
-    void glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params);
-    void glGetMapiv(GLenum target, GLenum query, GLint *v);
-    void glGetMapfv(GLenum target, GLenum query, GLfloat *v);
-    void glGetMapdv(GLenum target, GLenum query, GLdouble *v);
-    void glGetLightiv(GLenum light, GLenum pname, GLint *params);
-    void glGetLightfv(GLenum light, GLenum pname, GLfloat *params);
-    void glGetClipPlane(GLenum plane, GLdouble *equation);
-    void glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
-    void glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
-    void glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values);
-    void glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values);
-    void glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values);
-    void glPixelTransferi(GLenum pname, GLint param);
-    void glPixelTransferf(GLenum pname, GLfloat param);
-    void glPixelZoom(GLfloat xfactor, GLfloat yfactor);
-    void glAlphaFunc(GLenum func, GLfloat ref);
-    void glEvalPoint2(GLint i, GLint j);
-    void glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
-    void glEvalPoint1(GLint i);
-    void glEvalMesh1(GLenum mode, GLint i1, GLint i2);
-    void glEvalCoord2fv(const GLfloat *u);
-    void glEvalCoord2f(GLfloat u, GLfloat v);
-    void glEvalCoord2dv(const GLdouble *u);
-    void glEvalCoord2d(GLdouble u, GLdouble v);
-    void glEvalCoord1fv(const GLfloat *u);
-    void glEvalCoord1f(GLfloat u);
-    void glEvalCoord1dv(const GLdouble *u);
-    void glEvalCoord1d(GLdouble u);
-    void glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
-    void glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
-    void glMapGrid1f(GLint un, GLfloat u1, GLfloat u2);
-    void glMapGrid1d(GLint un, GLdouble u1, GLdouble u2);
-    void glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);
-    void glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);
-    void glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);
-    void glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);
-    void glPushAttrib(GLbitfield mask);
-    void glPopAttrib();
-    void glAccum(GLenum op, GLfloat value);
-    void glIndexMask(GLuint mask);
-    void glClearIndex(GLfloat c);
-    void glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glPushName(GLuint name);
-    void glPopName();
-    void glPassThrough(GLfloat token);
-    void glLoadName(GLuint name);
-    void glInitNames();
-    GLint glRenderMode(GLenum mode);
-    void glSelectBuffer(GLsizei size, GLuint *buffer);
-    void glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer);
-    void glTexGeniv(GLenum coord, GLenum pname, const GLint *params);
-    void glTexGeni(GLenum coord, GLenum pname, GLint param);
-    void glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params);
-    void glTexGenf(GLenum coord, GLenum pname, GLfloat param);
-    void glTexGendv(GLenum coord, GLenum pname, const GLdouble *params);
-    void glTexGend(GLenum coord, GLenum pname, GLdouble param);
-    void glTexEnviv(GLenum target, GLenum pname, const GLint *params);
-    void glTexEnvi(GLenum target, GLenum pname, GLint param);
-    void glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glTexEnvf(GLenum target, GLenum pname, GLfloat param);
-    void glShadeModel(GLenum mode);
-    void glPolygonStipple(const GLubyte *mask);
-    void glMaterialiv(GLenum face, GLenum pname, const GLint *params);
-    void glMateriali(GLenum face, GLenum pname, GLint param);
-    void glMaterialfv(GLenum face, GLenum pname, const GLfloat *params);
-    void glMaterialf(GLenum face, GLenum pname, GLfloat param);
-    void glLineStipple(GLint factor, GLushort pattern);
-    void glLightModeliv(GLenum pname, const GLint *params);
-    void glLightModeli(GLenum pname, GLint param);
-    void glLightModelfv(GLenum pname, const GLfloat *params);
-    void glLightModelf(GLenum pname, GLfloat param);
-    void glLightiv(GLenum light, GLenum pname, const GLint *params);
-    void glLighti(GLenum light, GLenum pname, GLint param);
-    void glLightfv(GLenum light, GLenum pname, const GLfloat *params);
-    void glLightf(GLenum light, GLenum pname, GLfloat param);
-    void glFogiv(GLenum pname, const GLint *params);
-    void glFogi(GLenum pname, GLint param);
-    void glFogfv(GLenum pname, const GLfloat *params);
-    void glFogf(GLenum pname, GLfloat param);
-    void glColorMaterial(GLenum face, GLenum mode);
-    void glClipPlane(GLenum plane, const GLdouble *equation);
-    void glVertex4sv(const GLshort *v);
-    void glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w);
-    void glVertex4iv(const GLint *v);
-    void glVertex4i(GLint x, GLint y, GLint z, GLint w);
-    void glVertex4fv(const GLfloat *v);
-    void glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void glVertex4dv(const GLdouble *v);
-    void glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glVertex3sv(const GLshort *v);
-    void glVertex3s(GLshort x, GLshort y, GLshort z);
-    void glVertex3iv(const GLint *v);
-    void glVertex3i(GLint x, GLint y, GLint z);
-    void glVertex3fv(const GLfloat *v);
-    void glVertex3f(GLfloat x, GLfloat y, GLfloat z);
-    void glVertex3dv(const GLdouble *v);
-    void glVertex3d(GLdouble x, GLdouble y, GLdouble z);
-    void glVertex2sv(const GLshort *v);
-    void glVertex2s(GLshort x, GLshort y);
-    void glVertex2iv(const GLint *v);
-    void glVertex2i(GLint x, GLint y);
-    void glVertex2fv(const GLfloat *v);
-    void glVertex2f(GLfloat x, GLfloat y);
-    void glVertex2dv(const GLdouble *v);
-    void glVertex2d(GLdouble x, GLdouble y);
-    void glTexCoord4sv(const GLshort *v);
-    void glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q);
-    void glTexCoord4iv(const GLint *v);
-    void glTexCoord4i(GLint s, GLint t, GLint r, GLint q);
-    void glTexCoord4fv(const GLfloat *v);
-    void glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
-    void glTexCoord4dv(const GLdouble *v);
-    void glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q);
-    void glTexCoord3sv(const GLshort *v);
-    void glTexCoord3s(GLshort s, GLshort t, GLshort r);
-    void glTexCoord3iv(const GLint *v);
-    void glTexCoord3i(GLint s, GLint t, GLint r);
-    void glTexCoord3fv(const GLfloat *v);
-    void glTexCoord3f(GLfloat s, GLfloat t, GLfloat r);
-    void glTexCoord3dv(const GLdouble *v);
-    void glTexCoord3d(GLdouble s, GLdouble t, GLdouble r);
-    void glTexCoord2sv(const GLshort *v);
-    void glTexCoord2s(GLshort s, GLshort t);
-    void glTexCoord2iv(const GLint *v);
-    void glTexCoord2i(GLint s, GLint t);
-    void glTexCoord2fv(const GLfloat *v);
-    void glTexCoord2f(GLfloat s, GLfloat t);
-    void glTexCoord2dv(const GLdouble *v);
-    void glTexCoord2d(GLdouble s, GLdouble t);
-    void glTexCoord1sv(const GLshort *v);
-    void glTexCoord1s(GLshort s);
-    void glTexCoord1iv(const GLint *v);
-    void glTexCoord1i(GLint s);
-    void glTexCoord1fv(const GLfloat *v);
-    void glTexCoord1f(GLfloat s);
-    void glTexCoord1dv(const GLdouble *v);
-    void glTexCoord1d(GLdouble s);
-    void glRectsv(const GLshort *v1, const GLshort *v2);
-    void glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
-    void glRectiv(const GLint *v1, const GLint *v2);
-    void glRecti(GLint x1, GLint y1, GLint x2, GLint y2);
-    void glRectfv(const GLfloat *v1, const GLfloat *v2);
-    void glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
-    void glRectdv(const GLdouble *v1, const GLdouble *v2);
-    void glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
-    void glRasterPos4sv(const GLshort *v);
-    void glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w);
-    void glRasterPos4iv(const GLint *v);
-    void glRasterPos4i(GLint x, GLint y, GLint z, GLint w);
-    void glRasterPos4fv(const GLfloat *v);
-    void glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void glRasterPos4dv(const GLdouble *v);
-    void glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glRasterPos3sv(const GLshort *v);
-    void glRasterPos3s(GLshort x, GLshort y, GLshort z);
-    void glRasterPos3iv(const GLint *v);
-    void glRasterPos3i(GLint x, GLint y, GLint z);
-    void glRasterPos3fv(const GLfloat *v);
-    void glRasterPos3f(GLfloat x, GLfloat y, GLfloat z);
-    void glRasterPos3dv(const GLdouble *v);
-    void glRasterPos3d(GLdouble x, GLdouble y, GLdouble z);
-    void glRasterPos2sv(const GLshort *v);
-    void glRasterPos2s(GLshort x, GLshort y);
-    void glRasterPos2iv(const GLint *v);
-    void glRasterPos2i(GLint x, GLint y);
-    void glRasterPos2fv(const GLfloat *v);
-    void glRasterPos2f(GLfloat x, GLfloat y);
-    void glRasterPos2dv(const GLdouble *v);
-    void glRasterPos2d(GLdouble x, GLdouble y);
-    void glNormal3sv(const GLshort *v);
-    void glNormal3s(GLshort nx, GLshort ny, GLshort nz);
-    void glNormal3iv(const GLint *v);
-    void glNormal3i(GLint nx, GLint ny, GLint nz);
-    void glNormal3fv(const GLfloat *v);
-    void glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz);
-    void glNormal3dv(const GLdouble *v);
-    void glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz);
-    void glNormal3bv(const GLbyte *v);
-    void glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz);
-    void glIndexsv(const GLshort *c);
-    void glIndexs(GLshort c);
-    void glIndexiv(const GLint *c);
-    void glIndexi(GLint c);
-    void glIndexfv(const GLfloat *c);
-    void glIndexf(GLfloat c);
-    void glIndexdv(const GLdouble *c);
-    void glIndexd(GLdouble c);
-    void glEnd();
-    void glEdgeFlagv(const GLboolean *flag);
-    void glEdgeFlag(GLboolean flag);
-    void glColor4usv(const GLushort *v);
-    void glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha);
-    void glColor4uiv(const GLuint *v);
-    void glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha);
-    void glColor4ubv(const GLubyte *v);
-    void glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
-    void glColor4sv(const GLshort *v);
-    void glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha);
-    void glColor4iv(const GLint *v);
-    void glColor4i(GLint red, GLint green, GLint blue, GLint alpha);
-    void glColor4fv(const GLfloat *v);
-    void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glColor4dv(const GLdouble *v);
-    void glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
-    void glColor4bv(const GLbyte *v);
-    void glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
-    void glColor3usv(const GLushort *v);
-    void glColor3us(GLushort red, GLushort green, GLushort blue);
-    void glColor3uiv(const GLuint *v);
-    void glColor3ui(GLuint red, GLuint green, GLuint blue);
-    void glColor3ubv(const GLubyte *v);
-    void glColor3ub(GLubyte red, GLubyte green, GLubyte blue);
-    void glColor3sv(const GLshort *v);
-    void glColor3s(GLshort red, GLshort green, GLshort blue);
-    void glColor3iv(const GLint *v);
-    void glColor3i(GLint red, GLint green, GLint blue);
-    void glColor3fv(const GLfloat *v);
-    void glColor3f(GLfloat red, GLfloat green, GLfloat blue);
-    void glColor3dv(const GLdouble *v);
-    void glColor3d(GLdouble red, GLdouble green, GLdouble blue);
-    void glColor3bv(const GLbyte *v);
-    void glColor3b(GLbyte red, GLbyte green, GLbyte blue);
-    void glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap);
-    void glBegin(GLenum mode);
-    void glListBase(GLuint base);
-    GLuint glGenLists(GLsizei range);
-    void glDeleteLists(GLuint list, GLsizei range);
-    void glCallLists(GLsizei n, GLenum type, const GLvoid *lists);
-    void glCallList(GLuint list);
-    void glEndList();
-    void glNewList(GLuint list, GLenum mode);
-
-    // OpenGL 1.1 deprecated functions
-    void glPushClientAttrib(GLbitfield mask);
-    void glPopClientAttrib();
-    void glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities);
-    GLboolean glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences);
-    void glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer);
-    void glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glEnableClientState(GLenum array);
-    void glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer);
-    void glDisableClientState(GLenum array);
-    void glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glArrayElement(GLint i);
-
-    // OpenGL 1.2 deprecated functions
-    void glResetMinmax(GLenum target);
-    void glResetHistogram(GLenum target);
-    void glMinmax(GLenum target, GLenum internalformat, GLboolean sink);
-    void glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink);
-    void glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
-    void glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
-    void glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column);
-    void glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span);
-    void glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image);
-    void glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
-    void glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glConvolutionParameteri(GLenum target, GLenum pname, GLint params);
-    void glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params);
-    void glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image);
-    void glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image);
-    void glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width);
-    void glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data);
-    void glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table);
-    void glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
-    void glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table);
-
-    // OpenGL 1.3 deprecated functions
-    void glMultTransposeMatrixd(const GLdouble *m);
-    void glMultTransposeMatrixf(const GLfloat *m);
-    void glLoadTransposeMatrixd(const GLdouble *m);
-    void glLoadTransposeMatrixf(const GLfloat *m);
-    void glMultiTexCoord4sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);
-    void glMultiTexCoord4iv(GLenum target, const GLint *v);
-    void glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q);
-    void glMultiTexCoord4fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
-    void glMultiTexCoord4dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
-    void glMultiTexCoord3sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r);
-    void glMultiTexCoord3iv(GLenum target, const GLint *v);
-    void glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r);
-    void glMultiTexCoord3fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r);
-    void glMultiTexCoord3dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r);
-    void glMultiTexCoord2sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord2s(GLenum target, GLshort s, GLshort t);
-    void glMultiTexCoord2iv(GLenum target, const GLint *v);
-    void glMultiTexCoord2i(GLenum target, GLint s, GLint t);
-    void glMultiTexCoord2fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t);
-    void glMultiTexCoord2dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t);
-    void glMultiTexCoord1sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord1s(GLenum target, GLshort s);
-    void glMultiTexCoord1iv(GLenum target, const GLint *v);
-    void glMultiTexCoord1i(GLenum target, GLint s);
-    void glMultiTexCoord1fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord1f(GLenum target, GLfloat s);
-    void glMultiTexCoord1dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord1d(GLenum target, GLdouble s);
-    void glClientActiveTexture(GLenum texture);
-
-    // OpenGL 1.4 deprecated functions
-    void glWindowPos3sv(const GLshort *v);
-    void glWindowPos3s(GLshort x, GLshort y, GLshort z);
-    void glWindowPos3iv(const GLint *v);
-    void glWindowPos3i(GLint x, GLint y, GLint z);
-    void glWindowPos3fv(const GLfloat *v);
-    void glWindowPos3f(GLfloat x, GLfloat y, GLfloat z);
-    void glWindowPos3dv(const GLdouble *v);
-    void glWindowPos3d(GLdouble x, GLdouble y, GLdouble z);
-    void glWindowPos2sv(const GLshort *v);
-    void glWindowPos2s(GLshort x, GLshort y);
-    void glWindowPos2iv(const GLint *v);
-    void glWindowPos2i(GLint x, GLint y);
-    void glWindowPos2fv(const GLfloat *v);
-    void glWindowPos2f(GLfloat x, GLfloat y);
-    void glWindowPos2dv(const GLdouble *v);
-    void glWindowPos2d(GLdouble x, GLdouble y);
-    void glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glSecondaryColor3usv(const GLushort *v);
-    void glSecondaryColor3us(GLushort red, GLushort green, GLushort blue);
-    void glSecondaryColor3uiv(const GLuint *v);
-    void glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue);
-    void glSecondaryColor3ubv(const GLubyte *v);
-    void glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue);
-    void glSecondaryColor3sv(const GLshort *v);
-    void glSecondaryColor3s(GLshort red, GLshort green, GLshort blue);
-    void glSecondaryColor3iv(const GLint *v);
-    void glSecondaryColor3i(GLint red, GLint green, GLint blue);
-    void glSecondaryColor3fv(const GLfloat *v);
-    void glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue);
-    void glSecondaryColor3dv(const GLdouble *v);
-    void glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue);
-    void glSecondaryColor3bv(const GLbyte *v);
-    void glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue);
-    void glFogCoordPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glFogCoorddv(const GLdouble *coord);
-    void glFogCoordd(GLdouble coord);
-    void glFogCoordfv(const GLfloat *coord);
-    void glFogCoordf(GLfloat coord);
-
-    // OpenGL 1.5 deprecated functions
-
-    // OpenGL 2.0 deprecated functions
-    void glVertexAttrib4usv(GLuint index, const GLushort *v);
-    void glVertexAttrib4uiv(GLuint index, const GLuint *v);
-    void glVertexAttrib4ubv(GLuint index, const GLubyte *v);
-    void glVertexAttrib4sv(GLuint index, const GLshort *v);
-    void glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
-    void glVertexAttrib4iv(GLuint index, const GLint *v);
-    void glVertexAttrib4fv(GLuint index, const GLfloat *v);
-    void glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void glVertexAttrib4dv(GLuint index, const GLdouble *v);
-    void glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glVertexAttrib4bv(GLuint index, const GLbyte *v);
-    void glVertexAttrib4Nusv(GLuint index, const GLushort *v);
-    void glVertexAttrib4Nuiv(GLuint index, const GLuint *v);
-    void glVertexAttrib4Nubv(GLuint index, const GLubyte *v);
-    void glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
-    void glVertexAttrib4Nsv(GLuint index, const GLshort *v);
-    void glVertexAttrib4Niv(GLuint index, const GLint *v);
-    void glVertexAttrib4Nbv(GLuint index, const GLbyte *v);
-    void glVertexAttrib3sv(GLuint index, const GLshort *v);
-    void glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z);
-    void glVertexAttrib3fv(GLuint index, const GLfloat *v);
-    void glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z);
-    void glVertexAttrib3dv(GLuint index, const GLdouble *v);
-    void glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z);
-    void glVertexAttrib2sv(GLuint index, const GLshort *v);
-    void glVertexAttrib2s(GLuint index, GLshort x, GLshort y);
-    void glVertexAttrib2fv(GLuint index, const GLfloat *v);
-    void glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y);
-    void glVertexAttrib2dv(GLuint index, const GLdouble *v);
-    void glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y);
-    void glVertexAttrib1sv(GLuint index, const GLshort *v);
-    void glVertexAttrib1s(GLuint index, GLshort x);
-    void glVertexAttrib1fv(GLuint index, const GLfloat *v);
-    void glVertexAttrib1f(GLuint index, GLfloat x);
-    void glVertexAttrib1dv(GLuint index, const GLdouble *v);
-    void glVertexAttrib1d(GLuint index, GLdouble x);
-
-    // OpenGL 2.1 deprecated functions
-
-    // OpenGL 3.0 deprecated functions
-    void glVertexAttribI4usv(GLuint index, const GLushort *v);
-    void glVertexAttribI4ubv(GLuint index, const GLubyte *v);
-    void glVertexAttribI4sv(GLuint index, const GLshort *v);
-    void glVertexAttribI4bv(GLuint index, const GLbyte *v);
-    void glVertexAttribI4uiv(GLuint index, const GLuint *v);
-    void glVertexAttribI3uiv(GLuint index, const GLuint *v);
-    void glVertexAttribI2uiv(GLuint index, const GLuint *v);
-    void glVertexAttribI1uiv(GLuint index, const GLuint *v);
-    void glVertexAttribI4iv(GLuint index, const GLint *v);
-    void glVertexAttribI3iv(GLuint index, const GLint *v);
-    void glVertexAttribI2iv(GLuint index, const GLint *v);
-    void glVertexAttribI1iv(GLuint index, const GLint *v);
-    void glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
-    void glVertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z);
-    void glVertexAttribI2ui(GLuint index, GLuint x, GLuint y);
-    void glVertexAttribI1ui(GLuint index, GLuint x);
-    void glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w);
-    void glVertexAttribI3i(GLuint index, GLint x, GLint y, GLint z);
-    void glVertexAttribI2i(GLuint index, GLint x, GLint y);
-    void glVertexAttribI1i(GLuint index, GLint x);
-
-    // OpenGL 3.1 deprecated functions
-
-    // OpenGL 3.2 deprecated functions
-
-    // OpenGL 3.3 deprecated functions
-
-    // OpenGL 4.0 deprecated functions
-
-private:
-    friend class QOpenGLContext;
-
-    static bool isContextCompatible(QOpenGLContext *context);
-    static QOpenGLVersionProfile versionProfile();
-
-    QOpenGLFunctions_1_0_CoreBackend* d_1_0_Core;
-    QOpenGLFunctions_1_1_CoreBackend* d_1_1_Core;
-    QOpenGLFunctions_1_2_CoreBackend* d_1_2_Core;
-    QOpenGLFunctions_1_3_CoreBackend* d_1_3_Core;
-    QOpenGLFunctions_1_4_CoreBackend* d_1_4_Core;
-    QOpenGLFunctions_1_5_CoreBackend* d_1_5_Core;
-    QOpenGLFunctions_2_0_CoreBackend* d_2_0_Core;
-    QOpenGLFunctions_2_1_CoreBackend* d_2_1_Core;
-    QOpenGLFunctions_3_0_CoreBackend* d_3_0_Core;
-    QOpenGLFunctions_3_1_CoreBackend* d_3_1_Core;
-    QOpenGLFunctions_3_2_CoreBackend* d_3_2_Core;
-    QOpenGLFunctions_3_3_CoreBackend* d_3_3_Core;
-    QOpenGLFunctions_4_0_CoreBackend* d_4_0_Core;
-    QOpenGLFunctions_1_0_DeprecatedBackend* d_1_0_Deprecated;
-    QOpenGLFunctions_1_1_DeprecatedBackend* d_1_1_Deprecated;
-    QOpenGLFunctions_1_2_DeprecatedBackend* d_1_2_Deprecated;
-    QOpenGLFunctions_1_3_DeprecatedBackend* d_1_3_Deprecated;
-    QOpenGLFunctions_1_4_DeprecatedBackend* d_1_4_Deprecated;
-    void *m_reserved_2_0_Deprecated; // To maintain BC
-    QOpenGLFunctions_3_3_DeprecatedBackend* d_3_3_Deprecated;
-};
-
-// OpenGL 1.0 core functions
-inline void QOpenGLFunctions_4_0_Compatibility::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_0_Core->f.Viewport(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glDepthRange(GLdouble nearVal, GLdouble farVal)
-{
-    d_1_0_Core->f.DepthRange(nearVal, farVal);
-}
-
-inline GLboolean QOpenGLFunctions_4_0_Compatibility::glIsEnabled(GLenum cap)
-{
-    return d_1_0_Core->f.IsEnabled(cap);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetTexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetTexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
-{
-    d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
-}
-
-inline const GLubyte * QOpenGLFunctions_4_0_Compatibility::glGetString(GLenum name)
-{
-    return d_1_0_Core->f.GetString(name);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetIntegerv(GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetIntegerv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetFloatv(GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetFloatv(pname, params);
-}
-
-inline GLenum QOpenGLFunctions_4_0_Compatibility::glGetError()
-{
-    return d_1_0_Core->f.GetError();
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetDoublev(GLenum pname, GLdouble *params)
-{
-    d_1_0_Core->f.GetDoublev(pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetBooleanv(GLenum pname, GLboolean *params)
-{
-    d_1_0_Core->f.GetBooleanv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
-{
-    d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glReadBuffer(GLenum mode)
-{
-    d_1_0_Core->f.ReadBuffer(mode);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glPixelStorei(GLenum pname, GLint param)
-{
-    d_1_0_Core->f.PixelStorei(pname, param);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glPixelStoref(GLenum pname, GLfloat param)
-{
-    d_1_0_Core->f.PixelStoref(pname, param);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glDepthFunc(GLenum func)
-{
-    d_1_0_Core->f.DepthFunc(func);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
-{
-    d_1_0_Core->f.StencilOp(fail, zfail, zpass);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glStencilFunc(GLenum func, GLint ref, GLuint mask)
-{
-    d_1_0_Core->f.StencilFunc(func, ref, mask);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glLogicOp(GLenum opcode)
-{
-    d_1_0_Core->f.LogicOp(opcode);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glBlendFunc(GLenum sfactor, GLenum dfactor)
-{
-    d_1_0_Core->f.BlendFunc(sfactor, dfactor);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glFlush()
-{
-    d_1_0_Core->f.Flush();
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glFinish()
-{
-    d_1_0_Core->f.Finish();
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glEnable(GLenum cap)
-{
-    d_1_0_Core->f.Enable(cap);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glDisable(GLenum cap)
-{
-    d_1_0_Core->f.Disable(cap);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glDepthMask(GLboolean flag)
-{
-    d_1_0_Core->f.DepthMask(flag);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
-{
-    d_1_0_Core->f.ColorMask(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glStencilMask(GLuint mask)
-{
-    d_1_0_Core->f.StencilMask(mask);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glClearDepth(GLdouble depth)
-{
-    d_1_0_Core->f.ClearDepth(depth);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glClearStencil(GLint s)
-{
-    d_1_0_Core->f.ClearStencil(s);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Core->f.ClearColor(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glClear(GLbitfield mask)
-{
-    d_1_0_Core->f.Clear(mask);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glDrawBuffer(GLenum mode)
-{
-    d_1_0_Core->f.DrawBuffer(mode);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Core->f.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Core->f.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_0_Core->f.TexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexParameteri(GLenum target, GLenum pname, GLint param)
-{
-    d_1_0_Core->f.TexParameteri(target, pname, param);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Core->f.TexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
-{
-    d_1_0_Core->f.TexParameterf(target, pname, param);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_0_Core->f.Scissor(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glPolygonMode(GLenum face, GLenum mode)
-{
-    d_1_0_Core->f.PolygonMode(face, mode);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glPointSize(GLfloat size)
-{
-    d_1_0_Core->f.PointSize(size);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glLineWidth(GLfloat width)
-{
-    d_1_0_Core->f.LineWidth(width);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glHint(GLenum target, GLenum mode)
-{
-    d_1_0_Core->f.Hint(target, mode);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glFrontFace(GLenum mode)
-{
-    d_1_0_Core->f.FrontFace(mode);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glCullFace(GLenum mode)
-{
-    d_1_0_Core->f.CullFace(mode);
-}
-
-
-// OpenGL 1.1 core functions
-inline void QOpenGLFunctions_4_0_Compatibility::glIndexubv(const GLubyte *c)
-{
-    d_1_1_Deprecated->f.Indexubv(c);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glIndexub(GLubyte c)
-{
-    d_1_1_Deprecated->f.Indexub(c);
-}
-
-inline GLboolean QOpenGLFunctions_4_0_Compatibility::glIsTexture(GLuint texture)
-{
-    return d_1_1_Core->f.IsTexture(texture);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGenTextures(GLsizei n, GLuint *textures)
-{
-    d_1_1_Core->f.GenTextures(n, textures);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glDeleteTextures(GLsizei n, const GLuint *textures)
-{
-    d_1_1_Core->f.DeleteTextures(n, textures);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glBindTexture(GLenum target, GLuint texture)
-{
-    d_1_1_Core->f.BindTexture(target, texture);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_1_Core->f.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_1_Core->f.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_1_Core->f.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
-{
-    d_1_1_Core->f.CopyTexSubImage1D(target, level, xoffset, x, y, width);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
-{
-    d_1_1_Core->f.CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
-{
-    d_1_1_Core->f.CopyTexImage1D(target, level, internalformat, x, y, width, border);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glPolygonOffset(GLfloat factor, GLfloat units)
-{
-    d_1_1_Core->f.PolygonOffset(factor, units);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetPointerv(GLenum pname, GLvoid* *params)
-{
-    d_1_1_Deprecated->f.GetPointerv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
-{
-    d_1_1_Core->f.DrawElements(mode, count, type, indices);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glDrawArrays(GLenum mode, GLint first, GLsizei count)
-{
-    d_1_1_Core->f.DrawArrays(mode, first, count);
-}
-
-
-// OpenGL 1.2 core functions
-inline void QOpenGLFunctions_4_0_Compatibility::glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_2_Core->f.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_2_Core->f.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_2_Core->f.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
-{
-    d_1_2_Core->f.DrawRangeElements(mode, start, end, count, type, indices);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glBlendEquation(GLenum mode)
-{
-    d_1_2_Core->f.BlendEquation(mode);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_2_Core->f.BlendColor(red, green, blue, alpha);
-}
-
-
-// OpenGL 1.3 core functions
-inline void QOpenGLFunctions_4_0_Compatibility::glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img)
-{
-    d_1_3_Core->f.GetCompressedTexImage(target, level, img);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glSampleCoverage(GLfloat value, GLboolean invert)
-{
-    d_1_3_Core->f.SampleCoverage(value, invert);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glActiveTexture(GLenum texture)
-{
-    d_1_3_Core->f.ActiveTexture(texture);
-}
-
-
-// OpenGL 1.4 core functions
-inline void QOpenGLFunctions_4_0_Compatibility::glPointParameteriv(GLenum pname, const GLint *params)
-{
-    d_1_4_Core->f.PointParameteriv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glPointParameteri(GLenum pname, GLint param)
-{
-    d_1_4_Core->f.PointParameteri(pname, param);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glPointParameterfv(GLenum pname, const GLfloat *params)
-{
-    d_1_4_Core->f.PointParameterfv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glPointParameterf(GLenum pname, GLfloat param)
-{
-    d_1_4_Core->f.PointParameterf(pname, param);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount)
-{
-    d_1_4_Core->f.MultiDrawElements(mode, count, type, indices, drawcount);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
-{
-    d_1_4_Core->f.MultiDrawArrays(mode, first, count, drawcount);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
-{
-    d_1_4_Core->f.BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
-}
-
-
-// OpenGL 1.5 core functions
-inline void QOpenGLFunctions_4_0_Compatibility::glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params)
-{
-    d_1_5_Core->f.GetBufferPointerv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetBufferParameteriv(target, pname, params);
-}
-
-inline GLboolean QOpenGLFunctions_4_0_Compatibility::glUnmapBuffer(GLenum target)
-{
-    return d_1_5_Core->f.UnmapBuffer(target);
-}
-
-inline GLvoid* QOpenGLFunctions_4_0_Compatibility::glMapBuffer(GLenum target, GLenum access)
-{
-    return d_1_5_Core->f.MapBuffer(target, access);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data)
-{
-    d_1_5_Core->f.GetBufferSubData(target, offset, size, data);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data)
-{
-    d_1_5_Core->f.BufferSubData(target, offset, size, data);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)
-{
-    d_1_5_Core->f.BufferData(target, size, data, usage);
-}
-
-inline GLboolean QOpenGLFunctions_4_0_Compatibility::glIsBuffer(GLuint buffer)
-{
-    return d_1_5_Core->f.IsBuffer(buffer);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGenBuffers(GLsizei n, GLuint *buffers)
-{
-    d_1_5_Core->f.GenBuffers(n, buffers);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glDeleteBuffers(GLsizei n, const GLuint *buffers)
-{
-    d_1_5_Core->f.DeleteBuffers(n, buffers);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glBindBuffer(GLenum target, GLuint buffer)
-{
-    d_1_5_Core->f.BindBuffer(target, buffer);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
-{
-    d_1_5_Core->f.GetQueryObjectuiv(id, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetQueryObjectiv(id, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetQueryiv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetQueryiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glEndQuery(GLenum target)
-{
-    d_1_5_Core->f.EndQuery(target);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glBeginQuery(GLenum target, GLuint id)
-{
-    d_1_5_Core->f.BeginQuery(target, id);
-}
-
-inline GLboolean QOpenGLFunctions_4_0_Compatibility::glIsQuery(GLuint id)
-{
-    return d_1_5_Core->f.IsQuery(id);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glDeleteQueries(GLsizei n, const GLuint *ids)
-{
-    d_1_5_Core->f.DeleteQueries(n, ids);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGenQueries(GLsizei n, GLuint *ids)
-{
-    d_1_5_Core->f.GenQueries(n, ids);
-}
-
-
-// OpenGL 2.0 core functions
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer)
-{
-    d_2_0_Core->f.VertexAttribPointer(index, size, type, normalized, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glValidateProgram(GLuint program)
-{
-    d_2_0_Core->f.ValidateProgram(program);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix3fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glUniform4iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform4iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glUniform3iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform3iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glUniform2iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform2iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glUniform1iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform1iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glUniform4fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform4fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glUniform3fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform3fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glUniform2fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform2fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glUniform1fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform1fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
-{
-    d_2_0_Core->f.Uniform4i(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glUniform3i(GLint location, GLint v0, GLint v1, GLint v2)
-{
-    d_2_0_Core->f.Uniform3i(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glUniform2i(GLint location, GLint v0, GLint v1)
-{
-    d_2_0_Core->f.Uniform2i(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glUniform1i(GLint location, GLint v0)
-{
-    d_2_0_Core->f.Uniform1i(location, v0);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
-{
-    d_2_0_Core->f.Uniform4f(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
-{
-    d_2_0_Core->f.Uniform3f(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glUniform2f(GLint location, GLfloat v0, GLfloat v1)
-{
-    d_2_0_Core->f.Uniform2f(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glUniform1f(GLint location, GLfloat v0)
-{
-    d_2_0_Core->f.Uniform1f(location, v0);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glUseProgram(GLuint program)
-{
-    d_2_0_Core->f.UseProgram(program);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length)
-{
-    d_2_0_Core->f.ShaderSource(shader, count, string, length);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glLinkProgram(GLuint program)
-{
-    d_2_0_Core->f.LinkProgram(program);
-}
-
-inline GLboolean QOpenGLFunctions_4_0_Compatibility::glIsShader(GLuint shader)
-{
-    return d_2_0_Core->f.IsShader(shader);
-}
-
-inline GLboolean QOpenGLFunctions_4_0_Compatibility::glIsProgram(GLuint program)
-{
-    return d_2_0_Core->f.IsProgram(program);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer)
-{
-    d_2_0_Core->f.GetVertexAttribPointerv(index, pname, pointer);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetVertexAttribiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
-{
-    d_2_0_Core->f.GetVertexAttribfv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
-{
-    d_2_0_Core->f.GetVertexAttribdv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetUniformiv(GLuint program, GLint location, GLint *params)
-{
-    d_2_0_Core->f.GetUniformiv(program, location, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetUniformfv(GLuint program, GLint location, GLfloat *params)
-{
-    d_2_0_Core->f.GetUniformfv(program, location, params);
-}
-
-inline GLint QOpenGLFunctions_4_0_Compatibility::glGetUniformLocation(GLuint program, const GLchar *name)
-{
-    return d_2_0_Core->f.GetUniformLocation(program, name);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
-{
-    d_2_0_Core->f.GetShaderSource(shader, bufSize, length, source);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-{
-    d_2_0_Core->f.GetShaderInfoLog(shader, bufSize, length, infoLog);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetShaderiv(GLuint shader, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetShaderiv(shader, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-{
-    d_2_0_Core->f.GetProgramInfoLog(program, bufSize, length, infoLog);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetProgramiv(GLuint program, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetProgramiv(program, pname, params);
-}
-
-inline GLint QOpenGLFunctions_4_0_Compatibility::glGetAttribLocation(GLuint program, const GLchar *name)
-{
-    return d_2_0_Core->f.GetAttribLocation(program, name);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj)
-{
-    d_2_0_Core->f.GetAttachedShaders(program, maxCount, count, obj);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
-{
-    d_2_0_Core->f.GetActiveUniform(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
-{
-    d_2_0_Core->f.GetActiveAttrib(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glEnableVertexAttribArray(GLuint index)
-{
-    d_2_0_Core->f.EnableVertexAttribArray(index);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glDisableVertexAttribArray(GLuint index)
-{
-    d_2_0_Core->f.DisableVertexAttribArray(index);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glDetachShader(GLuint program, GLuint shader)
-{
-    d_2_0_Core->f.DetachShader(program, shader);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glDeleteShader(GLuint shader)
-{
-    d_2_0_Core->f.DeleteShader(shader);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glDeleteProgram(GLuint program)
-{
-    d_2_0_Core->f.DeleteProgram(program);
-}
-
-inline GLuint QOpenGLFunctions_4_0_Compatibility::glCreateShader(GLenum type)
-{
-    return d_2_0_Core->f.CreateShader(type);
-}
-
-inline GLuint QOpenGLFunctions_4_0_Compatibility::glCreateProgram()
-{
-    return d_2_0_Core->f.CreateProgram();
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glCompileShader(GLuint shader)
-{
-    d_2_0_Core->f.CompileShader(shader);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glBindAttribLocation(GLuint program, GLuint index, const GLchar *name)
-{
-    d_2_0_Core->f.BindAttribLocation(program, index, name);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glAttachShader(GLuint program, GLuint shader)
-{
-    d_2_0_Core->f.AttachShader(program, shader);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glStencilMaskSeparate(GLenum face, GLuint mask)
-{
-    d_2_0_Core->f.StencilMaskSeparate(face, mask);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
-{
-    d_2_0_Core->f.StencilFuncSeparate(face, func, ref, mask);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
-{
-    d_2_0_Core->f.StencilOpSeparate(face, sfail, dpfail, dppass);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glDrawBuffers(GLsizei n, const GLenum *bufs)
-{
-    d_2_0_Core->f.DrawBuffers(n, bufs);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
-{
-    d_2_0_Core->f.BlendEquationSeparate(modeRGB, modeAlpha);
-}
-
-
-// OpenGL 2.1 core functions
-inline void QOpenGLFunctions_4_0_Compatibility::glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix4x3fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix3x4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix4x2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix2x4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix3x2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix2x3fv(location, count, transpose, value);
-}
-
-
-// OpenGL 3.0 core functions
-inline GLboolean QOpenGLFunctions_4_0_Compatibility::glIsVertexArray(GLuint array)
-{
-    return d_3_0_Core->f.IsVertexArray(array);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGenVertexArrays(GLsizei n, GLuint *arrays)
-{
-    d_3_0_Core->f.GenVertexArrays(n, arrays);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glDeleteVertexArrays(GLsizei n, const GLuint *arrays)
-{
-    d_3_0_Core->f.DeleteVertexArrays(n, arrays);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glBindVertexArray(GLuint array)
-{
-    d_3_0_Core->f.BindVertexArray(array);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
-{
-    d_3_0_Core->f.FlushMappedBufferRange(target, offset, length);
-}
-
-inline GLvoid* QOpenGLFunctions_4_0_Compatibility::glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
-{
-    return d_3_0_Core->f.MapBufferRange(target, offset, length, access);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
-{
-    d_3_0_Core->f.FramebufferTextureLayer(target, attachment, texture, level, layer);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    d_3_0_Core->f.RenderbufferStorageMultisample(target, samples, internalformat, width, height);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
-{
-    d_3_0_Core->f.BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGenerateMipmap(GLenum target)
-{
-    d_3_0_Core->f.GenerateMipmap(target);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
-{
-    d_3_0_Core->f.FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
-{
-    d_3_0_Core->f.FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
-{
-    d_3_0_Core->f.FramebufferTexture2D(target, attachment, textarget, texture, level);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
-{
-    d_3_0_Core->f.FramebufferTexture1D(target, attachment, textarget, texture, level);
-}
-
-inline GLenum QOpenGLFunctions_4_0_Compatibility::glCheckFramebufferStatus(GLenum target)
-{
-    return d_3_0_Core->f.CheckFramebufferStatus(target);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGenFramebuffers(GLsizei n, GLuint *framebuffers)
-{
-    d_3_0_Core->f.GenFramebuffers(n, framebuffers);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
-{
-    d_3_0_Core->f.DeleteFramebuffers(n, framebuffers);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glBindFramebuffer(GLenum target, GLuint framebuffer)
-{
-    d_3_0_Core->f.BindFramebuffer(target, framebuffer);
-}
-
-inline GLboolean QOpenGLFunctions_4_0_Compatibility::glIsFramebuffer(GLuint framebuffer)
-{
-    return d_3_0_Core->f.IsFramebuffer(framebuffer);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetRenderbufferParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    d_3_0_Core->f.RenderbufferStorage(target, internalformat, width, height);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGenRenderbuffers(GLsizei n, GLuint *renderbuffers)
-{
-    d_3_0_Core->f.GenRenderbuffers(n, renderbuffers);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
-{
-    d_3_0_Core->f.DeleteRenderbuffers(n, renderbuffers);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glBindRenderbuffer(GLenum target, GLuint renderbuffer)
-{
-    d_3_0_Core->f.BindRenderbuffer(target, renderbuffer);
-}
-
-inline GLboolean QOpenGLFunctions_4_0_Compatibility::glIsRenderbuffer(GLuint renderbuffer)
-{
-    return d_3_0_Core->f.IsRenderbuffer(renderbuffer);
-}
-
-inline const GLubyte * QOpenGLFunctions_4_0_Compatibility::glGetStringi(GLenum name, GLuint index)
-{
-    return d_3_0_Core->f.GetStringi(name, index);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
-{
-    d_3_0_Core->f.ClearBufferfi(buffer, drawbuffer, depth, stencil);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
-{
-    d_3_0_Core->f.ClearBufferfv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
-{
-    d_3_0_Core->f.ClearBufferuiv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
-{
-    d_3_0_Core->f.ClearBufferiv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params)
-{
-    d_3_0_Core->f.GetTexParameterIuiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetTexParameterIiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params)
-{
-    d_3_0_Core->f.TexParameterIuiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexParameterIiv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_3_0_Core->f.TexParameterIiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glUniform4uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform4uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glUniform3uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform3uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glUniform2uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform2uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glUniform1uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform1uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
-{
-    d_3_0_Core->f.Uniform4ui(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
-{
-    d_3_0_Core->f.Uniform3ui(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glUniform2ui(GLint location, GLuint v0, GLuint v1)
-{
-    d_3_0_Core->f.Uniform2ui(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glUniform1ui(GLint location, GLuint v0)
-{
-    d_3_0_Core->f.Uniform1ui(location, v0);
-}
-
-inline GLint QOpenGLFunctions_4_0_Compatibility::glGetFragDataLocation(GLuint program, const GLchar *name)
-{
-    return d_3_0_Core->f.GetFragDataLocation(program, name);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name)
-{
-    d_3_0_Core->f.BindFragDataLocation(program, color, name);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetUniformuiv(GLuint program, GLint location, GLuint *params)
-{
-    d_3_0_Core->f.GetUniformuiv(program, location, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
-{
-    d_3_0_Core->f.GetVertexAttribIuiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetVertexAttribIiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_3_0_Core->f.VertexAttribIPointer(index, size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glEndConditionalRender()
-{
-    d_3_0_Core->f.EndConditionalRender();
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glBeginConditionalRender(GLuint id, GLenum mode)
-{
-    d_3_0_Core->f.BeginConditionalRender(id, mode);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glClampColor(GLenum target, GLenum clamp)
-{
-    d_3_0_Core->f.ClampColor(target, clamp);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
-{
-    d_3_0_Core->f.GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode)
-{
-    d_3_0_Core->f.TransformFeedbackVaryings(program, count, varyings, bufferMode);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
-{
-    d_3_0_Core->f.BindBufferBase(target, index, buffer);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
-{
-    d_3_0_Core->f.BindBufferRange(target, index, buffer, offset, size);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glEndTransformFeedback()
-{
-    d_3_0_Core->f.EndTransformFeedback();
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glBeginTransformFeedback(GLenum primitiveMode)
-{
-    d_3_0_Core->f.BeginTransformFeedback(primitiveMode);
-}
-
-inline GLboolean QOpenGLFunctions_4_0_Compatibility::glIsEnabledi(GLenum target, GLuint index)
-{
-    return d_3_0_Core->f.IsEnabledi(target, index);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glDisablei(GLenum target, GLuint index)
-{
-    d_3_0_Core->f.Disablei(target, index);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glEnablei(GLenum target, GLuint index)
-{
-    d_3_0_Core->f.Enablei(target, index);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetIntegeri_v(GLenum target, GLuint index, GLint *data)
-{
-    d_3_0_Core->f.GetIntegeri_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetBooleani_v(GLenum target, GLuint index, GLboolean *data)
-{
-    d_3_0_Core->f.GetBooleani_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
-{
-    d_3_0_Core->f.ColorMaski(index, r, g, b, a);
-}
-
-
-// OpenGL 3.1 core functions
-inline void QOpenGLFunctions_4_0_Compatibility::glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
-{
-    d_3_1_Core->f.CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
-{
-    d_3_1_Core->f.UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
-{
-    d_3_1_Core->f.GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params)
-{
-    d_3_1_Core->f.GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
-}
-
-inline GLuint QOpenGLFunctions_4_0_Compatibility::glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName)
-{
-    return d_3_1_Core->f.GetUniformBlockIndex(program, uniformBlockName);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName)
-{
-    d_3_1_Core->f.GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params)
-{
-    d_3_1_Core->f.GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const *uniformNames, GLuint *uniformIndices)
-{
-    d_3_1_Core->f.GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glPrimitiveRestartIndex(GLuint index)
-{
-    d_3_1_Core->f.PrimitiveRestartIndex(index);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer)
-{
-    d_3_1_Core->f.TexBuffer(target, internalformat, buffer);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount)
-{
-    d_3_1_Core->f.DrawElementsInstanced(mode, count, type, indices, instancecount);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount)
-{
-    d_3_1_Core->f.DrawArraysInstanced(mode, first, count, instancecount);
-}
-
-
-// OpenGL 3.2 core functions
-inline void QOpenGLFunctions_4_0_Compatibility::glSampleMaski(GLuint index, GLbitfield mask)
-{
-    d_3_2_Core->f.SampleMaski(index, mask);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val)
-{
-    d_3_2_Core->f.GetMultisamplefv(pname, index, val);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexImage3DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
-{
-    d_3_2_Core->f.TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexImage2DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
-{
-    d_3_2_Core->f.TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values)
-{
-    d_3_2_Core->f.GetSynciv(sync, pname, bufSize, length, values);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetInteger64v(GLenum pname, GLint64 *params)
-{
-    d_3_2_Core->f.GetInteger64v(pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
-{
-    d_3_2_Core->f.WaitSync(sync, flags, timeout);
-}
-
-inline GLenum QOpenGLFunctions_4_0_Compatibility::glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
-{
-    return d_3_2_Core->f.ClientWaitSync(sync, flags, timeout);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glDeleteSync(GLsync sync)
-{
-    d_3_2_Core->f.DeleteSync(sync);
-}
-
-inline GLboolean QOpenGLFunctions_4_0_Compatibility::glIsSync(GLsync sync)
-{
-    return d_3_2_Core->f.IsSync(sync);
-}
-
-inline GLsync QOpenGLFunctions_4_0_Compatibility::glFenceSync(GLenum condition, GLbitfield flags)
-{
-    return d_3_2_Core->f.FenceSync(condition, flags);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glProvokingVertex(GLenum mode)
-{
-    d_3_2_Core->f.ProvokingVertex(mode);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount, const GLint *basevertex)
-{
-    d_3_2_Core->f.MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount, GLint basevertex)
-{
-    d_3_2_Core->f.DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)
-{
-    d_3_2_Core->f.DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)
-{
-    d_3_2_Core->f.DrawElementsBaseVertex(mode, count, type, indices, basevertex);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level)
-{
-    d_3_2_Core->f.FramebufferTexture(target, attachment, texture, level);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params)
-{
-    d_3_2_Core->f.GetBufferParameteri64v(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data)
-{
-    d_3_2_Core->f.GetInteger64i_v(target, index, data);
-}
-
-
-// OpenGL 3.3 core functions
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribP4uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP4uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP4ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribP3uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP3uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP3ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribP2uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP2uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP2ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribP1uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP1uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP1ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glSecondaryColorP3uiv(GLenum type, const GLuint *color)
-{
-    d_3_3_Deprecated->f.SecondaryColorP3uiv(type, color);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glSecondaryColorP3ui(GLenum type, GLuint color)
-{
-    d_3_3_Deprecated->f.SecondaryColorP3ui(type, color);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glColorP4uiv(GLenum type, const GLuint *color)
-{
-    d_3_3_Deprecated->f.ColorP4uiv(type, color);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glColorP4ui(GLenum type, GLuint color)
-{
-    d_3_3_Deprecated->f.ColorP4ui(type, color);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glColorP3uiv(GLenum type, const GLuint *color)
-{
-    d_3_3_Deprecated->f.ColorP3uiv(type, color);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glColorP3ui(GLenum type, GLuint color)
-{
-    d_3_3_Deprecated->f.ColorP3ui(type, color);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glNormalP3uiv(GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.NormalP3uiv(type, coords);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glNormalP3ui(GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.NormalP3ui(type, coords);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP4uiv(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP4ui(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP3uiv(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP3ui(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP2uiv(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP2ui(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP1uiv(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP1ui(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexCoordP4uiv(GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.TexCoordP4uiv(type, coords);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexCoordP4ui(GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.TexCoordP4ui(type, coords);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexCoordP3uiv(GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.TexCoordP3uiv(type, coords);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexCoordP3ui(GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.TexCoordP3ui(type, coords);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexCoordP2uiv(GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.TexCoordP2uiv(type, coords);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexCoordP2ui(GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.TexCoordP2ui(type, coords);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexCoordP1uiv(GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.TexCoordP1uiv(type, coords);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexCoordP1ui(GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.TexCoordP1ui(type, coords);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexP4uiv(GLenum type, const GLuint *value)
-{
-    d_3_3_Deprecated->f.VertexP4uiv(type, value);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexP4ui(GLenum type, GLuint value)
-{
-    d_3_3_Deprecated->f.VertexP4ui(type, value);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexP3uiv(GLenum type, const GLuint *value)
-{
-    d_3_3_Deprecated->f.VertexP3uiv(type, value);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexP3ui(GLenum type, GLuint value)
-{
-    d_3_3_Deprecated->f.VertexP3ui(type, value);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexP2uiv(GLenum type, const GLuint *value)
-{
-    d_3_3_Deprecated->f.VertexP2uiv(type, value);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexP2ui(GLenum type, GLuint value)
-{
-    d_3_3_Deprecated->f.VertexP2ui(type, value);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params)
-{
-    d_3_3_Core->f.GetQueryObjectui64v(id, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params)
-{
-    d_3_3_Core->f.GetQueryObjecti64v(id, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glQueryCounter(GLuint id, GLenum target)
-{
-    d_3_3_Core->f.QueryCounter(id, target);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params)
-{
-    d_3_3_Core->f.GetSamplerParameterIuiv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params)
-{
-    d_3_3_Core->f.GetSamplerParameterfv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params)
-{
-    d_3_3_Core->f.GetSamplerParameterIiv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params)
-{
-    d_3_3_Core->f.GetSamplerParameteriv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param)
-{
-    d_3_3_Core->f.SamplerParameterIuiv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param)
-{
-    d_3_3_Core->f.SamplerParameterIiv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param)
-{
-    d_3_3_Core->f.SamplerParameterfv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
-{
-    d_3_3_Core->f.SamplerParameterf(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param)
-{
-    d_3_3_Core->f.SamplerParameteriv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glSamplerParameteri(GLuint sampler, GLenum pname, GLint param)
-{
-    d_3_3_Core->f.SamplerParameteri(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glBindSampler(GLuint unit, GLuint sampler)
-{
-    d_3_3_Core->f.BindSampler(unit, sampler);
-}
-
-inline GLboolean QOpenGLFunctions_4_0_Compatibility::glIsSampler(GLuint sampler)
-{
-    return d_3_3_Core->f.IsSampler(sampler);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glDeleteSamplers(GLsizei count, const GLuint *samplers)
-{
-    d_3_3_Core->f.DeleteSamplers(count, samplers);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGenSamplers(GLsizei count, GLuint *samplers)
-{
-    d_3_3_Core->f.GenSamplers(count, samplers);
-}
-
-inline GLint QOpenGLFunctions_4_0_Compatibility::glGetFragDataIndex(GLuint program, const GLchar *name)
-{
-    return d_3_3_Core->f.GetFragDataIndex(program, name);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glBindFragDataLocationIndexed(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name)
-{
-    d_3_3_Core->f.BindFragDataLocationIndexed(program, colorNumber, index, name);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribDivisor(GLuint index, GLuint divisor)
-{
-    d_3_3_Core->f.VertexAttribDivisor(index, divisor);
-}
-
-
-// OpenGL 4.0 core functions
-inline void QOpenGLFunctions_4_0_Compatibility::glGetQueryIndexediv(GLenum target, GLuint index, GLenum pname, GLint *params)
-{
-    d_4_0_Core->f.GetQueryIndexediv(target, index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glEndQueryIndexed(GLenum target, GLuint index)
-{
-    d_4_0_Core->f.EndQueryIndexed(target, index);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glBeginQueryIndexed(GLenum target, GLuint index, GLuint id)
-{
-    d_4_0_Core->f.BeginQueryIndexed(target, index, id);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glDrawTransformFeedbackStream(GLenum mode, GLuint id, GLuint stream)
-{
-    d_4_0_Core->f.DrawTransformFeedbackStream(mode, id, stream);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glDrawTransformFeedback(GLenum mode, GLuint id)
-{
-    d_4_0_Core->f.DrawTransformFeedback(mode, id);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glResumeTransformFeedback()
-{
-    d_4_0_Core->f.ResumeTransformFeedback();
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glPauseTransformFeedback()
-{
-    d_4_0_Core->f.PauseTransformFeedback();
-}
-
-inline GLboolean QOpenGLFunctions_4_0_Compatibility::glIsTransformFeedback(GLuint id)
-{
-    return d_4_0_Core->f.IsTransformFeedback(id);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGenTransformFeedbacks(GLsizei n, GLuint *ids)
-{
-    d_4_0_Core->f.GenTransformFeedbacks(n, ids);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids)
-{
-    d_4_0_Core->f.DeleteTransformFeedbacks(n, ids);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glBindTransformFeedback(GLenum target, GLuint id)
-{
-    d_4_0_Core->f.BindTransformFeedback(target, id);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glPatchParameterfv(GLenum pname, const GLfloat *values)
-{
-    d_4_0_Core->f.PatchParameterfv(pname, values);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glPatchParameteri(GLenum pname, GLint value)
-{
-    d_4_0_Core->f.PatchParameteri(pname, value);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetProgramStageiv(GLuint program, GLenum shadertype, GLenum pname, GLint *values)
-{
-    d_4_0_Core->f.GetProgramStageiv(program, shadertype, pname, values);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetUniformSubroutineuiv(GLenum shadertype, GLint location, GLuint *params)
-{
-    d_4_0_Core->f.GetUniformSubroutineuiv(shadertype, location, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glUniformSubroutinesuiv(GLenum shadertype, GLsizei count, const GLuint *indices)
-{
-    d_4_0_Core->f.UniformSubroutinesuiv(shadertype, count, indices);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetActiveSubroutineName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
-{
-    d_4_0_Core->f.GetActiveSubroutineName(program, shadertype, index, bufsize, length, name);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetActiveSubroutineUniformName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
-{
-    d_4_0_Core->f.GetActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetActiveSubroutineUniformiv(GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values)
-{
-    d_4_0_Core->f.GetActiveSubroutineUniformiv(program, shadertype, index, pname, values);
-}
-
-inline GLuint QOpenGLFunctions_4_0_Compatibility::glGetSubroutineIndex(GLuint program, GLenum shadertype, const GLchar *name)
-{
-    return d_4_0_Core->f.GetSubroutineIndex(program, shadertype, name);
-}
-
-inline GLint QOpenGLFunctions_4_0_Compatibility::glGetSubroutineUniformLocation(GLuint program, GLenum shadertype, const GLchar *name)
-{
-    return d_4_0_Core->f.GetSubroutineUniformLocation(program, shadertype, name);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetUniformdv(GLuint program, GLint location, GLdouble *params)
-{
-    d_4_0_Core->f.GetUniformdv(program, location, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glUniformMatrix4x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix4x3dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glUniformMatrix4x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix4x2dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glUniformMatrix3x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix3x4dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glUniformMatrix3x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix3x2dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glUniformMatrix2x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix2x4dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glUniformMatrix2x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix2x3dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glUniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix4dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glUniformMatrix3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix3dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glUniformMatrix2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix2dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glUniform4dv(GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_0_Core->f.Uniform4dv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glUniform3dv(GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_0_Core->f.Uniform3dv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glUniform2dv(GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_0_Core->f.Uniform2dv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glUniform1dv(GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_0_Core->f.Uniform1dv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glUniform4d(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_4_0_Core->f.Uniform4d(location, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glUniform3d(GLint location, GLdouble x, GLdouble y, GLdouble z)
-{
-    d_4_0_Core->f.Uniform3d(location, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glUniform2d(GLint location, GLdouble x, GLdouble y)
-{
-    d_4_0_Core->f.Uniform2d(location, x, y);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glUniform1d(GLint location, GLdouble x)
-{
-    d_4_0_Core->f.Uniform1d(location, x);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glDrawElementsIndirect(GLenum mode, GLenum type, const GLvoid *indirect)
-{
-    d_4_0_Core->f.DrawElementsIndirect(mode, type, indirect);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glDrawArraysIndirect(GLenum mode, const GLvoid *indirect)
-{
-    d_4_0_Core->f.DrawArraysIndirect(mode, indirect);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glBlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
-{
-    d_4_0_Core->f.BlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glBlendFunci(GLuint buf, GLenum src, GLenum dst)
-{
-    d_4_0_Core->f.BlendFunci(buf, src, dst);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glBlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha)
-{
-    d_4_0_Core->f.BlendEquationSeparatei(buf, modeRGB, modeAlpha);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glBlendEquationi(GLuint buf, GLenum mode)
-{
-    d_4_0_Core->f.BlendEquationi(buf, mode);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMinSampleShading(GLfloat value)
-{
-    d_4_0_Core->f.MinSampleShading(value);
-}
-
-
-// OpenGL 1.0 deprecated functions
-inline void QOpenGLFunctions_4_0_Compatibility::glTranslatef(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Translatef(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTranslated(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Translated(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glScalef(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Scalef(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glScaled(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Scaled(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Rotatef(angle, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Rotated(angle, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glPushMatrix()
-{
-    d_1_0_Deprecated->f.PushMatrix();
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glPopMatrix()
-{
-    d_1_0_Deprecated->f.PopMatrix();
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
-{
-    d_1_0_Deprecated->f.Ortho(left, right, bottom, top, zNear, zFar);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMultMatrixd(const GLdouble *m)
-{
-    d_1_0_Deprecated->f.MultMatrixd(m);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMultMatrixf(const GLfloat *m)
-{
-    d_1_0_Deprecated->f.MultMatrixf(m);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMatrixMode(GLenum mode)
-{
-    d_1_0_Deprecated->f.MatrixMode(mode);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glLoadMatrixd(const GLdouble *m)
-{
-    d_1_0_Deprecated->f.LoadMatrixd(m);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glLoadMatrixf(const GLfloat *m)
-{
-    d_1_0_Deprecated->f.LoadMatrixf(m);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glLoadIdentity()
-{
-    d_1_0_Deprecated->f.LoadIdentity();
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
-{
-    d_1_0_Deprecated->f.Frustum(left, right, bottom, top, zNear, zFar);
-}
-
-inline GLboolean QOpenGLFunctions_4_0_Compatibility::glIsList(GLuint list)
-{
-    return d_1_0_Deprecated->f.IsList(list);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetTexGeniv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetTexGenfv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
-{
-    d_1_0_Deprecated->f.GetTexGendv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetTexEnviv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetTexEnviv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetTexEnvfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetPolygonStipple(GLubyte *mask)
-{
-    d_1_0_Deprecated->f.GetPolygonStipple(mask);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetPixelMapusv(GLenum map, GLushort *values)
-{
-    d_1_0_Deprecated->f.GetPixelMapusv(map, values);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetPixelMapuiv(GLenum map, GLuint *values)
-{
-    d_1_0_Deprecated->f.GetPixelMapuiv(map, values);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetPixelMapfv(GLenum map, GLfloat *values)
-{
-    d_1_0_Deprecated->f.GetPixelMapfv(map, values);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetMaterialiv(GLenum face, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetMaterialiv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetMaterialfv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetMapiv(GLenum target, GLenum query, GLint *v)
-{
-    d_1_0_Deprecated->f.GetMapiv(target, query, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetMapfv(GLenum target, GLenum query, GLfloat *v)
-{
-    d_1_0_Deprecated->f.GetMapfv(target, query, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetMapdv(GLenum target, GLenum query, GLdouble *v)
-{
-    d_1_0_Deprecated->f.GetMapdv(target, query, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetLightiv(GLenum light, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetLightiv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetLightfv(GLenum light, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetLightfv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetClipPlane(GLenum plane, GLdouble *equation)
-{
-    d_1_0_Deprecated->f.GetClipPlane(plane, equation);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Deprecated->f.DrawPixels(width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
-{
-    d_1_0_Deprecated->f.CopyPixels(x, y, width, height, type);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values)
-{
-    d_1_0_Deprecated->f.PixelMapusv(map, mapsize, values);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values)
-{
-    d_1_0_Deprecated->f.PixelMapuiv(map, mapsize, values);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values)
-{
-    d_1_0_Deprecated->f.PixelMapfv(map, mapsize, values);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glPixelTransferi(GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.PixelTransferi(pname, param);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glPixelTransferf(GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.PixelTransferf(pname, param);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glPixelZoom(GLfloat xfactor, GLfloat yfactor)
-{
-    d_1_0_Deprecated->f.PixelZoom(xfactor, yfactor);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glAlphaFunc(GLenum func, GLfloat ref)
-{
-    d_1_0_Deprecated->f.AlphaFunc(func, ref);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glEvalPoint2(GLint i, GLint j)
-{
-    d_1_0_Deprecated->f.EvalPoint2(i, j);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
-{
-    d_1_0_Deprecated->f.EvalMesh2(mode, i1, i2, j1, j2);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glEvalPoint1(GLint i)
-{
-    d_1_0_Deprecated->f.EvalPoint1(i);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glEvalMesh1(GLenum mode, GLint i1, GLint i2)
-{
-    d_1_0_Deprecated->f.EvalMesh1(mode, i1, i2);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glEvalCoord2fv(const GLfloat *u)
-{
-    d_1_0_Deprecated->f.EvalCoord2fv(u);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glEvalCoord2f(GLfloat u, GLfloat v)
-{
-    d_1_0_Deprecated->f.EvalCoord2f(u, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glEvalCoord2dv(const GLdouble *u)
-{
-    d_1_0_Deprecated->f.EvalCoord2dv(u);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glEvalCoord2d(GLdouble u, GLdouble v)
-{
-    d_1_0_Deprecated->f.EvalCoord2d(u, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glEvalCoord1fv(const GLfloat *u)
-{
-    d_1_0_Deprecated->f.EvalCoord1fv(u);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glEvalCoord1f(GLfloat u)
-{
-    d_1_0_Deprecated->f.EvalCoord1f(u);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glEvalCoord1dv(const GLdouble *u)
-{
-    d_1_0_Deprecated->f.EvalCoord1dv(u);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glEvalCoord1d(GLdouble u)
-{
-    d_1_0_Deprecated->f.EvalCoord1d(u);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
-{
-    d_1_0_Deprecated->f.MapGrid2f(un, u1, u2, vn, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
-{
-    d_1_0_Deprecated->f.MapGrid2d(un, u1, u2, vn, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
-{
-    d_1_0_Deprecated->f.MapGrid1f(un, u1, u2);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
-{
-    d_1_0_Deprecated->f.MapGrid1d(un, u1, u2);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
-{
-    d_1_0_Deprecated->f.Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
-{
-    d_1_0_Deprecated->f.Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
-{
-    d_1_0_Deprecated->f.Map1f(target, u1, u2, stride, order, points);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
-{
-    d_1_0_Deprecated->f.Map1d(target, u1, u2, stride, order, points);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glPushAttrib(GLbitfield mask)
-{
-    d_1_0_Deprecated->f.PushAttrib(mask);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glPopAttrib()
-{
-    d_1_0_Deprecated->f.PopAttrib();
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glAccum(GLenum op, GLfloat value)
-{
-    d_1_0_Deprecated->f.Accum(op, value);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glIndexMask(GLuint mask)
-{
-    d_1_0_Deprecated->f.IndexMask(mask);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glClearIndex(GLfloat c)
-{
-    d_1_0_Deprecated->f.ClearIndex(c);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Deprecated->f.ClearAccum(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glPushName(GLuint name)
-{
-    d_1_0_Deprecated->f.PushName(name);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glPopName()
-{
-    d_1_0_Deprecated->f.PopName();
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glPassThrough(GLfloat token)
-{
-    d_1_0_Deprecated->f.PassThrough(token);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glLoadName(GLuint name)
-{
-    d_1_0_Deprecated->f.LoadName(name);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glInitNames()
-{
-    d_1_0_Deprecated->f.InitNames();
-}
-
-inline GLint QOpenGLFunctions_4_0_Compatibility::glRenderMode(GLenum mode)
-{
-    return d_1_0_Deprecated->f.RenderMode(mode);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glSelectBuffer(GLsizei size, GLuint *buffer)
-{
-    d_1_0_Deprecated->f.SelectBuffer(size, buffer);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
-{
-    d_1_0_Deprecated->f.FeedbackBuffer(size, type, buffer);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexGeniv(GLenum coord, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.TexGeniv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexGeni(GLenum coord, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.TexGeni(coord, pname, param);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.TexGenfv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexGenf(GLenum coord, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.TexGenf(coord, pname, param);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
-{
-    d_1_0_Deprecated->f.TexGendv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexGend(GLenum coord, GLenum pname, GLdouble param)
-{
-    d_1_0_Deprecated->f.TexGend(coord, pname, param);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexEnviv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.TexEnviv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexEnvi(GLenum target, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.TexEnvi(target, pname, param);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.TexEnvfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexEnvf(GLenum target, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.TexEnvf(target, pname, param);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glShadeModel(GLenum mode)
-{
-    d_1_0_Deprecated->f.ShadeModel(mode);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glPolygonStipple(const GLubyte *mask)
-{
-    d_1_0_Deprecated->f.PolygonStipple(mask);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMaterialiv(GLenum face, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.Materialiv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMateriali(GLenum face, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.Materiali(face, pname, param);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.Materialfv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMaterialf(GLenum face, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.Materialf(face, pname, param);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glLineStipple(GLint factor, GLushort pattern)
-{
-    d_1_0_Deprecated->f.LineStipple(factor, pattern);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glLightModeliv(GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.LightModeliv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glLightModeli(GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.LightModeli(pname, param);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glLightModelfv(GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.LightModelfv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glLightModelf(GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.LightModelf(pname, param);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glLightiv(GLenum light, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.Lightiv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glLighti(GLenum light, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.Lighti(light, pname, param);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glLightfv(GLenum light, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.Lightfv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glLightf(GLenum light, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.Lightf(light, pname, param);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glFogiv(GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.Fogiv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glFogi(GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.Fogi(pname, param);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glFogfv(GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.Fogfv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glFogf(GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.Fogf(pname, param);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glColorMaterial(GLenum face, GLenum mode)
-{
-    d_1_0_Deprecated->f.ColorMaterial(face, mode);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glClipPlane(GLenum plane, const GLdouble *equation)
-{
-    d_1_0_Deprecated->f.ClipPlane(plane, equation);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertex4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Vertex4sv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
-{
-    d_1_0_Deprecated->f.Vertex4s(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertex4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Vertex4iv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertex4i(GLint x, GLint y, GLint z, GLint w)
-{
-    d_1_0_Deprecated->f.Vertex4i(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertex4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Vertex4fv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    d_1_0_Deprecated->f.Vertex4f(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertex4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Vertex4dv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_1_0_Deprecated->f.Vertex4d(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertex3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Vertex3sv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertex3s(GLshort x, GLshort y, GLshort z)
-{
-    d_1_0_Deprecated->f.Vertex3s(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertex3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Vertex3iv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertex3i(GLint x, GLint y, GLint z)
-{
-    d_1_0_Deprecated->f.Vertex3i(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertex3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Vertex3fv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertex3f(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Vertex3f(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertex3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Vertex3dv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertex3d(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Vertex3d(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertex2sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Vertex2sv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertex2s(GLshort x, GLshort y)
-{
-    d_1_0_Deprecated->f.Vertex2s(x, y);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertex2iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Vertex2iv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertex2i(GLint x, GLint y)
-{
-    d_1_0_Deprecated->f.Vertex2i(x, y);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertex2fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Vertex2fv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertex2f(GLfloat x, GLfloat y)
-{
-    d_1_0_Deprecated->f.Vertex2f(x, y);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertex2dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Vertex2dv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertex2d(GLdouble x, GLdouble y)
-{
-    d_1_0_Deprecated->f.Vertex2d(x, y);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord4sv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
-{
-    d_1_0_Deprecated->f.TexCoord4s(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord4iv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
-{
-    d_1_0_Deprecated->f.TexCoord4i(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord4fv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
-{
-    d_1_0_Deprecated->f.TexCoord4f(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord4dv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
-{
-    d_1_0_Deprecated->f.TexCoord4d(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord3sv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord3s(GLshort s, GLshort t, GLshort r)
-{
-    d_1_0_Deprecated->f.TexCoord3s(s, t, r);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord3iv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord3i(GLint s, GLint t, GLint r)
-{
-    d_1_0_Deprecated->f.TexCoord3i(s, t, r);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord3fv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
-{
-    d_1_0_Deprecated->f.TexCoord3f(s, t, r);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord3dv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
-{
-    d_1_0_Deprecated->f.TexCoord3d(s, t, r);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord2sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord2sv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord2s(GLshort s, GLshort t)
-{
-    d_1_0_Deprecated->f.TexCoord2s(s, t);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord2iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord2iv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord2i(GLint s, GLint t)
-{
-    d_1_0_Deprecated->f.TexCoord2i(s, t);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord2fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord2fv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord2f(GLfloat s, GLfloat t)
-{
-    d_1_0_Deprecated->f.TexCoord2f(s, t);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord2dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord2dv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord2d(GLdouble s, GLdouble t)
-{
-    d_1_0_Deprecated->f.TexCoord2d(s, t);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord1sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord1sv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord1s(GLshort s)
-{
-    d_1_0_Deprecated->f.TexCoord1s(s);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord1iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord1iv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord1i(GLint s)
-{
-    d_1_0_Deprecated->f.TexCoord1i(s);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord1fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord1fv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord1f(GLfloat s)
-{
-    d_1_0_Deprecated->f.TexCoord1f(s);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord1dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord1dv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord1d(GLdouble s)
-{
-    d_1_0_Deprecated->f.TexCoord1d(s);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glRectsv(const GLshort *v1, const GLshort *v2)
-{
-    d_1_0_Deprecated->f.Rectsv(v1, v2);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
-{
-    d_1_0_Deprecated->f.Rects(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glRectiv(const GLint *v1, const GLint *v2)
-{
-    d_1_0_Deprecated->f.Rectiv(v1, v2);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
-{
-    d_1_0_Deprecated->f.Recti(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glRectfv(const GLfloat *v1, const GLfloat *v2)
-{
-    d_1_0_Deprecated->f.Rectfv(v1, v2);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
-{
-    d_1_0_Deprecated->f.Rectf(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glRectdv(const GLdouble *v1, const GLdouble *v2)
-{
-    d_1_0_Deprecated->f.Rectdv(v1, v2);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
-{
-    d_1_0_Deprecated->f.Rectd(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glRasterPos4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.RasterPos4sv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
-{
-    d_1_0_Deprecated->f.RasterPos4s(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glRasterPos4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.RasterPos4iv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
-{
-    d_1_0_Deprecated->f.RasterPos4i(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glRasterPos4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.RasterPos4fv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    d_1_0_Deprecated->f.RasterPos4f(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glRasterPos4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.RasterPos4dv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_1_0_Deprecated->f.RasterPos4d(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glRasterPos3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.RasterPos3sv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glRasterPos3s(GLshort x, GLshort y, GLshort z)
-{
-    d_1_0_Deprecated->f.RasterPos3s(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glRasterPos3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.RasterPos3iv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glRasterPos3i(GLint x, GLint y, GLint z)
-{
-    d_1_0_Deprecated->f.RasterPos3i(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glRasterPos3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.RasterPos3fv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.RasterPos3f(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glRasterPos3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.RasterPos3dv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.RasterPos3d(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glRasterPos2sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.RasterPos2sv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glRasterPos2s(GLshort x, GLshort y)
-{
-    d_1_0_Deprecated->f.RasterPos2s(x, y);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glRasterPos2iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.RasterPos2iv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glRasterPos2i(GLint x, GLint y)
-{
-    d_1_0_Deprecated->f.RasterPos2i(x, y);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glRasterPos2fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.RasterPos2fv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glRasterPos2f(GLfloat x, GLfloat y)
-{
-    d_1_0_Deprecated->f.RasterPos2f(x, y);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glRasterPos2dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.RasterPos2dv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glRasterPos2d(GLdouble x, GLdouble y)
-{
-    d_1_0_Deprecated->f.RasterPos2d(x, y);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glNormal3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Normal3sv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glNormal3s(GLshort nx, GLshort ny, GLshort nz)
-{
-    d_1_0_Deprecated->f.Normal3s(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glNormal3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Normal3iv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glNormal3i(GLint nx, GLint ny, GLint nz)
-{
-    d_1_0_Deprecated->f.Normal3i(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glNormal3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Normal3fv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
-{
-    d_1_0_Deprecated->f.Normal3f(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glNormal3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Normal3dv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
-{
-    d_1_0_Deprecated->f.Normal3d(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glNormal3bv(const GLbyte *v)
-{
-    d_1_0_Deprecated->f.Normal3bv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
-{
-    d_1_0_Deprecated->f.Normal3b(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glIndexsv(const GLshort *c)
-{
-    d_1_0_Deprecated->f.Indexsv(c);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glIndexs(GLshort c)
-{
-    d_1_0_Deprecated->f.Indexs(c);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glIndexiv(const GLint *c)
-{
-    d_1_0_Deprecated->f.Indexiv(c);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glIndexi(GLint c)
-{
-    d_1_0_Deprecated->f.Indexi(c);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glIndexfv(const GLfloat *c)
-{
-    d_1_0_Deprecated->f.Indexfv(c);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glIndexf(GLfloat c)
-{
-    d_1_0_Deprecated->f.Indexf(c);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glIndexdv(const GLdouble *c)
-{
-    d_1_0_Deprecated->f.Indexdv(c);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glIndexd(GLdouble c)
-{
-    d_1_0_Deprecated->f.Indexd(c);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glEnd()
-{
-    d_1_0_Deprecated->f.End();
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glEdgeFlagv(const GLboolean *flag)
-{
-    d_1_0_Deprecated->f.EdgeFlagv(flag);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glEdgeFlag(GLboolean flag)
-{
-    d_1_0_Deprecated->f.EdgeFlag(flag);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glColor4usv(const GLushort *v)
-{
-    d_1_0_Deprecated->f.Color4usv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
-{
-    d_1_0_Deprecated->f.Color4us(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glColor4uiv(const GLuint *v)
-{
-    d_1_0_Deprecated->f.Color4uiv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
-{
-    d_1_0_Deprecated->f.Color4ui(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glColor4ubv(const GLubyte *v)
-{
-    d_1_0_Deprecated->f.Color4ubv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
-{
-    d_1_0_Deprecated->f.Color4ub(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glColor4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Color4sv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
-{
-    d_1_0_Deprecated->f.Color4s(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glColor4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Color4iv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
-{
-    d_1_0_Deprecated->f.Color4i(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glColor4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Color4fv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Deprecated->f.Color4f(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glColor4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Color4dv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
-{
-    d_1_0_Deprecated->f.Color4d(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glColor4bv(const GLbyte *v)
-{
-    d_1_0_Deprecated->f.Color4bv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
-{
-    d_1_0_Deprecated->f.Color4b(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glColor3usv(const GLushort *v)
-{
-    d_1_0_Deprecated->f.Color3usv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glColor3us(GLushort red, GLushort green, GLushort blue)
-{
-    d_1_0_Deprecated->f.Color3us(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glColor3uiv(const GLuint *v)
-{
-    d_1_0_Deprecated->f.Color3uiv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glColor3ui(GLuint red, GLuint green, GLuint blue)
-{
-    d_1_0_Deprecated->f.Color3ui(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glColor3ubv(const GLubyte *v)
-{
-    d_1_0_Deprecated->f.Color3ubv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
-{
-    d_1_0_Deprecated->f.Color3ub(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glColor3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Color3sv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glColor3s(GLshort red, GLshort green, GLshort blue)
-{
-    d_1_0_Deprecated->f.Color3s(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glColor3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Color3iv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glColor3i(GLint red, GLint green, GLint blue)
-{
-    d_1_0_Deprecated->f.Color3i(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glColor3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Color3fv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glColor3f(GLfloat red, GLfloat green, GLfloat blue)
-{
-    d_1_0_Deprecated->f.Color3f(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glColor3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Color3dv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glColor3d(GLdouble red, GLdouble green, GLdouble blue)
-{
-    d_1_0_Deprecated->f.Color3d(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glColor3bv(const GLbyte *v)
-{
-    d_1_0_Deprecated->f.Color3bv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glColor3b(GLbyte red, GLbyte green, GLbyte blue)
-{
-    d_1_0_Deprecated->f.Color3b(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
-{
-    d_1_0_Deprecated->f.Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glBegin(GLenum mode)
-{
-    d_1_0_Deprecated->f.Begin(mode);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glListBase(GLuint base)
-{
-    d_1_0_Deprecated->f.ListBase(base);
-}
-
-inline GLuint QOpenGLFunctions_4_0_Compatibility::glGenLists(GLsizei range)
-{
-    return d_1_0_Deprecated->f.GenLists(range);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glDeleteLists(GLuint list, GLsizei range)
-{
-    d_1_0_Deprecated->f.DeleteLists(list, range);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glCallLists(GLsizei n, GLenum type, const GLvoid *lists)
-{
-    d_1_0_Deprecated->f.CallLists(n, type, lists);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glCallList(GLuint list)
-{
-    d_1_0_Deprecated->f.CallList(list);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glEndList()
-{
-    d_1_0_Deprecated->f.EndList();
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glNewList(GLuint list, GLenum mode)
-{
-    d_1_0_Deprecated->f.NewList(list, mode);
-}
-
-
-// OpenGL 1.1 deprecated functions
-inline void QOpenGLFunctions_4_0_Compatibility::glPushClientAttrib(GLbitfield mask)
-{
-    d_1_1_Deprecated->f.PushClientAttrib(mask);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glPopClientAttrib()
-{
-    d_1_1_Deprecated->f.PopClientAttrib();
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities)
-{
-    d_1_1_Deprecated->f.PrioritizeTextures(n, textures, priorities);
-}
-
-inline GLboolean QOpenGLFunctions_4_0_Compatibility::glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
-{
-    return d_1_1_Deprecated->f.AreTexturesResident(n, textures, residences);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.VertexPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.TexCoordPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.NormalPointer(type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.InterleavedArrays(format, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.IndexPointer(type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glEnableClientState(GLenum array)
-{
-    d_1_1_Deprecated->f.EnableClientState(array);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.EdgeFlagPointer(stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glDisableClientState(GLenum array)
-{
-    d_1_1_Deprecated->f.DisableClientState(array);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.ColorPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glArrayElement(GLint i)
-{
-    d_1_1_Deprecated->f.ArrayElement(i);
-}
-
-
-// OpenGL 1.2 deprecated functions
-inline void QOpenGLFunctions_4_0_Compatibility::glResetMinmax(GLenum target)
-{
-    d_1_2_Deprecated->f.ResetMinmax(target);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glResetHistogram(GLenum target)
-{
-    d_1_2_Deprecated->f.ResetHistogram(target);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMinmax(GLenum target, GLenum internalformat, GLboolean sink)
-{
-    d_1_2_Deprecated->f.Minmax(target, internalformat, sink);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
-{
-    d_1_2_Deprecated->f.Histogram(target, width, internalformat, sink);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetMinmaxParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetMinmaxParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
-{
-    d_1_2_Deprecated->f.GetMinmax(target, reset, format, type, values);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetHistogramParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetHistogramParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
-{
-    d_1_2_Deprecated->f.GetHistogram(target, reset, format, type, values);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column)
-{
-    d_1_2_Deprecated->f.SeparableFilter2D(target, internalformat, width, height, format, type, row, column);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span)
-{
-    d_1_2_Deprecated->f.GetSeparableFilter(target, format, type, row, column, span);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetConvolutionParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetConvolutionParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image)
-{
-    d_1_2_Deprecated->f.GetConvolutionFilter(target, format, type, image);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_2_Deprecated->f.CopyConvolutionFilter2D(target, internalformat, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
-{
-    d_1_2_Deprecated->f.CopyConvolutionFilter1D(target, internalformat, x, y, width);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glConvolutionParameteri(GLenum target, GLenum pname, GLint params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameteri(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameterf(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image)
-{
-    d_1_2_Deprecated->f.ConvolutionFilter2D(target, internalformat, width, height, format, type, image);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image)
-{
-    d_1_2_Deprecated->f.ConvolutionFilter1D(target, internalformat, width, format, type, image);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
-{
-    d_1_2_Deprecated->f.CopyColorSubTable(target, start, x, y, width);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data)
-{
-    d_1_2_Deprecated->f.ColorSubTable(target, start, count, format, type, data);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetColorTableParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetColorTableParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table)
-{
-    d_1_2_Deprecated->f.GetColorTable(target, format, type, table);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
-{
-    d_1_2_Deprecated->f.CopyColorTable(target, internalformat, x, y, width);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_2_Deprecated->f.ColorTableParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_2_Deprecated->f.ColorTableParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table)
-{
-    d_1_2_Deprecated->f.ColorTable(target, internalformat, width, format, type, table);
-}
-
-
-// OpenGL 1.3 deprecated functions
-inline void QOpenGLFunctions_4_0_Compatibility::glMultTransposeMatrixd(const GLdouble *m)
-{
-    d_1_3_Deprecated->f.MultTransposeMatrixd(m);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMultTransposeMatrixf(const GLfloat *m)
-{
-    d_1_3_Deprecated->f.MultTransposeMatrixf(m);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glLoadTransposeMatrixd(const GLdouble *m)
-{
-    d_1_3_Deprecated->f.LoadTransposeMatrixd(m);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glLoadTransposeMatrixf(const GLfloat *m)
-{
-    d_1_3_Deprecated->f.LoadTransposeMatrixf(m);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord4sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4sv(target, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4s(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord4iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4iv(target, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4i(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord4fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4fv(target, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4f(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord4dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4dv(target, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4d(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord3sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3sv(target, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3s(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord3iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3iv(target, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3i(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord3fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3fv(target, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3f(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord3dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3dv(target, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3d(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord2sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2sv(target, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord2s(GLenum target, GLshort s, GLshort t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2s(target, s, t);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord2iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2iv(target, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord2i(GLenum target, GLint s, GLint t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2i(target, s, t);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord2fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2fv(target, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2f(target, s, t);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord2dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2dv(target, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2d(target, s, t);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord1sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1sv(target, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord1s(GLenum target, GLshort s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1s(target, s);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord1iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1iv(target, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord1i(GLenum target, GLint s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1i(target, s);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord1fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1fv(target, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord1f(GLenum target, GLfloat s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1f(target, s);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord1dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1dv(target, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord1d(GLenum target, GLdouble s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1d(target, s);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glClientActiveTexture(GLenum texture)
-{
-    d_1_3_Deprecated->f.ClientActiveTexture(texture);
-}
-
-
-// OpenGL 1.4 deprecated functions
-inline void QOpenGLFunctions_4_0_Compatibility::glWindowPos3sv(const GLshort *v)
-{
-    d_1_4_Deprecated->f.WindowPos3sv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glWindowPos3s(GLshort x, GLshort y, GLshort z)
-{
-    d_1_4_Deprecated->f.WindowPos3s(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glWindowPos3iv(const GLint *v)
-{
-    d_1_4_Deprecated->f.WindowPos3iv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glWindowPos3i(GLint x, GLint y, GLint z)
-{
-    d_1_4_Deprecated->f.WindowPos3i(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glWindowPos3fv(const GLfloat *v)
-{
-    d_1_4_Deprecated->f.WindowPos3fv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glWindowPos3f(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_4_Deprecated->f.WindowPos3f(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glWindowPos3dv(const GLdouble *v)
-{
-    d_1_4_Deprecated->f.WindowPos3dv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glWindowPos3d(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_4_Deprecated->f.WindowPos3d(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glWindowPos2sv(const GLshort *v)
-{
-    d_1_4_Deprecated->f.WindowPos2sv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glWindowPos2s(GLshort x, GLshort y)
-{
-    d_1_4_Deprecated->f.WindowPos2s(x, y);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glWindowPos2iv(const GLint *v)
-{
-    d_1_4_Deprecated->f.WindowPos2iv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glWindowPos2i(GLint x, GLint y)
-{
-    d_1_4_Deprecated->f.WindowPos2i(x, y);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glWindowPos2fv(const GLfloat *v)
-{
-    d_1_4_Deprecated->f.WindowPos2fv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glWindowPos2f(GLfloat x, GLfloat y)
-{
-    d_1_4_Deprecated->f.WindowPos2f(x, y);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glWindowPos2dv(const GLdouble *v)
-{
-    d_1_4_Deprecated->f.WindowPos2dv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glWindowPos2d(GLdouble x, GLdouble y)
-{
-    d_1_4_Deprecated->f.WindowPos2d(x, y);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_4_Deprecated->f.SecondaryColorPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glSecondaryColor3usv(const GLushort *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3usv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glSecondaryColor3us(GLushort red, GLushort green, GLushort blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3us(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glSecondaryColor3uiv(const GLuint *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3uiv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3ui(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glSecondaryColor3ubv(const GLubyte *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3ubv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3ub(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glSecondaryColor3sv(const GLshort *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3sv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glSecondaryColor3s(GLshort red, GLshort green, GLshort blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3s(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glSecondaryColor3iv(const GLint *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3iv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glSecondaryColor3i(GLint red, GLint green, GLint blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3i(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glSecondaryColor3fv(const GLfloat *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3fv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3f(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glSecondaryColor3dv(const GLdouble *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3dv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3d(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glSecondaryColor3bv(const GLbyte *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3bv(v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3b(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glFogCoordPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_4_Deprecated->f.FogCoordPointer(type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glFogCoorddv(const GLdouble *coord)
-{
-    d_1_4_Deprecated->f.FogCoorddv(coord);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glFogCoordd(GLdouble coord)
-{
-    d_1_4_Deprecated->f.FogCoordd(coord);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glFogCoordfv(const GLfloat *coord)
-{
-    d_1_4_Deprecated->f.FogCoordfv(coord);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glFogCoordf(GLfloat coord)
-{
-    d_1_4_Deprecated->f.FogCoordf(coord);
-}
-
-
-// OpenGL 1.5 deprecated functions
-
-// OpenGL 2.0 deprecated functions
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4usv(GLuint index, const GLushort *v)
-{
-    d_2_0_Core->f.VertexAttrib4usv(index, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4uiv(GLuint index, const GLuint *v)
-{
-    d_2_0_Core->f.VertexAttrib4uiv(index, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4ubv(GLuint index, const GLubyte *v)
-{
-    d_2_0_Core->f.VertexAttrib4ubv(index, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4sv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib4sv(index, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
-{
-    d_2_0_Core->f.VertexAttrib4s(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4iv(GLuint index, const GLint *v)
-{
-    d_2_0_Core->f.VertexAttrib4iv(index, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4fv(GLuint index, const GLfloat *v)
-{
-    d_2_0_Core->f.VertexAttrib4fv(index, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    d_2_0_Core->f.VertexAttrib4f(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4dv(GLuint index, const GLdouble *v)
-{
-    d_2_0_Core->f.VertexAttrib4dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_2_0_Core->f.VertexAttrib4d(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4bv(GLuint index, const GLbyte *v)
-{
-    d_2_0_Core->f.VertexAttrib4bv(index, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4Nusv(GLuint index, const GLushort *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nusv(index, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4Nuiv(GLuint index, const GLuint *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nuiv(index, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4Nubv(GLuint index, const GLubyte *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nubv(index, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
-{
-    d_2_0_Core->f.VertexAttrib4Nub(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4Nsv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nsv(index, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4Niv(GLuint index, const GLint *v)
-{
-    d_2_0_Core->f.VertexAttrib4Niv(index, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4Nbv(GLuint index, const GLbyte *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nbv(index, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib3sv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib3sv(index, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
-{
-    d_2_0_Core->f.VertexAttrib3s(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib3fv(GLuint index, const GLfloat *v)
-{
-    d_2_0_Core->f.VertexAttrib3fv(index, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
-{
-    d_2_0_Core->f.VertexAttrib3f(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib3dv(GLuint index, const GLdouble *v)
-{
-    d_2_0_Core->f.VertexAttrib3dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
-{
-    d_2_0_Core->f.VertexAttrib3d(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib2sv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib2sv(index, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib2s(GLuint index, GLshort x, GLshort y)
-{
-    d_2_0_Core->f.VertexAttrib2s(index, x, y);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib2fv(GLuint index, const GLfloat *v)
-{
-    d_2_0_Core->f.VertexAttrib2fv(index, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
-{
-    d_2_0_Core->f.VertexAttrib2f(index, x, y);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib2dv(GLuint index, const GLdouble *v)
-{
-    d_2_0_Core->f.VertexAttrib2dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
-{
-    d_2_0_Core->f.VertexAttrib2d(index, x, y);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib1sv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib1sv(index, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib1s(GLuint index, GLshort x)
-{
-    d_2_0_Core->f.VertexAttrib1s(index, x);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib1fv(GLuint index, const GLfloat *v)
-{
-    d_2_0_Core->f.VertexAttrib1fv(index, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib1f(GLuint index, GLfloat x)
-{
-    d_2_0_Core->f.VertexAttrib1f(index, x);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib1dv(GLuint index, const GLdouble *v)
-{
-    d_2_0_Core->f.VertexAttrib1dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib1d(GLuint index, GLdouble x)
-{
-    d_2_0_Core->f.VertexAttrib1d(index, x);
-}
-
-
-// OpenGL 2.1 deprecated functions
-
-// OpenGL 3.0 deprecated functions
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI4usv(GLuint index, const GLushort *v)
-{
-    d_3_0_Core->f.VertexAttribI4usv(index, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI4ubv(GLuint index, const GLubyte *v)
-{
-    d_3_0_Core->f.VertexAttribI4ubv(index, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI4sv(GLuint index, const GLshort *v)
-{
-    d_3_0_Core->f.VertexAttribI4sv(index, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI4bv(GLuint index, const GLbyte *v)
-{
-    d_3_0_Core->f.VertexAttribI4bv(index, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI4uiv(GLuint index, const GLuint *v)
-{
-    d_3_0_Core->f.VertexAttribI4uiv(index, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI3uiv(GLuint index, const GLuint *v)
-{
-    d_3_0_Core->f.VertexAttribI3uiv(index, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI2uiv(GLuint index, const GLuint *v)
-{
-    d_3_0_Core->f.VertexAttribI2uiv(index, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI1uiv(GLuint index, const GLuint *v)
-{
-    d_3_0_Core->f.VertexAttribI1uiv(index, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI4iv(GLuint index, const GLint *v)
-{
-    d_3_0_Core->f.VertexAttribI4iv(index, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI3iv(GLuint index, const GLint *v)
-{
-    d_3_0_Core->f.VertexAttribI3iv(index, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI2iv(GLuint index, const GLint *v)
-{
-    d_3_0_Core->f.VertexAttribI2iv(index, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI1iv(GLuint index, const GLint *v)
-{
-    d_3_0_Core->f.VertexAttribI1iv(index, v);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
-{
-    d_3_0_Core->f.VertexAttribI4ui(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z)
-{
-    d_3_0_Core->f.VertexAttribI3ui(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI2ui(GLuint index, GLuint x, GLuint y)
-{
-    d_3_0_Core->f.VertexAttribI2ui(index, x, y);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI1ui(GLuint index, GLuint x)
-{
-    d_3_0_Core->f.VertexAttribI1ui(index, x);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
-{
-    d_3_0_Core->f.VertexAttribI4i(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI3i(GLuint index, GLint x, GLint y, GLint z)
-{
-    d_3_0_Core->f.VertexAttribI3i(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI2i(GLuint index, GLint x, GLint y)
-{
-    d_3_0_Core->f.VertexAttribI2i(index, x, y);
-}
-
-inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI1i(GLuint index, GLint x)
-{
-    d_3_0_Core->f.VertexAttribI1i(index, x);
-}
-
-
-// OpenGL 3.1 deprecated functions
-
-// OpenGL 3.2 deprecated functions
-
-// OpenGL 3.3 deprecated functions
-
-// OpenGL 4.0 deprecated functions
-
-
-QT_END_NAMESPACE
-
-#endif // QT_NO_OPENGL && !QT_OPENGL_ES_2
-
-#endif
diff --git a/src/gui/opengl/qopenglfunctions_4_0_core.cpp b/src/gui/opengl/qopenglfunctions_4_0_core.cpp
deleted file mode 100644
index 60453d147c..0000000000
--- a/src/gui/opengl/qopenglfunctions_4_0_core.cpp
+++ /dev/null
@@ -1,233 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#include "qopenglfunctions_4_0_core.h"
-#include "qopenglcontext.h"
-
-QT_BEGIN_NAMESPACE
-
-/*!
-    \class QOpenGLFunctions_4_0_Core
-    \inmodule QtGui
-    \since 5.1
-    \wrapper
-    \brief The QOpenGLFunctions_4_0_Core class provides all functions for OpenGL 4.0 core profile.
-
-    This class is a wrapper for functions from OpenGL 4.0 core profile.
-    See reference pages on \l {http://www.opengl.org/sdk/docs/}{opengl.org}
-    for function documentation.
-
-    \sa QAbstractOpenGLFunctions
-*/
-
-QOpenGLFunctions_4_0_Core::QOpenGLFunctions_4_0_Core()
- : QAbstractOpenGLFunctions()
- , d_1_0_Core(nullptr)
- , d_1_1_Core(nullptr)
- , d_1_2_Core(nullptr)
- , d_1_3_Core(nullptr)
- , d_1_4_Core(nullptr)
- , d_1_5_Core(nullptr)
- , d_2_0_Core(nullptr)
- , d_2_1_Core(nullptr)
- , d_3_0_Core(nullptr)
- , d_3_1_Core(nullptr)
- , d_3_2_Core(nullptr)
- , d_3_3_Core(nullptr)
- , d_4_0_Core(nullptr)
-{
-}
-
-QOpenGLFunctions_4_0_Core::~QOpenGLFunctions_4_0_Core()
-{
-    if (d_1_0_Core) {
-        d_1_0_Core->refs.deref();
-        Q_ASSERT(d_1_0_Core->refs.loadRelaxed());
-    }
-    if (d_1_1_Core) {
-        d_1_1_Core->refs.deref();
-        Q_ASSERT(d_1_1_Core->refs.loadRelaxed());
-    }
-    if (d_1_2_Core) {
-        d_1_2_Core->refs.deref();
-        Q_ASSERT(d_1_2_Core->refs.loadRelaxed());
-    }
-    if (d_1_3_Core) {
-        d_1_3_Core->refs.deref();
-        Q_ASSERT(d_1_3_Core->refs.loadRelaxed());
-    }
-    if (d_1_4_Core) {
-        d_1_4_Core->refs.deref();
-        Q_ASSERT(d_1_4_Core->refs.loadRelaxed());
-    }
-    if (d_1_5_Core) {
-        d_1_5_Core->refs.deref();
-        Q_ASSERT(d_1_5_Core->refs.loadRelaxed());
-    }
-    if (d_2_0_Core) {
-        d_2_0_Core->refs.deref();
-        Q_ASSERT(d_2_0_Core->refs.loadRelaxed());
-    }
-    if (d_2_1_Core) {
-        d_2_1_Core->refs.deref();
-        Q_ASSERT(d_2_1_Core->refs.loadRelaxed());
-    }
-    if (d_3_0_Core) {
-        d_3_0_Core->refs.deref();
-        Q_ASSERT(d_3_0_Core->refs.loadRelaxed());
-    }
-    if (d_3_1_Core) {
-        d_3_1_Core->refs.deref();
-        Q_ASSERT(d_3_1_Core->refs.loadRelaxed());
-    }
-    if (d_3_2_Core) {
-        d_3_2_Core->refs.deref();
-        Q_ASSERT(d_3_2_Core->refs.loadRelaxed());
-    }
-    if (d_3_3_Core) {
-        d_3_3_Core->refs.deref();
-        Q_ASSERT(d_3_3_Core->refs.loadRelaxed());
-    }
-    if (d_4_0_Core) {
-        d_4_0_Core->refs.deref();
-        Q_ASSERT(d_4_0_Core->refs.loadRelaxed());
-    }
-}
-
-bool QOpenGLFunctions_4_0_Core::initializeOpenGLFunctions()
-{
-    if ( isInitialized() )
-        return true;
-
-    QOpenGLContext* context = QOpenGLContext::currentContext();
-
-    // If owned by a context object make sure it is current.
-    // Also check that current context is capable of resolving all needed functions
-    if (((owningContext() && owningContext() == context) || !owningContext())
-        && QOpenGLFunctions_4_0_Core::isContextCompatible(context))
-    {
-        // Associate with private implementation, creating if necessary
-        // Function pointers in the backends are resolved at creation time
-        QOpenGLVersionFunctionsBackend* d = nullptr;
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        d_1_3_Core = static_cast<QOpenGLFunctions_1_3_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        d_1_4_Core = static_cast<QOpenGLFunctions_1_4_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        d_1_5_Core = static_cast<QOpenGLFunctions_1_5_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        d_2_0_Core = static_cast<QOpenGLFunctions_2_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        d_2_1_Core = static_cast<QOpenGLFunctions_2_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        d_3_0_Core = static_cast<QOpenGLFunctions_3_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
-        d_3_1_Core = static_cast<QOpenGLFunctions_3_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
-        d_3_2_Core = static_cast<QOpenGLFunctions_3_2_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_CoreBackend::versionStatus());
-        d_3_3_Core = static_cast<QOpenGLFunctions_3_3_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_0_CoreBackend::versionStatus());
-        d_4_0_Core = static_cast<QOpenGLFunctions_4_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        QAbstractOpenGLFunctions::initializeOpenGLFunctions();
-    }
-    return isInitialized();
-}
-
-bool QOpenGLFunctions_4_0_Core::isContextCompatible(QOpenGLContext *context)
-{
-    Q_ASSERT(context);
-    QSurfaceFormat f = context->format();
-    const QPair<int, int> v = qMakePair(f.majorVersion(), f.minorVersion());
-    if (v < qMakePair(4, 0))
-        return false;
-
-    return true;
-}
-
-QOpenGLVersionProfile QOpenGLFunctions_4_0_Core::versionProfile()
-{
-    QOpenGLVersionProfile v;
-    v.setVersion(4, 0);
-    v.setProfile(QSurfaceFormat::CoreProfile);
-    return v;
-}
-
-QT_END_NAMESPACE
diff --git a/src/gui/opengl/qopenglfunctions_4_0_core.h b/src/gui/opengl/qopenglfunctions_4_0_core.h
deleted file mode 100644
index 6cb55e86f7..0000000000
--- a/src/gui/opengl/qopenglfunctions_4_0_core.h
+++ /dev/null
@@ -1,2422 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#ifndef QOPENGLVERSIONFUNCTIONS_4_0_CORE_H
-#define QOPENGLVERSIONFUNCTIONS_4_0_CORE_H
-
-#include <QtGui/qtguiglobal.h>
-
-#if !defined(QT_NO_OPENGL) && !defined(QT_OPENGL_ES_2)
-
-#include <QtGui/QOpenGLVersionFunctions>
-#include <QtGui/qopenglcontext.h>
-
-QT_BEGIN_NAMESPACE
-
-class Q_GUI_EXPORT QOpenGLFunctions_4_0_Core : public QAbstractOpenGLFunctions
-{
-public:
-    QOpenGLFunctions_4_0_Core();
-    ~QOpenGLFunctions_4_0_Core();
-
-    bool initializeOpenGLFunctions() override;
-
-    // OpenGL 1.0 core functions
-    void glViewport(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glDepthRange(GLdouble nearVal, GLdouble farVal);
-    GLboolean glIsEnabled(GLenum cap);
-    void glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params);
-    void glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params);
-    void glGetTexParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
-    const GLubyte * glGetString(GLenum name);
-    void glGetIntegerv(GLenum pname, GLint *params);
-    void glGetFloatv(GLenum pname, GLfloat *params);
-    GLenum glGetError();
-    void glGetDoublev(GLenum pname, GLdouble *params);
-    void glGetBooleanv(GLenum pname, GLboolean *params);
-    void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
-    void glReadBuffer(GLenum mode);
-    void glPixelStorei(GLenum pname, GLint param);
-    void glPixelStoref(GLenum pname, GLfloat param);
-    void glDepthFunc(GLenum func);
-    void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass);
-    void glStencilFunc(GLenum func, GLint ref, GLuint mask);
-    void glLogicOp(GLenum opcode);
-    void glBlendFunc(GLenum sfactor, GLenum dfactor);
-    void glFlush();
-    void glFinish();
-    void glEnable(GLenum cap);
-    void glDisable(GLenum cap);
-    void glDepthMask(GLboolean flag);
-    void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
-    void glStencilMask(GLuint mask);
-    void glClearDepth(GLdouble depth);
-    void glClearStencil(GLint s);
-    void glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glClear(GLbitfield mask);
-    void glDrawBuffer(GLenum mode);
-    void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glTexParameteri(GLenum target, GLenum pname, GLint param);
-    void glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glTexParameterf(GLenum target, GLenum pname, GLfloat param);
-    void glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glPolygonMode(GLenum face, GLenum mode);
-    void glPointSize(GLfloat size);
-    void glLineWidth(GLfloat width);
-    void glHint(GLenum target, GLenum mode);
-    void glFrontFace(GLenum mode);
-    void glCullFace(GLenum mode);
-
-    // OpenGL 1.1 core functions
-    void glIndexubv(const GLubyte *c);
-    void glIndexub(GLubyte c);
-    GLboolean glIsTexture(GLuint texture);
-    void glGenTextures(GLsizei n, GLuint *textures);
-    void glDeleteTextures(GLsizei n, const GLuint *textures);
-    void glBindTexture(GLenum target, GLuint texture);
-    void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
-    void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
-    void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
-    void glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
-    void glPolygonOffset(GLfloat factor, GLfloat units);
-    void glGetPointerv(GLenum pname, GLvoid* *params);
-    void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
-    void glDrawArrays(GLenum mode, GLint first, GLsizei count);
-
-    // OpenGL 1.2 core functions
-    void glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices);
-    void glBlendEquation(GLenum mode);
-    void glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-
-    // OpenGL 1.3 core functions
-    void glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img);
-    void glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glSampleCoverage(GLfloat value, GLboolean invert);
-    void glActiveTexture(GLenum texture);
-
-    // OpenGL 1.4 core functions
-    void glPointParameteriv(GLenum pname, const GLint *params);
-    void glPointParameteri(GLenum pname, GLint param);
-    void glPointParameterfv(GLenum pname, const GLfloat *params);
-    void glPointParameterf(GLenum pname, GLfloat param);
-    void glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount);
-    void glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount);
-    void glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
-
-    // OpenGL 1.5 core functions
-    void glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params);
-    void glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params);
-    GLboolean glUnmapBuffer(GLenum target);
-    GLvoid* glMapBuffer(GLenum target, GLenum access);
-    void glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data);
-    void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data);
-    void glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage);
-    GLboolean glIsBuffer(GLuint buffer);
-    void glGenBuffers(GLsizei n, GLuint *buffers);
-    void glDeleteBuffers(GLsizei n, const GLuint *buffers);
-    void glBindBuffer(GLenum target, GLuint buffer);
-    void glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params);
-    void glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params);
-    void glGetQueryiv(GLenum target, GLenum pname, GLint *params);
-    void glEndQuery(GLenum target);
-    void glBeginQuery(GLenum target, GLuint id);
-    GLboolean glIsQuery(GLuint id);
-    void glDeleteQueries(GLsizei n, const GLuint *ids);
-    void glGenQueries(GLsizei n, GLuint *ids);
-
-    // OpenGL 2.0 core functions
-    void glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer);
-    void glValidateProgram(GLuint program);
-    void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniform4iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform3iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform2iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform1iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform4fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform3fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform2fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform1fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
-    void glUniform3i(GLint location, GLint v0, GLint v1, GLint v2);
-    void glUniform2i(GLint location, GLint v0, GLint v1);
-    void glUniform1i(GLint location, GLint v0);
-    void glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
-    void glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
-    void glUniform2f(GLint location, GLfloat v0, GLfloat v1);
-    void glUniform1f(GLint location, GLfloat v0);
-    void glUseProgram(GLuint program);
-    void glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length);
-    void glLinkProgram(GLuint program);
-    GLboolean glIsShader(GLuint shader);
-    GLboolean glIsProgram(GLuint program);
-    void glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer);
-    void glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params);
-    void glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params);
-    void glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params);
-    void glGetUniformiv(GLuint program, GLint location, GLint *params);
-    void glGetUniformfv(GLuint program, GLint location, GLfloat *params);
-    GLint glGetUniformLocation(GLuint program, const GLchar *name);
-    void glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source);
-    void glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void glGetShaderiv(GLuint shader, GLenum pname, GLint *params);
-    void glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void glGetProgramiv(GLuint program, GLenum pname, GLint *params);
-    GLint glGetAttribLocation(GLuint program, const GLchar *name);
-    void glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj);
-    void glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
-    void glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
-    void glEnableVertexAttribArray(GLuint index);
-    void glDisableVertexAttribArray(GLuint index);
-    void glDetachShader(GLuint program, GLuint shader);
-    void glDeleteShader(GLuint shader);
-    void glDeleteProgram(GLuint program);
-    GLuint glCreateShader(GLenum type);
-    GLuint glCreateProgram();
-    void glCompileShader(GLuint shader);
-    void glBindAttribLocation(GLuint program, GLuint index, const GLchar *name);
-    void glAttachShader(GLuint program, GLuint shader);
-    void glStencilMaskSeparate(GLenum face, GLuint mask);
-    void glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask);
-    void glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);
-    void glDrawBuffers(GLsizei n, const GLenum *bufs);
-    void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha);
-
-    // OpenGL 2.1 core functions
-    void glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-
-    // OpenGL 3.0 core functions
-    GLboolean glIsVertexArray(GLuint array);
-    void glGenVertexArrays(GLsizei n, GLuint *arrays);
-    void glDeleteVertexArrays(GLsizei n, const GLuint *arrays);
-    void glBindVertexArray(GLuint array);
-    void glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length);
-    GLvoid* glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
-    void glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
-    void glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
-    void glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
-    void glGenerateMipmap(GLenum target);
-    void glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params);
-    void glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
-    void glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset);
-    void glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
-    void glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
-    GLenum glCheckFramebufferStatus(GLenum target);
-    void glGenFramebuffers(GLsizei n, GLuint *framebuffers);
-    void glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers);
-    void glBindFramebuffer(GLenum target, GLuint framebuffer);
-    GLboolean glIsFramebuffer(GLuint framebuffer);
-    void glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
-    void glGenRenderbuffers(GLsizei n, GLuint *renderbuffers);
-    void glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers);
-    void glBindRenderbuffer(GLenum target, GLuint renderbuffer);
-    GLboolean glIsRenderbuffer(GLuint renderbuffer);
-    const GLubyte * glGetStringi(GLenum name, GLuint index);
-    void glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
-    void glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value);
-    void glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value);
-    void glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value);
-    void glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params);
-    void glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params);
-    void glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params);
-    void glTexParameterIiv(GLenum target, GLenum pname, const GLint *params);
-    void glUniform4uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform3uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform2uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform1uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
-    void glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2);
-    void glUniform2ui(GLint location, GLuint v0, GLuint v1);
-    void glUniform1ui(GLint location, GLuint v0);
-    GLint glGetFragDataLocation(GLuint program, const GLchar *name);
-    void glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name);
-    void glGetUniformuiv(GLuint program, GLint location, GLuint *params);
-    void glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params);
-    void glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params);
-    void glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glEndConditionalRender();
-    void glBeginConditionalRender(GLuint id, GLenum mode);
-    void glClampColor(GLenum target, GLenum clamp);
-    void glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name);
-    void glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode);
-    void glBindBufferBase(GLenum target, GLuint index, GLuint buffer);
-    void glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
-    void glEndTransformFeedback();
-    void glBeginTransformFeedback(GLenum primitiveMode);
-    GLboolean glIsEnabledi(GLenum target, GLuint index);
-    void glDisablei(GLenum target, GLuint index);
-    void glEnablei(GLenum target, GLuint index);
-    void glGetIntegeri_v(GLenum target, GLuint index, GLint *data);
-    void glGetBooleani_v(GLenum target, GLuint index, GLboolean *data);
-    void glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a);
-
-    // OpenGL 3.1 core functions
-    void glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
-    void glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);
-    void glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName);
-    void glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params);
-    GLuint glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName);
-    void glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName);
-    void glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params);
-    void glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const *uniformNames, GLuint *uniformIndices);
-    void glPrimitiveRestartIndex(GLuint index);
-    void glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer);
-    void glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount);
-    void glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount);
-
-    // OpenGL 3.2 core functions
-    void glSampleMaski(GLuint index, GLbitfield mask);
-    void glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val);
-    void glTexImage3DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
-    void glTexImage2DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
-    void glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values);
-    void glGetInteger64v(GLenum pname, GLint64 *params);
-    void glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout);
-    GLenum glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout);
-    void glDeleteSync(GLsync sync);
-    GLboolean glIsSync(GLsync sync);
-    GLsync glFenceSync(GLenum condition, GLbitfield flags);
-    void glProvokingVertex(GLenum mode);
-    void glMultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount, const GLint *basevertex);
-    void glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount, GLint basevertex);
-    void glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex);
-    void glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex);
-    void glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level);
-    void glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params);
-    void glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data);
-
-    // OpenGL 3.3 core functions
-    void glVertexAttribP4uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glVertexAttribP3uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glVertexAttribP2uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glVertexAttribP1uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glSecondaryColorP3uiv(GLenum type, const GLuint *color);
-    void glSecondaryColorP3ui(GLenum type, GLuint color);
-    void glColorP4uiv(GLenum type, const GLuint *color);
-    void glColorP4ui(GLenum type, GLuint color);
-    void glColorP3uiv(GLenum type, const GLuint *color);
-    void glColorP3ui(GLenum type, GLuint color);
-    void glNormalP3uiv(GLenum type, const GLuint *coords);
-    void glNormalP3ui(GLenum type, GLuint coords);
-    void glMultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint *coords);
-    void glMultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords);
-    void glMultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint *coords);
-    void glMultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords);
-    void glMultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint *coords);
-    void glMultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords);
-    void glMultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint *coords);
-    void glMultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords);
-    void glTexCoordP4uiv(GLenum type, const GLuint *coords);
-    void glTexCoordP4ui(GLenum type, GLuint coords);
-    void glTexCoordP3uiv(GLenum type, const GLuint *coords);
-    void glTexCoordP3ui(GLenum type, GLuint coords);
-    void glTexCoordP2uiv(GLenum type, const GLuint *coords);
-    void glTexCoordP2ui(GLenum type, GLuint coords);
-    void glTexCoordP1uiv(GLenum type, const GLuint *coords);
-    void glTexCoordP1ui(GLenum type, GLuint coords);
-    void glVertexP4uiv(GLenum type, const GLuint *value);
-    void glVertexP4ui(GLenum type, GLuint value);
-    void glVertexP3uiv(GLenum type, const GLuint *value);
-    void glVertexP3ui(GLenum type, GLuint value);
-    void glVertexP2uiv(GLenum type, const GLuint *value);
-    void glVertexP2ui(GLenum type, GLuint value);
-    void glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params);
-    void glGetQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params);
-    void glQueryCounter(GLuint id, GLenum target);
-    void glGetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params);
-    void glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params);
-    void glGetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params);
-    void glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params);
-    void glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param);
-    void glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param);
-    void glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param);
-    void glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param);
-    void glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param);
-    void glSamplerParameteri(GLuint sampler, GLenum pname, GLint param);
-    void glBindSampler(GLuint unit, GLuint sampler);
-    GLboolean glIsSampler(GLuint sampler);
-    void glDeleteSamplers(GLsizei count, const GLuint *samplers);
-    void glGenSamplers(GLsizei count, GLuint *samplers);
-    GLint glGetFragDataIndex(GLuint program, const GLchar *name);
-    void glBindFragDataLocationIndexed(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name);
-    void glVertexAttribDivisor(GLuint index, GLuint divisor);
-
-    // OpenGL 4.0 core functions
-    void glGetQueryIndexediv(GLenum target, GLuint index, GLenum pname, GLint *params);
-    void glEndQueryIndexed(GLenum target, GLuint index);
-    void glBeginQueryIndexed(GLenum target, GLuint index, GLuint id);
-    void glDrawTransformFeedbackStream(GLenum mode, GLuint id, GLuint stream);
-    void glDrawTransformFeedback(GLenum mode, GLuint id);
-    void glResumeTransformFeedback();
-    void glPauseTransformFeedback();
-    GLboolean glIsTransformFeedback(GLuint id);
-    void glGenTransformFeedbacks(GLsizei n, GLuint *ids);
-    void glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids);
-    void glBindTransformFeedback(GLenum target, GLuint id);
-    void glPatchParameterfv(GLenum pname, const GLfloat *values);
-    void glPatchParameteri(GLenum pname, GLint value);
-    void glGetProgramStageiv(GLuint program, GLenum shadertype, GLenum pname, GLint *values);
-    void glGetUniformSubroutineuiv(GLenum shadertype, GLint location, GLuint *params);
-    void glUniformSubroutinesuiv(GLenum shadertype, GLsizei count, const GLuint *indices);
-    void glGetActiveSubroutineName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name);
-    void glGetActiveSubroutineUniformName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name);
-    void glGetActiveSubroutineUniformiv(GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values);
-    GLuint glGetSubroutineIndex(GLuint program, GLenum shadertype, const GLchar *name);
-    GLint glGetSubroutineUniformLocation(GLuint program, GLenum shadertype, const GLchar *name);
-    void glGetUniformdv(GLuint program, GLint location, GLdouble *params);
-    void glUniformMatrix4x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix4x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix3x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix3x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix2x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix2x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniform4dv(GLint location, GLsizei count, const GLdouble *value);
-    void glUniform3dv(GLint location, GLsizei count, const GLdouble *value);
-    void glUniform2dv(GLint location, GLsizei count, const GLdouble *value);
-    void glUniform1dv(GLint location, GLsizei count, const GLdouble *value);
-    void glUniform4d(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glUniform3d(GLint location, GLdouble x, GLdouble y, GLdouble z);
-    void glUniform2d(GLint location, GLdouble x, GLdouble y);
-    void glUniform1d(GLint location, GLdouble x);
-    void glDrawElementsIndirect(GLenum mode, GLenum type, const GLvoid *indirect);
-    void glDrawArraysIndirect(GLenum mode, const GLvoid *indirect);
-    void glBlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
-    void glBlendFunci(GLuint buf, GLenum src, GLenum dst);
-    void glBlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha);
-    void glBlendEquationi(GLuint buf, GLenum mode);
-    void glMinSampleShading(GLfloat value);
-
-private:
-    friend class QOpenGLContext;
-
-    static bool isContextCompatible(QOpenGLContext *context);
-    static QOpenGLVersionProfile versionProfile();
-
-    QOpenGLFunctions_1_0_CoreBackend* d_1_0_Core;
-    QOpenGLFunctions_1_1_CoreBackend* d_1_1_Core;
-    QOpenGLFunctions_1_2_CoreBackend* d_1_2_Core;
-    QOpenGLFunctions_1_3_CoreBackend* d_1_3_Core;
-    QOpenGLFunctions_1_4_CoreBackend* d_1_4_Core;
-    QOpenGLFunctions_1_5_CoreBackend* d_1_5_Core;
-    QOpenGLFunctions_2_0_CoreBackend* d_2_0_Core;
-    QOpenGLFunctions_2_1_CoreBackend* d_2_1_Core;
-    QOpenGLFunctions_3_0_CoreBackend* d_3_0_Core;
-    QOpenGLFunctions_3_1_CoreBackend* d_3_1_Core;
-    QOpenGLFunctions_3_2_CoreBackend* d_3_2_Core;
-    QOpenGLFunctions_3_3_CoreBackend* d_3_3_Core;
-    QOpenGLFunctions_4_0_CoreBackend* d_4_0_Core;
-};
-
-// OpenGL 1.0 core functions
-inline void QOpenGLFunctions_4_0_Core::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_0_Core->f.Viewport(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glDepthRange(GLdouble nearVal, GLdouble farVal)
-{
-    d_1_0_Core->f.DepthRange(nearVal, farVal);
-}
-
-inline GLboolean QOpenGLFunctions_4_0_Core::glIsEnabled(GLenum cap)
-{
-    return d_1_0_Core->f.IsEnabled(cap);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetTexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetTexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
-{
-    d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
-}
-
-inline const GLubyte * QOpenGLFunctions_4_0_Core::glGetString(GLenum name)
-{
-    return d_1_0_Core->f.GetString(name);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetIntegerv(GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetIntegerv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetFloatv(GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetFloatv(pname, params);
-}
-
-inline GLenum QOpenGLFunctions_4_0_Core::glGetError()
-{
-    return d_1_0_Core->f.GetError();
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetDoublev(GLenum pname, GLdouble *params)
-{
-    d_1_0_Core->f.GetDoublev(pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetBooleanv(GLenum pname, GLboolean *params)
-{
-    d_1_0_Core->f.GetBooleanv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
-{
-    d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glReadBuffer(GLenum mode)
-{
-    d_1_0_Core->f.ReadBuffer(mode);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glPixelStorei(GLenum pname, GLint param)
-{
-    d_1_0_Core->f.PixelStorei(pname, param);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glPixelStoref(GLenum pname, GLfloat param)
-{
-    d_1_0_Core->f.PixelStoref(pname, param);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glDepthFunc(GLenum func)
-{
-    d_1_0_Core->f.DepthFunc(func);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
-{
-    d_1_0_Core->f.StencilOp(fail, zfail, zpass);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glStencilFunc(GLenum func, GLint ref, GLuint mask)
-{
-    d_1_0_Core->f.StencilFunc(func, ref, mask);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glLogicOp(GLenum opcode)
-{
-    d_1_0_Core->f.LogicOp(opcode);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glBlendFunc(GLenum sfactor, GLenum dfactor)
-{
-    d_1_0_Core->f.BlendFunc(sfactor, dfactor);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glFlush()
-{
-    d_1_0_Core->f.Flush();
-}
-
-inline void QOpenGLFunctions_4_0_Core::glFinish()
-{
-    d_1_0_Core->f.Finish();
-}
-
-inline void QOpenGLFunctions_4_0_Core::glEnable(GLenum cap)
-{
-    d_1_0_Core->f.Enable(cap);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glDisable(GLenum cap)
-{
-    d_1_0_Core->f.Disable(cap);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glDepthMask(GLboolean flag)
-{
-    d_1_0_Core->f.DepthMask(flag);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
-{
-    d_1_0_Core->f.ColorMask(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glStencilMask(GLuint mask)
-{
-    d_1_0_Core->f.StencilMask(mask);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glClearDepth(GLdouble depth)
-{
-    d_1_0_Core->f.ClearDepth(depth);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glClearStencil(GLint s)
-{
-    d_1_0_Core->f.ClearStencil(s);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Core->f.ClearColor(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glClear(GLbitfield mask)
-{
-    d_1_0_Core->f.Clear(mask);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glDrawBuffer(GLenum mode)
-{
-    d_1_0_Core->f.DrawBuffer(mode);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Core->f.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Core->f.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_0_Core->f.TexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glTexParameteri(GLenum target, GLenum pname, GLint param)
-{
-    d_1_0_Core->f.TexParameteri(target, pname, param);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Core->f.TexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
-{
-    d_1_0_Core->f.TexParameterf(target, pname, param);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_0_Core->f.Scissor(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glPolygonMode(GLenum face, GLenum mode)
-{
-    d_1_0_Core->f.PolygonMode(face, mode);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glPointSize(GLfloat size)
-{
-    d_1_0_Core->f.PointSize(size);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glLineWidth(GLfloat width)
-{
-    d_1_0_Core->f.LineWidth(width);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glHint(GLenum target, GLenum mode)
-{
-    d_1_0_Core->f.Hint(target, mode);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glFrontFace(GLenum mode)
-{
-    d_1_0_Core->f.FrontFace(mode);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glCullFace(GLenum mode)
-{
-    d_1_0_Core->f.CullFace(mode);
-}
-
-
-// OpenGL 1.1 core functions
-inline void QOpenGLFunctions_4_0_Core::glIndexubv(const GLubyte *c)
-{
-    Q_UNUSED(c);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_0_Core::glIndexub(GLubyte c)
-{
-    Q_UNUSED(c);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline GLboolean QOpenGLFunctions_4_0_Core::glIsTexture(GLuint texture)
-{
-    return d_1_1_Core->f.IsTexture(texture);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGenTextures(GLsizei n, GLuint *textures)
-{
-    d_1_1_Core->f.GenTextures(n, textures);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glDeleteTextures(GLsizei n, const GLuint *textures)
-{
-    d_1_1_Core->f.DeleteTextures(n, textures);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glBindTexture(GLenum target, GLuint texture)
-{
-    d_1_1_Core->f.BindTexture(target, texture);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_1_Core->f.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_1_Core->f.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_1_Core->f.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
-{
-    d_1_1_Core->f.CopyTexSubImage1D(target, level, xoffset, x, y, width);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
-{
-    d_1_1_Core->f.CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
-{
-    d_1_1_Core->f.CopyTexImage1D(target, level, internalformat, x, y, width, border);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glPolygonOffset(GLfloat factor, GLfloat units)
-{
-    d_1_1_Core->f.PolygonOffset(factor, units);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetPointerv(GLenum pname, GLvoid* *params)
-{
-    Q_UNUSED(pname);
-    Q_UNUSED(params);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_0_Core::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
-{
-    d_1_1_Core->f.DrawElements(mode, count, type, indices);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glDrawArrays(GLenum mode, GLint first, GLsizei count)
-{
-    d_1_1_Core->f.DrawArrays(mode, first, count);
-}
-
-
-// OpenGL 1.2 core functions
-inline void QOpenGLFunctions_4_0_Core::glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_2_Core->f.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_2_Core->f.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_2_Core->f.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
-{
-    d_1_2_Core->f.DrawRangeElements(mode, start, end, count, type, indices);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glBlendEquation(GLenum mode)
-{
-    d_1_2_Core->f.BlendEquation(mode);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_2_Core->f.BlendColor(red, green, blue, alpha);
-}
-
-
-// OpenGL 1.3 core functions
-inline void QOpenGLFunctions_4_0_Core::glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img)
-{
-    d_1_3_Core->f.GetCompressedTexImage(target, level, img);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glSampleCoverage(GLfloat value, GLboolean invert)
-{
-    d_1_3_Core->f.SampleCoverage(value, invert);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glActiveTexture(GLenum texture)
-{
-    d_1_3_Core->f.ActiveTexture(texture);
-}
-
-
-// OpenGL 1.4 core functions
-inline void QOpenGLFunctions_4_0_Core::glPointParameteriv(GLenum pname, const GLint *params)
-{
-    d_1_4_Core->f.PointParameteriv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glPointParameteri(GLenum pname, GLint param)
-{
-    d_1_4_Core->f.PointParameteri(pname, param);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glPointParameterfv(GLenum pname, const GLfloat *params)
-{
-    d_1_4_Core->f.PointParameterfv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glPointParameterf(GLenum pname, GLfloat param)
-{
-    d_1_4_Core->f.PointParameterf(pname, param);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount)
-{
-    d_1_4_Core->f.MultiDrawElements(mode, count, type, indices, drawcount);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
-{
-    d_1_4_Core->f.MultiDrawArrays(mode, first, count, drawcount);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
-{
-    d_1_4_Core->f.BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
-}
-
-
-// OpenGL 1.5 core functions
-inline void QOpenGLFunctions_4_0_Core::glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params)
-{
-    d_1_5_Core->f.GetBufferPointerv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetBufferParameteriv(target, pname, params);
-}
-
-inline GLboolean QOpenGLFunctions_4_0_Core::glUnmapBuffer(GLenum target)
-{
-    return d_1_5_Core->f.UnmapBuffer(target);
-}
-
-inline GLvoid* QOpenGLFunctions_4_0_Core::glMapBuffer(GLenum target, GLenum access)
-{
-    return d_1_5_Core->f.MapBuffer(target, access);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data)
-{
-    d_1_5_Core->f.GetBufferSubData(target, offset, size, data);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data)
-{
-    d_1_5_Core->f.BufferSubData(target, offset, size, data);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)
-{
-    d_1_5_Core->f.BufferData(target, size, data, usage);
-}
-
-inline GLboolean QOpenGLFunctions_4_0_Core::glIsBuffer(GLuint buffer)
-{
-    return d_1_5_Core->f.IsBuffer(buffer);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGenBuffers(GLsizei n, GLuint *buffers)
-{
-    d_1_5_Core->f.GenBuffers(n, buffers);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glDeleteBuffers(GLsizei n, const GLuint *buffers)
-{
-    d_1_5_Core->f.DeleteBuffers(n, buffers);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glBindBuffer(GLenum target, GLuint buffer)
-{
-    d_1_5_Core->f.BindBuffer(target, buffer);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
-{
-    d_1_5_Core->f.GetQueryObjectuiv(id, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetQueryObjectiv(id, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetQueryiv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetQueryiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glEndQuery(GLenum target)
-{
-    d_1_5_Core->f.EndQuery(target);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glBeginQuery(GLenum target, GLuint id)
-{
-    d_1_5_Core->f.BeginQuery(target, id);
-}
-
-inline GLboolean QOpenGLFunctions_4_0_Core::glIsQuery(GLuint id)
-{
-    return d_1_5_Core->f.IsQuery(id);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glDeleteQueries(GLsizei n, const GLuint *ids)
-{
-    d_1_5_Core->f.DeleteQueries(n, ids);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGenQueries(GLsizei n, GLuint *ids)
-{
-    d_1_5_Core->f.GenQueries(n, ids);
-}
-
-
-// OpenGL 2.0 core functions
-inline void QOpenGLFunctions_4_0_Core::glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer)
-{
-    d_2_0_Core->f.VertexAttribPointer(index, size, type, normalized, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glValidateProgram(GLuint program)
-{
-    d_2_0_Core->f.ValidateProgram(program);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix3fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glUniform4iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform4iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glUniform3iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform3iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glUniform2iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform2iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glUniform1iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform1iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glUniform4fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform4fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glUniform3fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform3fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glUniform2fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform2fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glUniform1fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform1fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
-{
-    d_2_0_Core->f.Uniform4i(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glUniform3i(GLint location, GLint v0, GLint v1, GLint v2)
-{
-    d_2_0_Core->f.Uniform3i(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glUniform2i(GLint location, GLint v0, GLint v1)
-{
-    d_2_0_Core->f.Uniform2i(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glUniform1i(GLint location, GLint v0)
-{
-    d_2_0_Core->f.Uniform1i(location, v0);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
-{
-    d_2_0_Core->f.Uniform4f(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
-{
-    d_2_0_Core->f.Uniform3f(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glUniform2f(GLint location, GLfloat v0, GLfloat v1)
-{
-    d_2_0_Core->f.Uniform2f(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glUniform1f(GLint location, GLfloat v0)
-{
-    d_2_0_Core->f.Uniform1f(location, v0);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glUseProgram(GLuint program)
-{
-    d_2_0_Core->f.UseProgram(program);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length)
-{
-    d_2_0_Core->f.ShaderSource(shader, count, string, length);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glLinkProgram(GLuint program)
-{
-    d_2_0_Core->f.LinkProgram(program);
-}
-
-inline GLboolean QOpenGLFunctions_4_0_Core::glIsShader(GLuint shader)
-{
-    return d_2_0_Core->f.IsShader(shader);
-}
-
-inline GLboolean QOpenGLFunctions_4_0_Core::glIsProgram(GLuint program)
-{
-    return d_2_0_Core->f.IsProgram(program);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer)
-{
-    d_2_0_Core->f.GetVertexAttribPointerv(index, pname, pointer);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetVertexAttribiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
-{
-    d_2_0_Core->f.GetVertexAttribfv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
-{
-    d_2_0_Core->f.GetVertexAttribdv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetUniformiv(GLuint program, GLint location, GLint *params)
-{
-    d_2_0_Core->f.GetUniformiv(program, location, params);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetUniformfv(GLuint program, GLint location, GLfloat *params)
-{
-    d_2_0_Core->f.GetUniformfv(program, location, params);
-}
-
-inline GLint QOpenGLFunctions_4_0_Core::glGetUniformLocation(GLuint program, const GLchar *name)
-{
-    return d_2_0_Core->f.GetUniformLocation(program, name);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
-{
-    d_2_0_Core->f.GetShaderSource(shader, bufSize, length, source);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-{
-    d_2_0_Core->f.GetShaderInfoLog(shader, bufSize, length, infoLog);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetShaderiv(GLuint shader, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetShaderiv(shader, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-{
-    d_2_0_Core->f.GetProgramInfoLog(program, bufSize, length, infoLog);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetProgramiv(GLuint program, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetProgramiv(program, pname, params);
-}
-
-inline GLint QOpenGLFunctions_4_0_Core::glGetAttribLocation(GLuint program, const GLchar *name)
-{
-    return d_2_0_Core->f.GetAttribLocation(program, name);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj)
-{
-    d_2_0_Core->f.GetAttachedShaders(program, maxCount, count, obj);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
-{
-    d_2_0_Core->f.GetActiveUniform(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
-{
-    d_2_0_Core->f.GetActiveAttrib(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glEnableVertexAttribArray(GLuint index)
-{
-    d_2_0_Core->f.EnableVertexAttribArray(index);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glDisableVertexAttribArray(GLuint index)
-{
-    d_2_0_Core->f.DisableVertexAttribArray(index);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glDetachShader(GLuint program, GLuint shader)
-{
-    d_2_0_Core->f.DetachShader(program, shader);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glDeleteShader(GLuint shader)
-{
-    d_2_0_Core->f.DeleteShader(shader);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glDeleteProgram(GLuint program)
-{
-    d_2_0_Core->f.DeleteProgram(program);
-}
-
-inline GLuint QOpenGLFunctions_4_0_Core::glCreateShader(GLenum type)
-{
-    return d_2_0_Core->f.CreateShader(type);
-}
-
-inline GLuint QOpenGLFunctions_4_0_Core::glCreateProgram()
-{
-    return d_2_0_Core->f.CreateProgram();
-}
-
-inline void QOpenGLFunctions_4_0_Core::glCompileShader(GLuint shader)
-{
-    d_2_0_Core->f.CompileShader(shader);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glBindAttribLocation(GLuint program, GLuint index, const GLchar *name)
-{
-    d_2_0_Core->f.BindAttribLocation(program, index, name);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glAttachShader(GLuint program, GLuint shader)
-{
-    d_2_0_Core->f.AttachShader(program, shader);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glStencilMaskSeparate(GLenum face, GLuint mask)
-{
-    d_2_0_Core->f.StencilMaskSeparate(face, mask);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
-{
-    d_2_0_Core->f.StencilFuncSeparate(face, func, ref, mask);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
-{
-    d_2_0_Core->f.StencilOpSeparate(face, sfail, dpfail, dppass);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glDrawBuffers(GLsizei n, const GLenum *bufs)
-{
-    d_2_0_Core->f.DrawBuffers(n, bufs);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
-{
-    d_2_0_Core->f.BlendEquationSeparate(modeRGB, modeAlpha);
-}
-
-
-// OpenGL 2.1 core functions
-inline void QOpenGLFunctions_4_0_Core::glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix4x3fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix3x4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix4x2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix2x4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix3x2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix2x3fv(location, count, transpose, value);
-}
-
-
-// OpenGL 3.0 core functions
-inline GLboolean QOpenGLFunctions_4_0_Core::glIsVertexArray(GLuint array)
-{
-    return d_3_0_Core->f.IsVertexArray(array);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGenVertexArrays(GLsizei n, GLuint *arrays)
-{
-    d_3_0_Core->f.GenVertexArrays(n, arrays);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glDeleteVertexArrays(GLsizei n, const GLuint *arrays)
-{
-    d_3_0_Core->f.DeleteVertexArrays(n, arrays);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glBindVertexArray(GLuint array)
-{
-    d_3_0_Core->f.BindVertexArray(array);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
-{
-    d_3_0_Core->f.FlushMappedBufferRange(target, offset, length);
-}
-
-inline GLvoid* QOpenGLFunctions_4_0_Core::glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
-{
-    return d_3_0_Core->f.MapBufferRange(target, offset, length, access);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
-{
-    d_3_0_Core->f.FramebufferTextureLayer(target, attachment, texture, level, layer);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    d_3_0_Core->f.RenderbufferStorageMultisample(target, samples, internalformat, width, height);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
-{
-    d_3_0_Core->f.BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGenerateMipmap(GLenum target)
-{
-    d_3_0_Core->f.GenerateMipmap(target);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
-{
-    d_3_0_Core->f.FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
-{
-    d_3_0_Core->f.FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
-{
-    d_3_0_Core->f.FramebufferTexture2D(target, attachment, textarget, texture, level);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
-{
-    d_3_0_Core->f.FramebufferTexture1D(target, attachment, textarget, texture, level);
-}
-
-inline GLenum QOpenGLFunctions_4_0_Core::glCheckFramebufferStatus(GLenum target)
-{
-    return d_3_0_Core->f.CheckFramebufferStatus(target);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGenFramebuffers(GLsizei n, GLuint *framebuffers)
-{
-    d_3_0_Core->f.GenFramebuffers(n, framebuffers);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
-{
-    d_3_0_Core->f.DeleteFramebuffers(n, framebuffers);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glBindFramebuffer(GLenum target, GLuint framebuffer)
-{
-    d_3_0_Core->f.BindFramebuffer(target, framebuffer);
-}
-
-inline GLboolean QOpenGLFunctions_4_0_Core::glIsFramebuffer(GLuint framebuffer)
-{
-    return d_3_0_Core->f.IsFramebuffer(framebuffer);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetRenderbufferParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    d_3_0_Core->f.RenderbufferStorage(target, internalformat, width, height);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGenRenderbuffers(GLsizei n, GLuint *renderbuffers)
-{
-    d_3_0_Core->f.GenRenderbuffers(n, renderbuffers);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
-{
-    d_3_0_Core->f.DeleteRenderbuffers(n, renderbuffers);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glBindRenderbuffer(GLenum target, GLuint renderbuffer)
-{
-    d_3_0_Core->f.BindRenderbuffer(target, renderbuffer);
-}
-
-inline GLboolean QOpenGLFunctions_4_0_Core::glIsRenderbuffer(GLuint renderbuffer)
-{
-    return d_3_0_Core->f.IsRenderbuffer(renderbuffer);
-}
-
-inline const GLubyte * QOpenGLFunctions_4_0_Core::glGetStringi(GLenum name, GLuint index)
-{
-    return d_3_0_Core->f.GetStringi(name, index);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
-{
-    d_3_0_Core->f.ClearBufferfi(buffer, drawbuffer, depth, stencil);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
-{
-    d_3_0_Core->f.ClearBufferfv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
-{
-    d_3_0_Core->f.ClearBufferuiv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
-{
-    d_3_0_Core->f.ClearBufferiv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params)
-{
-    d_3_0_Core->f.GetTexParameterIuiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetTexParameterIiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params)
-{
-    d_3_0_Core->f.TexParameterIuiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glTexParameterIiv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_3_0_Core->f.TexParameterIiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glUniform4uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform4uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glUniform3uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform3uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glUniform2uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform2uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glUniform1uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform1uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
-{
-    d_3_0_Core->f.Uniform4ui(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
-{
-    d_3_0_Core->f.Uniform3ui(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glUniform2ui(GLint location, GLuint v0, GLuint v1)
-{
-    d_3_0_Core->f.Uniform2ui(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glUniform1ui(GLint location, GLuint v0)
-{
-    d_3_0_Core->f.Uniform1ui(location, v0);
-}
-
-inline GLint QOpenGLFunctions_4_0_Core::glGetFragDataLocation(GLuint program, const GLchar *name)
-{
-    return d_3_0_Core->f.GetFragDataLocation(program, name);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name)
-{
-    d_3_0_Core->f.BindFragDataLocation(program, color, name);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetUniformuiv(GLuint program, GLint location, GLuint *params)
-{
-    d_3_0_Core->f.GetUniformuiv(program, location, params);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
-{
-    d_3_0_Core->f.GetVertexAttribIuiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetVertexAttribIiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_3_0_Core->f.VertexAttribIPointer(index, size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glEndConditionalRender()
-{
-    d_3_0_Core->f.EndConditionalRender();
-}
-
-inline void QOpenGLFunctions_4_0_Core::glBeginConditionalRender(GLuint id, GLenum mode)
-{
-    d_3_0_Core->f.BeginConditionalRender(id, mode);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glClampColor(GLenum target, GLenum clamp)
-{
-    d_3_0_Core->f.ClampColor(target, clamp);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
-{
-    d_3_0_Core->f.GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode)
-{
-    d_3_0_Core->f.TransformFeedbackVaryings(program, count, varyings, bufferMode);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
-{
-    d_3_0_Core->f.BindBufferBase(target, index, buffer);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
-{
-    d_3_0_Core->f.BindBufferRange(target, index, buffer, offset, size);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glEndTransformFeedback()
-{
-    d_3_0_Core->f.EndTransformFeedback();
-}
-
-inline void QOpenGLFunctions_4_0_Core::glBeginTransformFeedback(GLenum primitiveMode)
-{
-    d_3_0_Core->f.BeginTransformFeedback(primitiveMode);
-}
-
-inline GLboolean QOpenGLFunctions_4_0_Core::glIsEnabledi(GLenum target, GLuint index)
-{
-    return d_3_0_Core->f.IsEnabledi(target, index);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glDisablei(GLenum target, GLuint index)
-{
-    d_3_0_Core->f.Disablei(target, index);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glEnablei(GLenum target, GLuint index)
-{
-    d_3_0_Core->f.Enablei(target, index);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetIntegeri_v(GLenum target, GLuint index, GLint *data)
-{
-    d_3_0_Core->f.GetIntegeri_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetBooleani_v(GLenum target, GLuint index, GLboolean *data)
-{
-    d_3_0_Core->f.GetBooleani_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
-{
-    d_3_0_Core->f.ColorMaski(index, r, g, b, a);
-}
-
-
-// OpenGL 3.1 core functions
-inline void QOpenGLFunctions_4_0_Core::glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
-{
-    d_3_1_Core->f.CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
-{
-    d_3_1_Core->f.UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
-{
-    d_3_1_Core->f.GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params)
-{
-    d_3_1_Core->f.GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
-}
-
-inline GLuint QOpenGLFunctions_4_0_Core::glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName)
-{
-    return d_3_1_Core->f.GetUniformBlockIndex(program, uniformBlockName);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName)
-{
-    d_3_1_Core->f.GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params)
-{
-    d_3_1_Core->f.GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const *uniformNames, GLuint *uniformIndices)
-{
-    d_3_1_Core->f.GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glPrimitiveRestartIndex(GLuint index)
-{
-    d_3_1_Core->f.PrimitiveRestartIndex(index);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer)
-{
-    d_3_1_Core->f.TexBuffer(target, internalformat, buffer);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount)
-{
-    d_3_1_Core->f.DrawElementsInstanced(mode, count, type, indices, instancecount);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount)
-{
-    d_3_1_Core->f.DrawArraysInstanced(mode, first, count, instancecount);
-}
-
-
-// OpenGL 3.2 core functions
-inline void QOpenGLFunctions_4_0_Core::glSampleMaski(GLuint index, GLbitfield mask)
-{
-    d_3_2_Core->f.SampleMaski(index, mask);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val)
-{
-    d_3_2_Core->f.GetMultisamplefv(pname, index, val);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glTexImage3DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
-{
-    d_3_2_Core->f.TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glTexImage2DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
-{
-    d_3_2_Core->f.TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values)
-{
-    d_3_2_Core->f.GetSynciv(sync, pname, bufSize, length, values);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetInteger64v(GLenum pname, GLint64 *params)
-{
-    d_3_2_Core->f.GetInteger64v(pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
-{
-    d_3_2_Core->f.WaitSync(sync, flags, timeout);
-}
-
-inline GLenum QOpenGLFunctions_4_0_Core::glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
-{
-    return d_3_2_Core->f.ClientWaitSync(sync, flags, timeout);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glDeleteSync(GLsync sync)
-{
-    d_3_2_Core->f.DeleteSync(sync);
-}
-
-inline GLboolean QOpenGLFunctions_4_0_Core::glIsSync(GLsync sync)
-{
-    return d_3_2_Core->f.IsSync(sync);
-}
-
-inline GLsync QOpenGLFunctions_4_0_Core::glFenceSync(GLenum condition, GLbitfield flags)
-{
-    return d_3_2_Core->f.FenceSync(condition, flags);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glProvokingVertex(GLenum mode)
-{
-    d_3_2_Core->f.ProvokingVertex(mode);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glMultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount, const GLint *basevertex)
-{
-    d_3_2_Core->f.MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount, GLint basevertex)
-{
-    d_3_2_Core->f.DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)
-{
-    d_3_2_Core->f.DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)
-{
-    d_3_2_Core->f.DrawElementsBaseVertex(mode, count, type, indices, basevertex);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level)
-{
-    d_3_2_Core->f.FramebufferTexture(target, attachment, texture, level);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params)
-{
-    d_3_2_Core->f.GetBufferParameteri64v(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data)
-{
-    d_3_2_Core->f.GetInteger64i_v(target, index, data);
-}
-
-
-// OpenGL 3.3 core functions
-inline void QOpenGLFunctions_4_0_Core::glVertexAttribP4uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP4uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glVertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP4ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glVertexAttribP3uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP3uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glVertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP3ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glVertexAttribP2uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP2uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glVertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP2ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glVertexAttribP1uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP1uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glVertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP1ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glSecondaryColorP3uiv(GLenum type, const GLuint *color)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(color);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_0_Core::glSecondaryColorP3ui(GLenum type, GLuint color)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(color);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_0_Core::glColorP4uiv(GLenum type, const GLuint *color)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(color);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_0_Core::glColorP4ui(GLenum type, GLuint color)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(color);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_0_Core::glColorP3uiv(GLenum type, const GLuint *color)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(color);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_0_Core::glColorP3ui(GLenum type, GLuint color)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(color);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_0_Core::glNormalP3uiv(GLenum type, const GLuint *coords)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_0_Core::glNormalP3ui(GLenum type, GLuint coords)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_0_Core::glMultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint *coords)
-{
-    Q_UNUSED(texture);
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_0_Core::glMultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords)
-{
-    Q_UNUSED(texture);
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_0_Core::glMultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint *coords)
-{
-    Q_UNUSED(texture);
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_0_Core::glMultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords)
-{
-    Q_UNUSED(texture);
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_0_Core::glMultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint *coords)
-{
-    Q_UNUSED(texture);
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_0_Core::glMultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords)
-{
-    Q_UNUSED(texture);
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_0_Core::glMultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint *coords)
-{
-    Q_UNUSED(texture);
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_0_Core::glMultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords)
-{
-    Q_UNUSED(texture);
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_0_Core::glTexCoordP4uiv(GLenum type, const GLuint *coords)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_0_Core::glTexCoordP4ui(GLenum type, GLuint coords)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_0_Core::glTexCoordP3uiv(GLenum type, const GLuint *coords)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_0_Core::glTexCoordP3ui(GLenum type, GLuint coords)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_0_Core::glTexCoordP2uiv(GLenum type, const GLuint *coords)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_0_Core::glTexCoordP2ui(GLenum type, GLuint coords)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_0_Core::glTexCoordP1uiv(GLenum type, const GLuint *coords)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_0_Core::glTexCoordP1ui(GLenum type, GLuint coords)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_0_Core::glVertexP4uiv(GLenum type, const GLuint *value)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(value);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_0_Core::glVertexP4ui(GLenum type, GLuint value)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(value);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_0_Core::glVertexP3uiv(GLenum type, const GLuint *value)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(value);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_0_Core::glVertexP3ui(GLenum type, GLuint value)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(value);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_0_Core::glVertexP2uiv(GLenum type, const GLuint *value)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(value);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_0_Core::glVertexP2ui(GLenum type, GLuint value)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(value);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params)
-{
-    d_3_3_Core->f.GetQueryObjectui64v(id, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params)
-{
-    d_3_3_Core->f.GetQueryObjecti64v(id, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glQueryCounter(GLuint id, GLenum target)
-{
-    d_3_3_Core->f.QueryCounter(id, target);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params)
-{
-    d_3_3_Core->f.GetSamplerParameterIuiv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params)
-{
-    d_3_3_Core->f.GetSamplerParameterfv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params)
-{
-    d_3_3_Core->f.GetSamplerParameterIiv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params)
-{
-    d_3_3_Core->f.GetSamplerParameteriv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param)
-{
-    d_3_3_Core->f.SamplerParameterIuiv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param)
-{
-    d_3_3_Core->f.SamplerParameterIiv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param)
-{
-    d_3_3_Core->f.SamplerParameterfv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
-{
-    d_3_3_Core->f.SamplerParameterf(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param)
-{
-    d_3_3_Core->f.SamplerParameteriv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glSamplerParameteri(GLuint sampler, GLenum pname, GLint param)
-{
-    d_3_3_Core->f.SamplerParameteri(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glBindSampler(GLuint unit, GLuint sampler)
-{
-    d_3_3_Core->f.BindSampler(unit, sampler);
-}
-
-inline GLboolean QOpenGLFunctions_4_0_Core::glIsSampler(GLuint sampler)
-{
-    return d_3_3_Core->f.IsSampler(sampler);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glDeleteSamplers(GLsizei count, const GLuint *samplers)
-{
-    d_3_3_Core->f.DeleteSamplers(count, samplers);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGenSamplers(GLsizei count, GLuint *samplers)
-{
-    d_3_3_Core->f.GenSamplers(count, samplers);
-}
-
-inline GLint QOpenGLFunctions_4_0_Core::glGetFragDataIndex(GLuint program, const GLchar *name)
-{
-    return d_3_3_Core->f.GetFragDataIndex(program, name);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glBindFragDataLocationIndexed(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name)
-{
-    d_3_3_Core->f.BindFragDataLocationIndexed(program, colorNumber, index, name);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glVertexAttribDivisor(GLuint index, GLuint divisor)
-{
-    d_3_3_Core->f.VertexAttribDivisor(index, divisor);
-}
-
-
-// OpenGL 4.0 core functions
-inline void QOpenGLFunctions_4_0_Core::glGetQueryIndexediv(GLenum target, GLuint index, GLenum pname, GLint *params)
-{
-    d_4_0_Core->f.GetQueryIndexediv(target, index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glEndQueryIndexed(GLenum target, GLuint index)
-{
-    d_4_0_Core->f.EndQueryIndexed(target, index);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glBeginQueryIndexed(GLenum target, GLuint index, GLuint id)
-{
-    d_4_0_Core->f.BeginQueryIndexed(target, index, id);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glDrawTransformFeedbackStream(GLenum mode, GLuint id, GLuint stream)
-{
-    d_4_0_Core->f.DrawTransformFeedbackStream(mode, id, stream);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glDrawTransformFeedback(GLenum mode, GLuint id)
-{
-    d_4_0_Core->f.DrawTransformFeedback(mode, id);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glResumeTransformFeedback()
-{
-    d_4_0_Core->f.ResumeTransformFeedback();
-}
-
-inline void QOpenGLFunctions_4_0_Core::glPauseTransformFeedback()
-{
-    d_4_0_Core->f.PauseTransformFeedback();
-}
-
-inline GLboolean QOpenGLFunctions_4_0_Core::glIsTransformFeedback(GLuint id)
-{
-    return d_4_0_Core->f.IsTransformFeedback(id);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGenTransformFeedbacks(GLsizei n, GLuint *ids)
-{
-    d_4_0_Core->f.GenTransformFeedbacks(n, ids);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids)
-{
-    d_4_0_Core->f.DeleteTransformFeedbacks(n, ids);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glBindTransformFeedback(GLenum target, GLuint id)
-{
-    d_4_0_Core->f.BindTransformFeedback(target, id);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glPatchParameterfv(GLenum pname, const GLfloat *values)
-{
-    d_4_0_Core->f.PatchParameterfv(pname, values);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glPatchParameteri(GLenum pname, GLint value)
-{
-    d_4_0_Core->f.PatchParameteri(pname, value);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetProgramStageiv(GLuint program, GLenum shadertype, GLenum pname, GLint *values)
-{
-    d_4_0_Core->f.GetProgramStageiv(program, shadertype, pname, values);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetUniformSubroutineuiv(GLenum shadertype, GLint location, GLuint *params)
-{
-    d_4_0_Core->f.GetUniformSubroutineuiv(shadertype, location, params);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glUniformSubroutinesuiv(GLenum shadertype, GLsizei count, const GLuint *indices)
-{
-    d_4_0_Core->f.UniformSubroutinesuiv(shadertype, count, indices);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetActiveSubroutineName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
-{
-    d_4_0_Core->f.GetActiveSubroutineName(program, shadertype, index, bufsize, length, name);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetActiveSubroutineUniformName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
-{
-    d_4_0_Core->f.GetActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetActiveSubroutineUniformiv(GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values)
-{
-    d_4_0_Core->f.GetActiveSubroutineUniformiv(program, shadertype, index, pname, values);
-}
-
-inline GLuint QOpenGLFunctions_4_0_Core::glGetSubroutineIndex(GLuint program, GLenum shadertype, const GLchar *name)
-{
-    return d_4_0_Core->f.GetSubroutineIndex(program, shadertype, name);
-}
-
-inline GLint QOpenGLFunctions_4_0_Core::glGetSubroutineUniformLocation(GLuint program, GLenum shadertype, const GLchar *name)
-{
-    return d_4_0_Core->f.GetSubroutineUniformLocation(program, shadertype, name);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glGetUniformdv(GLuint program, GLint location, GLdouble *params)
-{
-    d_4_0_Core->f.GetUniformdv(program, location, params);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glUniformMatrix4x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix4x3dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glUniformMatrix4x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix4x2dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glUniformMatrix3x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix3x4dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glUniformMatrix3x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix3x2dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glUniformMatrix2x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix2x4dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glUniformMatrix2x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix2x3dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glUniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix4dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glUniformMatrix3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix3dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glUniformMatrix2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix2dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glUniform4dv(GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_0_Core->f.Uniform4dv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glUniform3dv(GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_0_Core->f.Uniform3dv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glUniform2dv(GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_0_Core->f.Uniform2dv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glUniform1dv(GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_0_Core->f.Uniform1dv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glUniform4d(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_4_0_Core->f.Uniform4d(location, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glUniform3d(GLint location, GLdouble x, GLdouble y, GLdouble z)
-{
-    d_4_0_Core->f.Uniform3d(location, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glUniform2d(GLint location, GLdouble x, GLdouble y)
-{
-    d_4_0_Core->f.Uniform2d(location, x, y);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glUniform1d(GLint location, GLdouble x)
-{
-    d_4_0_Core->f.Uniform1d(location, x);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glDrawElementsIndirect(GLenum mode, GLenum type, const GLvoid *indirect)
-{
-    d_4_0_Core->f.DrawElementsIndirect(mode, type, indirect);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glDrawArraysIndirect(GLenum mode, const GLvoid *indirect)
-{
-    d_4_0_Core->f.DrawArraysIndirect(mode, indirect);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glBlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
-{
-    d_4_0_Core->f.BlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glBlendFunci(GLuint buf, GLenum src, GLenum dst)
-{
-    d_4_0_Core->f.BlendFunci(buf, src, dst);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glBlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha)
-{
-    d_4_0_Core->f.BlendEquationSeparatei(buf, modeRGB, modeAlpha);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glBlendEquationi(GLuint buf, GLenum mode)
-{
-    d_4_0_Core->f.BlendEquationi(buf, mode);
-}
-
-inline void QOpenGLFunctions_4_0_Core::glMinSampleShading(GLfloat value)
-{
-    d_4_0_Core->f.MinSampleShading(value);
-}
-
-
-
-QT_END_NAMESPACE
-
-#endif // QT_NO_OPENGL && !QT_OPENGL_ES_2
-
-#endif
diff --git a/src/gui/opengl/qopenglfunctions_4_1_compatibility.cpp b/src/gui/opengl/qopenglfunctions_4_1_compatibility.cpp
deleted file mode 100644
index bdea8b5ba9..0000000000
--- a/src/gui/opengl/qopenglfunctions_4_1_compatibility.cpp
+++ /dev/null
@@ -1,300 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#include "qopenglfunctions_4_1_compatibility.h"
-#include "qopenglcontext.h"
-
-QT_BEGIN_NAMESPACE
-
-/*!
-    \class QOpenGLFunctions_4_1_Compatibility
-    \inmodule QtGui
-    \since 5.1
-    \wrapper
-    \brief The QOpenGLFunctions_4_1_Compatibility class provides all functions for OpenGL 4.1 compatibility profile.
-
-    This class is a wrapper for functions from OpenGL 4.1 compatibility profile.
-    See reference pages on \l {http://www.opengl.org/sdk/docs/}{opengl.org}
-    for function documentation.
-
-    \sa QAbstractOpenGLFunctions
-*/
-
-QOpenGLFunctions_4_1_Compatibility::QOpenGLFunctions_4_1_Compatibility()
- : QAbstractOpenGLFunctions()
- , d_1_0_Core(nullptr)
- , d_1_1_Core(nullptr)
- , d_1_2_Core(nullptr)
- , d_1_3_Core(nullptr)
- , d_1_4_Core(nullptr)
- , d_1_5_Core(nullptr)
- , d_2_0_Core(nullptr)
- , d_2_1_Core(nullptr)
- , d_3_0_Core(nullptr)
- , d_3_1_Core(nullptr)
- , d_3_2_Core(nullptr)
- , d_3_3_Core(nullptr)
- , d_4_0_Core(nullptr)
- , d_4_1_Core(nullptr)
- , d_1_0_Deprecated(nullptr)
- , d_1_1_Deprecated(nullptr)
- , d_1_2_Deprecated(nullptr)
- , d_1_3_Deprecated(nullptr)
- , d_1_4_Deprecated(nullptr)
- , m_reserved_2_0_Deprecated(nullptr)
- , d_3_3_Deprecated(nullptr)
-{
-}
-
-QOpenGLFunctions_4_1_Compatibility::~QOpenGLFunctions_4_1_Compatibility()
-{
-    if (d_1_0_Core) {
-        d_1_0_Core->refs.deref();
-        Q_ASSERT(d_1_0_Core->refs.loadRelaxed());
-    }
-    if (d_1_1_Core) {
-        d_1_1_Core->refs.deref();
-        Q_ASSERT(d_1_1_Core->refs.loadRelaxed());
-    }
-    if (d_1_2_Core) {
-        d_1_2_Core->refs.deref();
-        Q_ASSERT(d_1_2_Core->refs.loadRelaxed());
-    }
-    if (d_1_3_Core) {
-        d_1_3_Core->refs.deref();
-        Q_ASSERT(d_1_3_Core->refs.loadRelaxed());
-    }
-    if (d_1_4_Core) {
-        d_1_4_Core->refs.deref();
-        Q_ASSERT(d_1_4_Core->refs.loadRelaxed());
-    }
-    if (d_1_5_Core) {
-        d_1_5_Core->refs.deref();
-        Q_ASSERT(d_1_5_Core->refs.loadRelaxed());
-    }
-    if (d_2_0_Core) {
-        d_2_0_Core->refs.deref();
-        Q_ASSERT(d_2_0_Core->refs.loadRelaxed());
-    }
-    if (d_2_1_Core) {
-        d_2_1_Core->refs.deref();
-        Q_ASSERT(d_2_1_Core->refs.loadRelaxed());
-    }
-    if (d_3_0_Core) {
-        d_3_0_Core->refs.deref();
-        Q_ASSERT(d_3_0_Core->refs.loadRelaxed());
-    }
-    if (d_3_1_Core) {
-        d_3_1_Core->refs.deref();
-        Q_ASSERT(d_3_1_Core->refs.loadRelaxed());
-    }
-    if (d_3_2_Core) {
-        d_3_2_Core->refs.deref();
-        Q_ASSERT(d_3_2_Core->refs.loadRelaxed());
-    }
-    if (d_3_3_Core) {
-        d_3_3_Core->refs.deref();
-        Q_ASSERT(d_3_3_Core->refs.loadRelaxed());
-    }
-    if (d_4_0_Core) {
-        d_4_0_Core->refs.deref();
-        Q_ASSERT(d_4_0_Core->refs.loadRelaxed());
-    }
-    if (d_4_1_Core) {
-        d_4_1_Core->refs.deref();
-        Q_ASSERT(d_4_1_Core->refs.loadRelaxed());
-    }
-    if (d_1_0_Deprecated) {
-        d_1_0_Deprecated->refs.deref();
-        Q_ASSERT(d_1_0_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_1_Deprecated) {
-        d_1_1_Deprecated->refs.deref();
-        Q_ASSERT(d_1_1_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_2_Deprecated) {
-        d_1_2_Deprecated->refs.deref();
-        Q_ASSERT(d_1_2_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_3_Deprecated) {
-        d_1_3_Deprecated->refs.deref();
-        Q_ASSERT(d_1_3_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_4_Deprecated) {
-        d_1_4_Deprecated->refs.deref();
-        Q_ASSERT(d_1_4_Deprecated->refs.loadRelaxed());
-    }
-    if (d_3_3_Deprecated) {
-        d_3_3_Deprecated->refs.deref();
-        Q_ASSERT(d_3_3_Deprecated->refs.loadRelaxed());
-    }
-}
-
-bool QOpenGLFunctions_4_1_Compatibility::initializeOpenGLFunctions()
-{
-    if ( isInitialized() )
-        return true;
-
-    QOpenGLContext* context = QOpenGLContext::currentContext();
-
-    // If owned by a context object make sure it is current.
-    // Also check that current context is capable of resolving all needed functions
-    if (((owningContext() && owningContext() == context) || !owningContext())
-        && QOpenGLFunctions_4_1_Compatibility::isContextCompatible(context))
-    {
-        // Associate with private implementation, creating if necessary
-        // Function pointers in the backends are resolved at creation time
-        QOpenGLVersionFunctionsBackend* d = nullptr;
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        d_1_3_Core = static_cast<QOpenGLFunctions_1_3_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        d_1_4_Core = static_cast<QOpenGLFunctions_1_4_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        d_1_5_Core = static_cast<QOpenGLFunctions_1_5_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        d_2_0_Core = static_cast<QOpenGLFunctions_2_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        d_2_1_Core = static_cast<QOpenGLFunctions_2_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        d_3_0_Core = static_cast<QOpenGLFunctions_3_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
-        d_3_1_Core = static_cast<QOpenGLFunctions_3_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
-        d_3_2_Core = static_cast<QOpenGLFunctions_3_2_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_CoreBackend::versionStatus());
-        d_3_3_Core = static_cast<QOpenGLFunctions_3_3_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_0_CoreBackend::versionStatus());
-        d_4_0_Core = static_cast<QOpenGLFunctions_4_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_1_CoreBackend::versionStatus());
-        d_4_1_Core = static_cast<QOpenGLFunctions_4_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
-        d_1_0_Deprecated = static_cast<QOpenGLFunctions_1_0_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
-        d_1_1_Deprecated = static_cast<QOpenGLFunctions_1_1_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus());
-        d_1_2_Deprecated = static_cast<QOpenGLFunctions_1_2_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus());
-        d_1_3_Deprecated = static_cast<QOpenGLFunctions_1_3_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
-        d_1_4_Deprecated = static_cast<QOpenGLFunctions_1_4_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_DeprecatedBackend::versionStatus());
-        d_3_3_Deprecated = static_cast<QOpenGLFunctions_3_3_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        QAbstractOpenGLFunctions::initializeOpenGLFunctions();
-    }
-    return isInitialized();
-}
-
-bool QOpenGLFunctions_4_1_Compatibility::isContextCompatible(QOpenGLContext *context)
-{
-    Q_ASSERT(context);
-    QSurfaceFormat f = context->format();
-    const QPair<int, int> v = qMakePair(f.majorVersion(), f.minorVersion());
-    if (v < qMakePair(4, 1))
-        return false;
-
-    if (f.profile() == QSurfaceFormat::CoreProfile)
-        return false;
-
-    return true;
-}
-
-QOpenGLVersionProfile QOpenGLFunctions_4_1_Compatibility::versionProfile()
-{
-    QOpenGLVersionProfile v;
-    v.setVersion(4, 1);
-    v.setProfile(QSurfaceFormat::CompatibilityProfile);
-    return v;
-}
-
-QT_END_NAMESPACE
diff --git a/src/gui/opengl/qopenglfunctions_4_1_compatibility.h b/src/gui/opengl/qopenglfunctions_4_1_compatibility.h
deleted file mode 100644
index bee169b50c..0000000000
--- a/src/gui/opengl/qopenglfunctions_4_1_compatibility.h
+++ /dev/null
@@ -1,5556 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#ifndef QOPENGLVERSIONFUNCTIONS_4_1_COMPATIBILITY_H
-#define QOPENGLVERSIONFUNCTIONS_4_1_COMPATIBILITY_H
-
-#include <QtGui/qtguiglobal.h>
-
-#if !defined(QT_NO_OPENGL) && !defined(QT_OPENGL_ES_2)
-
-#include <QtGui/QOpenGLVersionFunctions>
-#include <QtGui/qopenglcontext.h>
-
-QT_BEGIN_NAMESPACE
-
-class Q_GUI_EXPORT QOpenGLFunctions_4_1_Compatibility : public QAbstractOpenGLFunctions
-{
-public:
-    QOpenGLFunctions_4_1_Compatibility();
-    ~QOpenGLFunctions_4_1_Compatibility();
-
-    bool initializeOpenGLFunctions() override;
-
-    // OpenGL 1.0 core functions
-    void glViewport(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glDepthRange(GLdouble nearVal, GLdouble farVal);
-    GLboolean glIsEnabled(GLenum cap);
-    void glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params);
-    void glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params);
-    void glGetTexParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
-    const GLubyte * glGetString(GLenum name);
-    void glGetIntegerv(GLenum pname, GLint *params);
-    void glGetFloatv(GLenum pname, GLfloat *params);
-    GLenum glGetError();
-    void glGetDoublev(GLenum pname, GLdouble *params);
-    void glGetBooleanv(GLenum pname, GLboolean *params);
-    void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
-    void glReadBuffer(GLenum mode);
-    void glPixelStorei(GLenum pname, GLint param);
-    void glPixelStoref(GLenum pname, GLfloat param);
-    void glDepthFunc(GLenum func);
-    void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass);
-    void glStencilFunc(GLenum func, GLint ref, GLuint mask);
-    void glLogicOp(GLenum opcode);
-    void glBlendFunc(GLenum sfactor, GLenum dfactor);
-    void glFlush();
-    void glFinish();
-    void glEnable(GLenum cap);
-    void glDisable(GLenum cap);
-    void glDepthMask(GLboolean flag);
-    void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
-    void glStencilMask(GLuint mask);
-    void glClearDepth(GLdouble depth);
-    void glClearStencil(GLint s);
-    void glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glClear(GLbitfield mask);
-    void glDrawBuffer(GLenum mode);
-    void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glTexParameteri(GLenum target, GLenum pname, GLint param);
-    void glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glTexParameterf(GLenum target, GLenum pname, GLfloat param);
-    void glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glPolygonMode(GLenum face, GLenum mode);
-    void glPointSize(GLfloat size);
-    void glLineWidth(GLfloat width);
-    void glHint(GLenum target, GLenum mode);
-    void glFrontFace(GLenum mode);
-    void glCullFace(GLenum mode);
-
-    // OpenGL 1.1 core functions
-    void glIndexubv(const GLubyte *c);
-    void glIndexub(GLubyte c);
-    GLboolean glIsTexture(GLuint texture);
-    void glGenTextures(GLsizei n, GLuint *textures);
-    void glDeleteTextures(GLsizei n, const GLuint *textures);
-    void glBindTexture(GLenum target, GLuint texture);
-    void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
-    void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
-    void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
-    void glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
-    void glPolygonOffset(GLfloat factor, GLfloat units);
-    void glGetPointerv(GLenum pname, GLvoid* *params);
-    void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
-    void glDrawArrays(GLenum mode, GLint first, GLsizei count);
-
-    // OpenGL 1.2 core functions
-    void glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices);
-    void glBlendEquation(GLenum mode);
-    void glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-
-    // OpenGL 1.3 core functions
-    void glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img);
-    void glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glSampleCoverage(GLfloat value, GLboolean invert);
-    void glActiveTexture(GLenum texture);
-
-    // OpenGL 1.4 core functions
-    void glPointParameteriv(GLenum pname, const GLint *params);
-    void glPointParameteri(GLenum pname, GLint param);
-    void glPointParameterfv(GLenum pname, const GLfloat *params);
-    void glPointParameterf(GLenum pname, GLfloat param);
-    void glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount);
-    void glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount);
-    void glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
-
-    // OpenGL 1.5 core functions
-    void glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params);
-    void glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params);
-    GLboolean glUnmapBuffer(GLenum target);
-    GLvoid* glMapBuffer(GLenum target, GLenum access);
-    void glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data);
-    void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data);
-    void glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage);
-    GLboolean glIsBuffer(GLuint buffer);
-    void glGenBuffers(GLsizei n, GLuint *buffers);
-    void glDeleteBuffers(GLsizei n, const GLuint *buffers);
-    void glBindBuffer(GLenum target, GLuint buffer);
-    void glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params);
-    void glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params);
-    void glGetQueryiv(GLenum target, GLenum pname, GLint *params);
-    void glEndQuery(GLenum target);
-    void glBeginQuery(GLenum target, GLuint id);
-    GLboolean glIsQuery(GLuint id);
-    void glDeleteQueries(GLsizei n, const GLuint *ids);
-    void glGenQueries(GLsizei n, GLuint *ids);
-
-    // OpenGL 2.0 core functions
-    void glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer);
-    void glValidateProgram(GLuint program);
-    void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniform4iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform3iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform2iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform1iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform4fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform3fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform2fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform1fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
-    void glUniform3i(GLint location, GLint v0, GLint v1, GLint v2);
-    void glUniform2i(GLint location, GLint v0, GLint v1);
-    void glUniform1i(GLint location, GLint v0);
-    void glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
-    void glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
-    void glUniform2f(GLint location, GLfloat v0, GLfloat v1);
-    void glUniform1f(GLint location, GLfloat v0);
-    void glUseProgram(GLuint program);
-    void glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length);
-    void glLinkProgram(GLuint program);
-    GLboolean glIsShader(GLuint shader);
-    GLboolean glIsProgram(GLuint program);
-    void glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer);
-    void glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params);
-    void glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params);
-    void glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params);
-    void glGetUniformiv(GLuint program, GLint location, GLint *params);
-    void glGetUniformfv(GLuint program, GLint location, GLfloat *params);
-    GLint glGetUniformLocation(GLuint program, const GLchar *name);
-    void glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source);
-    void glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void glGetShaderiv(GLuint shader, GLenum pname, GLint *params);
-    void glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void glGetProgramiv(GLuint program, GLenum pname, GLint *params);
-    GLint glGetAttribLocation(GLuint program, const GLchar *name);
-    void glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj);
-    void glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
-    void glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
-    void glEnableVertexAttribArray(GLuint index);
-    void glDisableVertexAttribArray(GLuint index);
-    void glDetachShader(GLuint program, GLuint shader);
-    void glDeleteShader(GLuint shader);
-    void glDeleteProgram(GLuint program);
-    GLuint glCreateShader(GLenum type);
-    GLuint glCreateProgram();
-    void glCompileShader(GLuint shader);
-    void glBindAttribLocation(GLuint program, GLuint index, const GLchar *name);
-    void glAttachShader(GLuint program, GLuint shader);
-    void glStencilMaskSeparate(GLenum face, GLuint mask);
-    void glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask);
-    void glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);
-    void glDrawBuffers(GLsizei n, const GLenum *bufs);
-    void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha);
-
-    // OpenGL 2.1 core functions
-    void glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-
-    // OpenGL 3.0 core functions
-    GLboolean glIsVertexArray(GLuint array);
-    void glGenVertexArrays(GLsizei n, GLuint *arrays);
-    void glDeleteVertexArrays(GLsizei n, const GLuint *arrays);
-    void glBindVertexArray(GLuint array);
-    void glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length);
-    GLvoid* glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
-    void glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
-    void glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
-    void glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
-    void glGenerateMipmap(GLenum target);
-    void glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params);
-    void glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
-    void glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset);
-    void glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
-    void glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
-    GLenum glCheckFramebufferStatus(GLenum target);
-    void glGenFramebuffers(GLsizei n, GLuint *framebuffers);
-    void glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers);
-    void glBindFramebuffer(GLenum target, GLuint framebuffer);
-    GLboolean glIsFramebuffer(GLuint framebuffer);
-    void glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
-    void glGenRenderbuffers(GLsizei n, GLuint *renderbuffers);
-    void glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers);
-    void glBindRenderbuffer(GLenum target, GLuint renderbuffer);
-    GLboolean glIsRenderbuffer(GLuint renderbuffer);
-    const GLubyte * glGetStringi(GLenum name, GLuint index);
-    void glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
-    void glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value);
-    void glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value);
-    void glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value);
-    void glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params);
-    void glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params);
-    void glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params);
-    void glTexParameterIiv(GLenum target, GLenum pname, const GLint *params);
-    void glUniform4uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform3uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform2uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform1uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
-    void glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2);
-    void glUniform2ui(GLint location, GLuint v0, GLuint v1);
-    void glUniform1ui(GLint location, GLuint v0);
-    GLint glGetFragDataLocation(GLuint program, const GLchar *name);
-    void glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name);
-    void glGetUniformuiv(GLuint program, GLint location, GLuint *params);
-    void glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params);
-    void glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params);
-    void glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glEndConditionalRender();
-    void glBeginConditionalRender(GLuint id, GLenum mode);
-    void glClampColor(GLenum target, GLenum clamp);
-    void glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name);
-    void glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode);
-    void glBindBufferBase(GLenum target, GLuint index, GLuint buffer);
-    void glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
-    void glEndTransformFeedback();
-    void glBeginTransformFeedback(GLenum primitiveMode);
-    GLboolean glIsEnabledi(GLenum target, GLuint index);
-    void glDisablei(GLenum target, GLuint index);
-    void glEnablei(GLenum target, GLuint index);
-    void glGetIntegeri_v(GLenum target, GLuint index, GLint *data);
-    void glGetBooleani_v(GLenum target, GLuint index, GLboolean *data);
-    void glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a);
-
-    // OpenGL 3.1 core functions
-    void glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
-    void glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);
-    void glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName);
-    void glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params);
-    GLuint glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName);
-    void glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName);
-    void glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params);
-    void glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const *uniformNames, GLuint *uniformIndices);
-    void glPrimitiveRestartIndex(GLuint index);
-    void glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer);
-    void glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount);
-    void glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount);
-
-    // OpenGL 3.2 core functions
-    void glSampleMaski(GLuint index, GLbitfield mask);
-    void glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val);
-    void glTexImage3DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
-    void glTexImage2DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
-    void glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values);
-    void glGetInteger64v(GLenum pname, GLint64 *params);
-    void glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout);
-    GLenum glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout);
-    void glDeleteSync(GLsync sync);
-    GLboolean glIsSync(GLsync sync);
-    GLsync glFenceSync(GLenum condition, GLbitfield flags);
-    void glProvokingVertex(GLenum mode);
-    void glMultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount, const GLint *basevertex);
-    void glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount, GLint basevertex);
-    void glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex);
-    void glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex);
-    void glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level);
-    void glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params);
-    void glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data);
-
-    // OpenGL 3.3 core functions
-    void glVertexAttribP4uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glVertexAttribP3uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glVertexAttribP2uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glVertexAttribP1uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glSecondaryColorP3uiv(GLenum type, const GLuint *color);
-    void glSecondaryColorP3ui(GLenum type, GLuint color);
-    void glColorP4uiv(GLenum type, const GLuint *color);
-    void glColorP4ui(GLenum type, GLuint color);
-    void glColorP3uiv(GLenum type, const GLuint *color);
-    void glColorP3ui(GLenum type, GLuint color);
-    void glNormalP3uiv(GLenum type, const GLuint *coords);
-    void glNormalP3ui(GLenum type, GLuint coords);
-    void glMultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint *coords);
-    void glMultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords);
-    void glMultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint *coords);
-    void glMultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords);
-    void glMultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint *coords);
-    void glMultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords);
-    void glMultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint *coords);
-    void glMultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords);
-    void glTexCoordP4uiv(GLenum type, const GLuint *coords);
-    void glTexCoordP4ui(GLenum type, GLuint coords);
-    void glTexCoordP3uiv(GLenum type, const GLuint *coords);
-    void glTexCoordP3ui(GLenum type, GLuint coords);
-    void glTexCoordP2uiv(GLenum type, const GLuint *coords);
-    void glTexCoordP2ui(GLenum type, GLuint coords);
-    void glTexCoordP1uiv(GLenum type, const GLuint *coords);
-    void glTexCoordP1ui(GLenum type, GLuint coords);
-    void glVertexP4uiv(GLenum type, const GLuint *value);
-    void glVertexP4ui(GLenum type, GLuint value);
-    void glVertexP3uiv(GLenum type, const GLuint *value);
-    void glVertexP3ui(GLenum type, GLuint value);
-    void glVertexP2uiv(GLenum type, const GLuint *value);
-    void glVertexP2ui(GLenum type, GLuint value);
-    void glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params);
-    void glGetQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params);
-    void glQueryCounter(GLuint id, GLenum target);
-    void glGetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params);
-    void glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params);
-    void glGetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params);
-    void glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params);
-    void glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param);
-    void glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param);
-    void glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param);
-    void glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param);
-    void glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param);
-    void glSamplerParameteri(GLuint sampler, GLenum pname, GLint param);
-    void glBindSampler(GLuint unit, GLuint sampler);
-    GLboolean glIsSampler(GLuint sampler);
-    void glDeleteSamplers(GLsizei count, const GLuint *samplers);
-    void glGenSamplers(GLsizei count, GLuint *samplers);
-    GLint glGetFragDataIndex(GLuint program, const GLchar *name);
-    void glBindFragDataLocationIndexed(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name);
-    void glVertexAttribDivisor(GLuint index, GLuint divisor);
-
-    // OpenGL 4.0 core functions
-    void glGetQueryIndexediv(GLenum target, GLuint index, GLenum pname, GLint *params);
-    void glEndQueryIndexed(GLenum target, GLuint index);
-    void glBeginQueryIndexed(GLenum target, GLuint index, GLuint id);
-    void glDrawTransformFeedbackStream(GLenum mode, GLuint id, GLuint stream);
-    void glDrawTransformFeedback(GLenum mode, GLuint id);
-    void glResumeTransformFeedback();
-    void glPauseTransformFeedback();
-    GLboolean glIsTransformFeedback(GLuint id);
-    void glGenTransformFeedbacks(GLsizei n, GLuint *ids);
-    void glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids);
-    void glBindTransformFeedback(GLenum target, GLuint id);
-    void glPatchParameterfv(GLenum pname, const GLfloat *values);
-    void glPatchParameteri(GLenum pname, GLint value);
-    void glGetProgramStageiv(GLuint program, GLenum shadertype, GLenum pname, GLint *values);
-    void glGetUniformSubroutineuiv(GLenum shadertype, GLint location, GLuint *params);
-    void glUniformSubroutinesuiv(GLenum shadertype, GLsizei count, const GLuint *indices);
-    void glGetActiveSubroutineName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name);
-    void glGetActiveSubroutineUniformName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name);
-    void glGetActiveSubroutineUniformiv(GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values);
-    GLuint glGetSubroutineIndex(GLuint program, GLenum shadertype, const GLchar *name);
-    GLint glGetSubroutineUniformLocation(GLuint program, GLenum shadertype, const GLchar *name);
-    void glGetUniformdv(GLuint program, GLint location, GLdouble *params);
-    void glUniformMatrix4x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix4x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix3x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix3x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix2x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix2x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniform4dv(GLint location, GLsizei count, const GLdouble *value);
-    void glUniform3dv(GLint location, GLsizei count, const GLdouble *value);
-    void glUniform2dv(GLint location, GLsizei count, const GLdouble *value);
-    void glUniform1dv(GLint location, GLsizei count, const GLdouble *value);
-    void glUniform4d(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glUniform3d(GLint location, GLdouble x, GLdouble y, GLdouble z);
-    void glUniform2d(GLint location, GLdouble x, GLdouble y);
-    void glUniform1d(GLint location, GLdouble x);
-    void glDrawElementsIndirect(GLenum mode, GLenum type, const GLvoid *indirect);
-    void glDrawArraysIndirect(GLenum mode, const GLvoid *indirect);
-    void glBlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
-    void glBlendFunci(GLuint buf, GLenum src, GLenum dst);
-    void glBlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha);
-    void glBlendEquationi(GLuint buf, GLenum mode);
-    void glMinSampleShading(GLfloat value);
-
-    // OpenGL 4.1 core functions
-    void glGetDoublei_v(GLenum target, GLuint index, GLdouble *data);
-    void glGetFloati_v(GLenum target, GLuint index, GLfloat *data);
-    void glDepthRangeIndexed(GLuint index, GLdouble n, GLdouble f);
-    void glDepthRangeArrayv(GLuint first, GLsizei count, const GLdouble *v);
-    void glScissorIndexedv(GLuint index, const GLint *v);
-    void glScissorIndexed(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height);
-    void glScissorArrayv(GLuint first, GLsizei count, const GLint *v);
-    void glViewportIndexedfv(GLuint index, const GLfloat *v);
-    void glViewportIndexedf(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h);
-    void glViewportArrayv(GLuint first, GLsizei count, const GLfloat *v);
-    void glGetVertexAttribLdv(GLuint index, GLenum pname, GLdouble *params);
-    void glVertexAttribLPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glVertexAttribL4dv(GLuint index, const GLdouble *v);
-    void glVertexAttribL3dv(GLuint index, const GLdouble *v);
-    void glVertexAttribL2dv(GLuint index, const GLdouble *v);
-    void glVertexAttribL1dv(GLuint index, const GLdouble *v);
-    void glVertexAttribL4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glVertexAttribL3d(GLuint index, GLdouble x, GLdouble y, GLdouble z);
-    void glVertexAttribL2d(GLuint index, GLdouble x, GLdouble y);
-    void glVertexAttribL1d(GLuint index, GLdouble x);
-    void glGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void glValidateProgramPipeline(GLuint pipeline);
-    void glProgramUniformMatrix4x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix3x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix4x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix2x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix3x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix2x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix4x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix3x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix4x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix2x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix3x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix2x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniform4uiv(GLuint program, GLint location, GLsizei count, const GLuint *value);
-    void glProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
-    void glProgramUniform4dv(GLuint program, GLint location, GLsizei count, const GLdouble *value);
-    void glProgramUniform4d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3);
-    void glProgramUniform4fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-    void glProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
-    void glProgramUniform4iv(GLuint program, GLint location, GLsizei count, const GLint *value);
-    void glProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
-    void glProgramUniform3uiv(GLuint program, GLint location, GLsizei count, const GLuint *value);
-    void glProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2);
-    void glProgramUniform3dv(GLuint program, GLint location, GLsizei count, const GLdouble *value);
-    void glProgramUniform3d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2);
-    void glProgramUniform3fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-    void glProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
-    void glProgramUniform3iv(GLuint program, GLint location, GLsizei count, const GLint *value);
-    void glProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2);
-    void glProgramUniform2uiv(GLuint program, GLint location, GLsizei count, const GLuint *value);
-    void glProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1);
-    void glProgramUniform2dv(GLuint program, GLint location, GLsizei count, const GLdouble *value);
-    void glProgramUniform2d(GLuint program, GLint location, GLdouble v0, GLdouble v1);
-    void glProgramUniform2fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-    void glProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1);
-    void glProgramUniform2iv(GLuint program, GLint location, GLsizei count, const GLint *value);
-    void glProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1);
-    void glProgramUniform1uiv(GLuint program, GLint location, GLsizei count, const GLuint *value);
-    void glProgramUniform1ui(GLuint program, GLint location, GLuint v0);
-    void glProgramUniform1dv(GLuint program, GLint location, GLsizei count, const GLdouble *value);
-    void glProgramUniform1d(GLuint program, GLint location, GLdouble v0);
-    void glProgramUniform1fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-    void glProgramUniform1f(GLuint program, GLint location, GLfloat v0);
-    void glProgramUniform1iv(GLuint program, GLint location, GLsizei count, const GLint *value);
-    void glProgramUniform1i(GLuint program, GLint location, GLint v0);
-    void glGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params);
-    GLboolean glIsProgramPipeline(GLuint pipeline);
-    void glGenProgramPipelines(GLsizei n, GLuint *pipelines);
-    void glDeleteProgramPipelines(GLsizei n, const GLuint *pipelines);
-    void glBindProgramPipeline(GLuint pipeline);
-    GLuint glCreateShaderProgramv(GLenum type, GLsizei count, const GLchar* const *strings);
-    void glActiveShaderProgram(GLuint pipeline, GLuint program);
-    void glUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program);
-    void glProgramParameteri(GLuint program, GLenum pname, GLint value);
-    void glProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid *binary, GLsizei length);
-    void glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, GLvoid *binary);
-    void glClearDepthf(GLfloat dd);
-    void glDepthRangef(GLfloat n, GLfloat f);
-    void glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision);
-    void glShaderBinary(GLsizei count, const GLuint *shaders, GLenum binaryformat, const GLvoid *binary, GLsizei length);
-    void glReleaseShaderCompiler();
-
-    // OpenGL 1.0 deprecated functions
-    void glTranslatef(GLfloat x, GLfloat y, GLfloat z);
-    void glTranslated(GLdouble x, GLdouble y, GLdouble z);
-    void glScalef(GLfloat x, GLfloat y, GLfloat z);
-    void glScaled(GLdouble x, GLdouble y, GLdouble z);
-    void glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
-    void glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
-    void glPushMatrix();
-    void glPopMatrix();
-    void glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
-    void glMultMatrixd(const GLdouble *m);
-    void glMultMatrixf(const GLfloat *m);
-    void glMatrixMode(GLenum mode);
-    void glLoadMatrixd(const GLdouble *m);
-    void glLoadMatrixf(const GLfloat *m);
-    void glLoadIdentity();
-    void glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
-    GLboolean glIsList(GLuint list);
-    void glGetTexGeniv(GLenum coord, GLenum pname, GLint *params);
-    void glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params);
-    void glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params);
-    void glGetTexEnviv(GLenum target, GLenum pname, GLint *params);
-    void glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetPolygonStipple(GLubyte *mask);
-    void glGetPixelMapusv(GLenum map, GLushort *values);
-    void glGetPixelMapuiv(GLenum map, GLuint *values);
-    void glGetPixelMapfv(GLenum map, GLfloat *values);
-    void glGetMaterialiv(GLenum face, GLenum pname, GLint *params);
-    void glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params);
-    void glGetMapiv(GLenum target, GLenum query, GLint *v);
-    void glGetMapfv(GLenum target, GLenum query, GLfloat *v);
-    void glGetMapdv(GLenum target, GLenum query, GLdouble *v);
-    void glGetLightiv(GLenum light, GLenum pname, GLint *params);
-    void glGetLightfv(GLenum light, GLenum pname, GLfloat *params);
-    void glGetClipPlane(GLenum plane, GLdouble *equation);
-    void glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
-    void glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
-    void glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values);
-    void glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values);
-    void glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values);
-    void glPixelTransferi(GLenum pname, GLint param);
-    void glPixelTransferf(GLenum pname, GLfloat param);
-    void glPixelZoom(GLfloat xfactor, GLfloat yfactor);
-    void glAlphaFunc(GLenum func, GLfloat ref);
-    void glEvalPoint2(GLint i, GLint j);
-    void glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
-    void glEvalPoint1(GLint i);
-    void glEvalMesh1(GLenum mode, GLint i1, GLint i2);
-    void glEvalCoord2fv(const GLfloat *u);
-    void glEvalCoord2f(GLfloat u, GLfloat v);
-    void glEvalCoord2dv(const GLdouble *u);
-    void glEvalCoord2d(GLdouble u, GLdouble v);
-    void glEvalCoord1fv(const GLfloat *u);
-    void glEvalCoord1f(GLfloat u);
-    void glEvalCoord1dv(const GLdouble *u);
-    void glEvalCoord1d(GLdouble u);
-    void glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
-    void glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
-    void glMapGrid1f(GLint un, GLfloat u1, GLfloat u2);
-    void glMapGrid1d(GLint un, GLdouble u1, GLdouble u2);
-    void glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);
-    void glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);
-    void glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);
-    void glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);
-    void glPushAttrib(GLbitfield mask);
-    void glPopAttrib();
-    void glAccum(GLenum op, GLfloat value);
-    void glIndexMask(GLuint mask);
-    void glClearIndex(GLfloat c);
-    void glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glPushName(GLuint name);
-    void glPopName();
-    void glPassThrough(GLfloat token);
-    void glLoadName(GLuint name);
-    void glInitNames();
-    GLint glRenderMode(GLenum mode);
-    void glSelectBuffer(GLsizei size, GLuint *buffer);
-    void glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer);
-    void glTexGeniv(GLenum coord, GLenum pname, const GLint *params);
-    void glTexGeni(GLenum coord, GLenum pname, GLint param);
-    void glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params);
-    void glTexGenf(GLenum coord, GLenum pname, GLfloat param);
-    void glTexGendv(GLenum coord, GLenum pname, const GLdouble *params);
-    void glTexGend(GLenum coord, GLenum pname, GLdouble param);
-    void glTexEnviv(GLenum target, GLenum pname, const GLint *params);
-    void glTexEnvi(GLenum target, GLenum pname, GLint param);
-    void glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glTexEnvf(GLenum target, GLenum pname, GLfloat param);
-    void glShadeModel(GLenum mode);
-    void glPolygonStipple(const GLubyte *mask);
-    void glMaterialiv(GLenum face, GLenum pname, const GLint *params);
-    void glMateriali(GLenum face, GLenum pname, GLint param);
-    void glMaterialfv(GLenum face, GLenum pname, const GLfloat *params);
-    void glMaterialf(GLenum face, GLenum pname, GLfloat param);
-    void glLineStipple(GLint factor, GLushort pattern);
-    void glLightModeliv(GLenum pname, const GLint *params);
-    void glLightModeli(GLenum pname, GLint param);
-    void glLightModelfv(GLenum pname, const GLfloat *params);
-    void glLightModelf(GLenum pname, GLfloat param);
-    void glLightiv(GLenum light, GLenum pname, const GLint *params);
-    void glLighti(GLenum light, GLenum pname, GLint param);
-    void glLightfv(GLenum light, GLenum pname, const GLfloat *params);
-    void glLightf(GLenum light, GLenum pname, GLfloat param);
-    void glFogiv(GLenum pname, const GLint *params);
-    void glFogi(GLenum pname, GLint param);
-    void glFogfv(GLenum pname, const GLfloat *params);
-    void glFogf(GLenum pname, GLfloat param);
-    void glColorMaterial(GLenum face, GLenum mode);
-    void glClipPlane(GLenum plane, const GLdouble *equation);
-    void glVertex4sv(const GLshort *v);
-    void glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w);
-    void glVertex4iv(const GLint *v);
-    void glVertex4i(GLint x, GLint y, GLint z, GLint w);
-    void glVertex4fv(const GLfloat *v);
-    void glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void glVertex4dv(const GLdouble *v);
-    void glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glVertex3sv(const GLshort *v);
-    void glVertex3s(GLshort x, GLshort y, GLshort z);
-    void glVertex3iv(const GLint *v);
-    void glVertex3i(GLint x, GLint y, GLint z);
-    void glVertex3fv(const GLfloat *v);
-    void glVertex3f(GLfloat x, GLfloat y, GLfloat z);
-    void glVertex3dv(const GLdouble *v);
-    void glVertex3d(GLdouble x, GLdouble y, GLdouble z);
-    void glVertex2sv(const GLshort *v);
-    void glVertex2s(GLshort x, GLshort y);
-    void glVertex2iv(const GLint *v);
-    void glVertex2i(GLint x, GLint y);
-    void glVertex2fv(const GLfloat *v);
-    void glVertex2f(GLfloat x, GLfloat y);
-    void glVertex2dv(const GLdouble *v);
-    void glVertex2d(GLdouble x, GLdouble y);
-    void glTexCoord4sv(const GLshort *v);
-    void glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q);
-    void glTexCoord4iv(const GLint *v);
-    void glTexCoord4i(GLint s, GLint t, GLint r, GLint q);
-    void glTexCoord4fv(const GLfloat *v);
-    void glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
-    void glTexCoord4dv(const GLdouble *v);
-    void glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q);
-    void glTexCoord3sv(const GLshort *v);
-    void glTexCoord3s(GLshort s, GLshort t, GLshort r);
-    void glTexCoord3iv(const GLint *v);
-    void glTexCoord3i(GLint s, GLint t, GLint r);
-    void glTexCoord3fv(const GLfloat *v);
-    void glTexCoord3f(GLfloat s, GLfloat t, GLfloat r);
-    void glTexCoord3dv(const GLdouble *v);
-    void glTexCoord3d(GLdouble s, GLdouble t, GLdouble r);
-    void glTexCoord2sv(const GLshort *v);
-    void glTexCoord2s(GLshort s, GLshort t);
-    void glTexCoord2iv(const GLint *v);
-    void glTexCoord2i(GLint s, GLint t);
-    void glTexCoord2fv(const GLfloat *v);
-    void glTexCoord2f(GLfloat s, GLfloat t);
-    void glTexCoord2dv(const GLdouble *v);
-    void glTexCoord2d(GLdouble s, GLdouble t);
-    void glTexCoord1sv(const GLshort *v);
-    void glTexCoord1s(GLshort s);
-    void glTexCoord1iv(const GLint *v);
-    void glTexCoord1i(GLint s);
-    void glTexCoord1fv(const GLfloat *v);
-    void glTexCoord1f(GLfloat s);
-    void glTexCoord1dv(const GLdouble *v);
-    void glTexCoord1d(GLdouble s);
-    void glRectsv(const GLshort *v1, const GLshort *v2);
-    void glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
-    void glRectiv(const GLint *v1, const GLint *v2);
-    void glRecti(GLint x1, GLint y1, GLint x2, GLint y2);
-    void glRectfv(const GLfloat *v1, const GLfloat *v2);
-    void glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
-    void glRectdv(const GLdouble *v1, const GLdouble *v2);
-    void glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
-    void glRasterPos4sv(const GLshort *v);
-    void glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w);
-    void glRasterPos4iv(const GLint *v);
-    void glRasterPos4i(GLint x, GLint y, GLint z, GLint w);
-    void glRasterPos4fv(const GLfloat *v);
-    void glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void glRasterPos4dv(const GLdouble *v);
-    void glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glRasterPos3sv(const GLshort *v);
-    void glRasterPos3s(GLshort x, GLshort y, GLshort z);
-    void glRasterPos3iv(const GLint *v);
-    void glRasterPos3i(GLint x, GLint y, GLint z);
-    void glRasterPos3fv(const GLfloat *v);
-    void glRasterPos3f(GLfloat x, GLfloat y, GLfloat z);
-    void glRasterPos3dv(const GLdouble *v);
-    void glRasterPos3d(GLdouble x, GLdouble y, GLdouble z);
-    void glRasterPos2sv(const GLshort *v);
-    void glRasterPos2s(GLshort x, GLshort y);
-    void glRasterPos2iv(const GLint *v);
-    void glRasterPos2i(GLint x, GLint y);
-    void glRasterPos2fv(const GLfloat *v);
-    void glRasterPos2f(GLfloat x, GLfloat y);
-    void glRasterPos2dv(const GLdouble *v);
-    void glRasterPos2d(GLdouble x, GLdouble y);
-    void glNormal3sv(const GLshort *v);
-    void glNormal3s(GLshort nx, GLshort ny, GLshort nz);
-    void glNormal3iv(const GLint *v);
-    void glNormal3i(GLint nx, GLint ny, GLint nz);
-    void glNormal3fv(const GLfloat *v);
-    void glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz);
-    void glNormal3dv(const GLdouble *v);
-    void glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz);
-    void glNormal3bv(const GLbyte *v);
-    void glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz);
-    void glIndexsv(const GLshort *c);
-    void glIndexs(GLshort c);
-    void glIndexiv(const GLint *c);
-    void glIndexi(GLint c);
-    void glIndexfv(const GLfloat *c);
-    void glIndexf(GLfloat c);
-    void glIndexdv(const GLdouble *c);
-    void glIndexd(GLdouble c);
-    void glEnd();
-    void glEdgeFlagv(const GLboolean *flag);
-    void glEdgeFlag(GLboolean flag);
-    void glColor4usv(const GLushort *v);
-    void glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha);
-    void glColor4uiv(const GLuint *v);
-    void glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha);
-    void glColor4ubv(const GLubyte *v);
-    void glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
-    void glColor4sv(const GLshort *v);
-    void glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha);
-    void glColor4iv(const GLint *v);
-    void glColor4i(GLint red, GLint green, GLint blue, GLint alpha);
-    void glColor4fv(const GLfloat *v);
-    void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glColor4dv(const GLdouble *v);
-    void glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
-    void glColor4bv(const GLbyte *v);
-    void glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
-    void glColor3usv(const GLushort *v);
-    void glColor3us(GLushort red, GLushort green, GLushort blue);
-    void glColor3uiv(const GLuint *v);
-    void glColor3ui(GLuint red, GLuint green, GLuint blue);
-    void glColor3ubv(const GLubyte *v);
-    void glColor3ub(GLubyte red, GLubyte green, GLubyte blue);
-    void glColor3sv(const GLshort *v);
-    void glColor3s(GLshort red, GLshort green, GLshort blue);
-    void glColor3iv(const GLint *v);
-    void glColor3i(GLint red, GLint green, GLint blue);
-    void glColor3fv(const GLfloat *v);
-    void glColor3f(GLfloat red, GLfloat green, GLfloat blue);
-    void glColor3dv(const GLdouble *v);
-    void glColor3d(GLdouble red, GLdouble green, GLdouble blue);
-    void glColor3bv(const GLbyte *v);
-    void glColor3b(GLbyte red, GLbyte green, GLbyte blue);
-    void glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap);
-    void glBegin(GLenum mode);
-    void glListBase(GLuint base);
-    GLuint glGenLists(GLsizei range);
-    void glDeleteLists(GLuint list, GLsizei range);
-    void glCallLists(GLsizei n, GLenum type, const GLvoid *lists);
-    void glCallList(GLuint list);
-    void glEndList();
-    void glNewList(GLuint list, GLenum mode);
-
-    // OpenGL 1.1 deprecated functions
-    void glPushClientAttrib(GLbitfield mask);
-    void glPopClientAttrib();
-    void glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities);
-    GLboolean glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences);
-    void glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer);
-    void glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glEnableClientState(GLenum array);
-    void glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer);
-    void glDisableClientState(GLenum array);
-    void glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glArrayElement(GLint i);
-
-    // OpenGL 1.2 deprecated functions
-    void glResetMinmax(GLenum target);
-    void glResetHistogram(GLenum target);
-    void glMinmax(GLenum target, GLenum internalformat, GLboolean sink);
-    void glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink);
-    void glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
-    void glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
-    void glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column);
-    void glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span);
-    void glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image);
-    void glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
-    void glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glConvolutionParameteri(GLenum target, GLenum pname, GLint params);
-    void glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params);
-    void glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image);
-    void glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image);
-    void glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width);
-    void glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data);
-    void glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table);
-    void glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
-    void glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table);
-
-    // OpenGL 1.3 deprecated functions
-    void glMultTransposeMatrixd(const GLdouble *m);
-    void glMultTransposeMatrixf(const GLfloat *m);
-    void glLoadTransposeMatrixd(const GLdouble *m);
-    void glLoadTransposeMatrixf(const GLfloat *m);
-    void glMultiTexCoord4sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);
-    void glMultiTexCoord4iv(GLenum target, const GLint *v);
-    void glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q);
-    void glMultiTexCoord4fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
-    void glMultiTexCoord4dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
-    void glMultiTexCoord3sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r);
-    void glMultiTexCoord3iv(GLenum target, const GLint *v);
-    void glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r);
-    void glMultiTexCoord3fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r);
-    void glMultiTexCoord3dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r);
-    void glMultiTexCoord2sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord2s(GLenum target, GLshort s, GLshort t);
-    void glMultiTexCoord2iv(GLenum target, const GLint *v);
-    void glMultiTexCoord2i(GLenum target, GLint s, GLint t);
-    void glMultiTexCoord2fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t);
-    void glMultiTexCoord2dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t);
-    void glMultiTexCoord1sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord1s(GLenum target, GLshort s);
-    void glMultiTexCoord1iv(GLenum target, const GLint *v);
-    void glMultiTexCoord1i(GLenum target, GLint s);
-    void glMultiTexCoord1fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord1f(GLenum target, GLfloat s);
-    void glMultiTexCoord1dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord1d(GLenum target, GLdouble s);
-    void glClientActiveTexture(GLenum texture);
-
-    // OpenGL 1.4 deprecated functions
-    void glWindowPos3sv(const GLshort *v);
-    void glWindowPos3s(GLshort x, GLshort y, GLshort z);
-    void glWindowPos3iv(const GLint *v);
-    void glWindowPos3i(GLint x, GLint y, GLint z);
-    void glWindowPos3fv(const GLfloat *v);
-    void glWindowPos3f(GLfloat x, GLfloat y, GLfloat z);
-    void glWindowPos3dv(const GLdouble *v);
-    void glWindowPos3d(GLdouble x, GLdouble y, GLdouble z);
-    void glWindowPos2sv(const GLshort *v);
-    void glWindowPos2s(GLshort x, GLshort y);
-    void glWindowPos2iv(const GLint *v);
-    void glWindowPos2i(GLint x, GLint y);
-    void glWindowPos2fv(const GLfloat *v);
-    void glWindowPos2f(GLfloat x, GLfloat y);
-    void glWindowPos2dv(const GLdouble *v);
-    void glWindowPos2d(GLdouble x, GLdouble y);
-    void glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glSecondaryColor3usv(const GLushort *v);
-    void glSecondaryColor3us(GLushort red, GLushort green, GLushort blue);
-    void glSecondaryColor3uiv(const GLuint *v);
-    void glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue);
-    void glSecondaryColor3ubv(const GLubyte *v);
-    void glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue);
-    void glSecondaryColor3sv(const GLshort *v);
-    void glSecondaryColor3s(GLshort red, GLshort green, GLshort blue);
-    void glSecondaryColor3iv(const GLint *v);
-    void glSecondaryColor3i(GLint red, GLint green, GLint blue);
-    void glSecondaryColor3fv(const GLfloat *v);
-    void glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue);
-    void glSecondaryColor3dv(const GLdouble *v);
-    void glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue);
-    void glSecondaryColor3bv(const GLbyte *v);
-    void glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue);
-    void glFogCoordPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glFogCoorddv(const GLdouble *coord);
-    void glFogCoordd(GLdouble coord);
-    void glFogCoordfv(const GLfloat *coord);
-    void glFogCoordf(GLfloat coord);
-
-    // OpenGL 1.5 deprecated functions
-
-    // OpenGL 2.0 deprecated functions
-    void glVertexAttrib4usv(GLuint index, const GLushort *v);
-    void glVertexAttrib4uiv(GLuint index, const GLuint *v);
-    void glVertexAttrib4ubv(GLuint index, const GLubyte *v);
-    void glVertexAttrib4sv(GLuint index, const GLshort *v);
-    void glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
-    void glVertexAttrib4iv(GLuint index, const GLint *v);
-    void glVertexAttrib4fv(GLuint index, const GLfloat *v);
-    void glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void glVertexAttrib4dv(GLuint index, const GLdouble *v);
-    void glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glVertexAttrib4bv(GLuint index, const GLbyte *v);
-    void glVertexAttrib4Nusv(GLuint index, const GLushort *v);
-    void glVertexAttrib4Nuiv(GLuint index, const GLuint *v);
-    void glVertexAttrib4Nubv(GLuint index, const GLubyte *v);
-    void glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
-    void glVertexAttrib4Nsv(GLuint index, const GLshort *v);
-    void glVertexAttrib4Niv(GLuint index, const GLint *v);
-    void glVertexAttrib4Nbv(GLuint index, const GLbyte *v);
-    void glVertexAttrib3sv(GLuint index, const GLshort *v);
-    void glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z);
-    void glVertexAttrib3fv(GLuint index, const GLfloat *v);
-    void glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z);
-    void glVertexAttrib3dv(GLuint index, const GLdouble *v);
-    void glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z);
-    void glVertexAttrib2sv(GLuint index, const GLshort *v);
-    void glVertexAttrib2s(GLuint index, GLshort x, GLshort y);
-    void glVertexAttrib2fv(GLuint index, const GLfloat *v);
-    void glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y);
-    void glVertexAttrib2dv(GLuint index, const GLdouble *v);
-    void glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y);
-    void glVertexAttrib1sv(GLuint index, const GLshort *v);
-    void glVertexAttrib1s(GLuint index, GLshort x);
-    void glVertexAttrib1fv(GLuint index, const GLfloat *v);
-    void glVertexAttrib1f(GLuint index, GLfloat x);
-    void glVertexAttrib1dv(GLuint index, const GLdouble *v);
-    void glVertexAttrib1d(GLuint index, GLdouble x);
-
-    // OpenGL 2.1 deprecated functions
-
-    // OpenGL 3.0 deprecated functions
-    void glVertexAttribI4usv(GLuint index, const GLushort *v);
-    void glVertexAttribI4ubv(GLuint index, const GLubyte *v);
-    void glVertexAttribI4sv(GLuint index, const GLshort *v);
-    void glVertexAttribI4bv(GLuint index, const GLbyte *v);
-    void glVertexAttribI4uiv(GLuint index, const GLuint *v);
-    void glVertexAttribI3uiv(GLuint index, const GLuint *v);
-    void glVertexAttribI2uiv(GLuint index, const GLuint *v);
-    void glVertexAttribI1uiv(GLuint index, const GLuint *v);
-    void glVertexAttribI4iv(GLuint index, const GLint *v);
-    void glVertexAttribI3iv(GLuint index, const GLint *v);
-    void glVertexAttribI2iv(GLuint index, const GLint *v);
-    void glVertexAttribI1iv(GLuint index, const GLint *v);
-    void glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
-    void glVertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z);
-    void glVertexAttribI2ui(GLuint index, GLuint x, GLuint y);
-    void glVertexAttribI1ui(GLuint index, GLuint x);
-    void glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w);
-    void glVertexAttribI3i(GLuint index, GLint x, GLint y, GLint z);
-    void glVertexAttribI2i(GLuint index, GLint x, GLint y);
-    void glVertexAttribI1i(GLuint index, GLint x);
-
-    // OpenGL 3.1 deprecated functions
-
-    // OpenGL 3.2 deprecated functions
-
-    // OpenGL 3.3 deprecated functions
-
-    // OpenGL 4.0 deprecated functions
-
-    // OpenGL 4.1 deprecated functions
-
-private:
-    friend class QOpenGLContext;
-
-    static bool isContextCompatible(QOpenGLContext *context);
-    static QOpenGLVersionProfile versionProfile();
-
-    QOpenGLFunctions_1_0_CoreBackend* d_1_0_Core;
-    QOpenGLFunctions_1_1_CoreBackend* d_1_1_Core;
-    QOpenGLFunctions_1_2_CoreBackend* d_1_2_Core;
-    QOpenGLFunctions_1_3_CoreBackend* d_1_3_Core;
-    QOpenGLFunctions_1_4_CoreBackend* d_1_4_Core;
-    QOpenGLFunctions_1_5_CoreBackend* d_1_5_Core;
-    QOpenGLFunctions_2_0_CoreBackend* d_2_0_Core;
-    QOpenGLFunctions_2_1_CoreBackend* d_2_1_Core;
-    QOpenGLFunctions_3_0_CoreBackend* d_3_0_Core;
-    QOpenGLFunctions_3_1_CoreBackend* d_3_1_Core;
-    QOpenGLFunctions_3_2_CoreBackend* d_3_2_Core;
-    QOpenGLFunctions_3_3_CoreBackend* d_3_3_Core;
-    QOpenGLFunctions_4_0_CoreBackend* d_4_0_Core;
-    QOpenGLFunctions_4_1_CoreBackend* d_4_1_Core;
-    QOpenGLFunctions_1_0_DeprecatedBackend* d_1_0_Deprecated;
-    QOpenGLFunctions_1_1_DeprecatedBackend* d_1_1_Deprecated;
-    QOpenGLFunctions_1_2_DeprecatedBackend* d_1_2_Deprecated;
-    QOpenGLFunctions_1_3_DeprecatedBackend* d_1_3_Deprecated;
-    QOpenGLFunctions_1_4_DeprecatedBackend* d_1_4_Deprecated;
-    void *m_reserved_2_0_Deprecated; // To maintain BC
-    QOpenGLFunctions_3_3_DeprecatedBackend* d_3_3_Deprecated;
-};
-
-// OpenGL 1.0 core functions
-inline void QOpenGLFunctions_4_1_Compatibility::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_0_Core->f.Viewport(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glDepthRange(GLdouble nearVal, GLdouble farVal)
-{
-    d_1_0_Core->f.DepthRange(nearVal, farVal);
-}
-
-inline GLboolean QOpenGLFunctions_4_1_Compatibility::glIsEnabled(GLenum cap)
-{
-    return d_1_0_Core->f.IsEnabled(cap);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetTexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetTexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
-{
-    d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
-}
-
-inline const GLubyte * QOpenGLFunctions_4_1_Compatibility::glGetString(GLenum name)
-{
-    return d_1_0_Core->f.GetString(name);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetIntegerv(GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetIntegerv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetFloatv(GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetFloatv(pname, params);
-}
-
-inline GLenum QOpenGLFunctions_4_1_Compatibility::glGetError()
-{
-    return d_1_0_Core->f.GetError();
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetDoublev(GLenum pname, GLdouble *params)
-{
-    d_1_0_Core->f.GetDoublev(pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetBooleanv(GLenum pname, GLboolean *params)
-{
-    d_1_0_Core->f.GetBooleanv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
-{
-    d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glReadBuffer(GLenum mode)
-{
-    d_1_0_Core->f.ReadBuffer(mode);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glPixelStorei(GLenum pname, GLint param)
-{
-    d_1_0_Core->f.PixelStorei(pname, param);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glPixelStoref(GLenum pname, GLfloat param)
-{
-    d_1_0_Core->f.PixelStoref(pname, param);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glDepthFunc(GLenum func)
-{
-    d_1_0_Core->f.DepthFunc(func);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
-{
-    d_1_0_Core->f.StencilOp(fail, zfail, zpass);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glStencilFunc(GLenum func, GLint ref, GLuint mask)
-{
-    d_1_0_Core->f.StencilFunc(func, ref, mask);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glLogicOp(GLenum opcode)
-{
-    d_1_0_Core->f.LogicOp(opcode);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glBlendFunc(GLenum sfactor, GLenum dfactor)
-{
-    d_1_0_Core->f.BlendFunc(sfactor, dfactor);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glFlush()
-{
-    d_1_0_Core->f.Flush();
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glFinish()
-{
-    d_1_0_Core->f.Finish();
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glEnable(GLenum cap)
-{
-    d_1_0_Core->f.Enable(cap);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glDisable(GLenum cap)
-{
-    d_1_0_Core->f.Disable(cap);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glDepthMask(GLboolean flag)
-{
-    d_1_0_Core->f.DepthMask(flag);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
-{
-    d_1_0_Core->f.ColorMask(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glStencilMask(GLuint mask)
-{
-    d_1_0_Core->f.StencilMask(mask);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glClearDepth(GLdouble depth)
-{
-    d_1_0_Core->f.ClearDepth(depth);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glClearStencil(GLint s)
-{
-    d_1_0_Core->f.ClearStencil(s);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Core->f.ClearColor(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glClear(GLbitfield mask)
-{
-    d_1_0_Core->f.Clear(mask);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glDrawBuffer(GLenum mode)
-{
-    d_1_0_Core->f.DrawBuffer(mode);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Core->f.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Core->f.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_0_Core->f.TexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexParameteri(GLenum target, GLenum pname, GLint param)
-{
-    d_1_0_Core->f.TexParameteri(target, pname, param);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Core->f.TexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
-{
-    d_1_0_Core->f.TexParameterf(target, pname, param);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_0_Core->f.Scissor(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glPolygonMode(GLenum face, GLenum mode)
-{
-    d_1_0_Core->f.PolygonMode(face, mode);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glPointSize(GLfloat size)
-{
-    d_1_0_Core->f.PointSize(size);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glLineWidth(GLfloat width)
-{
-    d_1_0_Core->f.LineWidth(width);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glHint(GLenum target, GLenum mode)
-{
-    d_1_0_Core->f.Hint(target, mode);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glFrontFace(GLenum mode)
-{
-    d_1_0_Core->f.FrontFace(mode);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glCullFace(GLenum mode)
-{
-    d_1_0_Core->f.CullFace(mode);
-}
-
-
-// OpenGL 1.1 core functions
-inline void QOpenGLFunctions_4_1_Compatibility::glIndexubv(const GLubyte *c)
-{
-    d_1_1_Deprecated->f.Indexubv(c);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glIndexub(GLubyte c)
-{
-    d_1_1_Deprecated->f.Indexub(c);
-}
-
-inline GLboolean QOpenGLFunctions_4_1_Compatibility::glIsTexture(GLuint texture)
-{
-    return d_1_1_Core->f.IsTexture(texture);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGenTextures(GLsizei n, GLuint *textures)
-{
-    d_1_1_Core->f.GenTextures(n, textures);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glDeleteTextures(GLsizei n, const GLuint *textures)
-{
-    d_1_1_Core->f.DeleteTextures(n, textures);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glBindTexture(GLenum target, GLuint texture)
-{
-    d_1_1_Core->f.BindTexture(target, texture);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_1_Core->f.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_1_Core->f.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_1_Core->f.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
-{
-    d_1_1_Core->f.CopyTexSubImage1D(target, level, xoffset, x, y, width);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
-{
-    d_1_1_Core->f.CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
-{
-    d_1_1_Core->f.CopyTexImage1D(target, level, internalformat, x, y, width, border);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glPolygonOffset(GLfloat factor, GLfloat units)
-{
-    d_1_1_Core->f.PolygonOffset(factor, units);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetPointerv(GLenum pname, GLvoid* *params)
-{
-    d_1_1_Deprecated->f.GetPointerv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
-{
-    d_1_1_Core->f.DrawElements(mode, count, type, indices);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glDrawArrays(GLenum mode, GLint first, GLsizei count)
-{
-    d_1_1_Core->f.DrawArrays(mode, first, count);
-}
-
-
-// OpenGL 1.2 core functions
-inline void QOpenGLFunctions_4_1_Compatibility::glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_2_Core->f.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_2_Core->f.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_2_Core->f.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
-{
-    d_1_2_Core->f.DrawRangeElements(mode, start, end, count, type, indices);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glBlendEquation(GLenum mode)
-{
-    d_1_2_Core->f.BlendEquation(mode);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_2_Core->f.BlendColor(red, green, blue, alpha);
-}
-
-
-// OpenGL 1.3 core functions
-inline void QOpenGLFunctions_4_1_Compatibility::glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img)
-{
-    d_1_3_Core->f.GetCompressedTexImage(target, level, img);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glSampleCoverage(GLfloat value, GLboolean invert)
-{
-    d_1_3_Core->f.SampleCoverage(value, invert);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glActiveTexture(GLenum texture)
-{
-    d_1_3_Core->f.ActiveTexture(texture);
-}
-
-
-// OpenGL 1.4 core functions
-inline void QOpenGLFunctions_4_1_Compatibility::glPointParameteriv(GLenum pname, const GLint *params)
-{
-    d_1_4_Core->f.PointParameteriv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glPointParameteri(GLenum pname, GLint param)
-{
-    d_1_4_Core->f.PointParameteri(pname, param);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glPointParameterfv(GLenum pname, const GLfloat *params)
-{
-    d_1_4_Core->f.PointParameterfv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glPointParameterf(GLenum pname, GLfloat param)
-{
-    d_1_4_Core->f.PointParameterf(pname, param);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount)
-{
-    d_1_4_Core->f.MultiDrawElements(mode, count, type, indices, drawcount);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
-{
-    d_1_4_Core->f.MultiDrawArrays(mode, first, count, drawcount);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
-{
-    d_1_4_Core->f.BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
-}
-
-
-// OpenGL 1.5 core functions
-inline void QOpenGLFunctions_4_1_Compatibility::glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params)
-{
-    d_1_5_Core->f.GetBufferPointerv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetBufferParameteriv(target, pname, params);
-}
-
-inline GLboolean QOpenGLFunctions_4_1_Compatibility::glUnmapBuffer(GLenum target)
-{
-    return d_1_5_Core->f.UnmapBuffer(target);
-}
-
-inline GLvoid* QOpenGLFunctions_4_1_Compatibility::glMapBuffer(GLenum target, GLenum access)
-{
-    return d_1_5_Core->f.MapBuffer(target, access);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data)
-{
-    d_1_5_Core->f.GetBufferSubData(target, offset, size, data);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data)
-{
-    d_1_5_Core->f.BufferSubData(target, offset, size, data);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)
-{
-    d_1_5_Core->f.BufferData(target, size, data, usage);
-}
-
-inline GLboolean QOpenGLFunctions_4_1_Compatibility::glIsBuffer(GLuint buffer)
-{
-    return d_1_5_Core->f.IsBuffer(buffer);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGenBuffers(GLsizei n, GLuint *buffers)
-{
-    d_1_5_Core->f.GenBuffers(n, buffers);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glDeleteBuffers(GLsizei n, const GLuint *buffers)
-{
-    d_1_5_Core->f.DeleteBuffers(n, buffers);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glBindBuffer(GLenum target, GLuint buffer)
-{
-    d_1_5_Core->f.BindBuffer(target, buffer);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
-{
-    d_1_5_Core->f.GetQueryObjectuiv(id, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetQueryObjectiv(id, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetQueryiv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetQueryiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glEndQuery(GLenum target)
-{
-    d_1_5_Core->f.EndQuery(target);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glBeginQuery(GLenum target, GLuint id)
-{
-    d_1_5_Core->f.BeginQuery(target, id);
-}
-
-inline GLboolean QOpenGLFunctions_4_1_Compatibility::glIsQuery(GLuint id)
-{
-    return d_1_5_Core->f.IsQuery(id);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glDeleteQueries(GLsizei n, const GLuint *ids)
-{
-    d_1_5_Core->f.DeleteQueries(n, ids);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGenQueries(GLsizei n, GLuint *ids)
-{
-    d_1_5_Core->f.GenQueries(n, ids);
-}
-
-
-// OpenGL 2.0 core functions
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer)
-{
-    d_2_0_Core->f.VertexAttribPointer(index, size, type, normalized, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glValidateProgram(GLuint program)
-{
-    d_2_0_Core->f.ValidateProgram(program);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix3fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUniform4iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform4iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUniform3iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform3iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUniform2iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform2iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUniform1iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform1iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUniform4fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform4fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUniform3fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform3fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUniform2fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform2fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUniform1fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform1fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
-{
-    d_2_0_Core->f.Uniform4i(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUniform3i(GLint location, GLint v0, GLint v1, GLint v2)
-{
-    d_2_0_Core->f.Uniform3i(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUniform2i(GLint location, GLint v0, GLint v1)
-{
-    d_2_0_Core->f.Uniform2i(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUniform1i(GLint location, GLint v0)
-{
-    d_2_0_Core->f.Uniform1i(location, v0);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
-{
-    d_2_0_Core->f.Uniform4f(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
-{
-    d_2_0_Core->f.Uniform3f(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUniform2f(GLint location, GLfloat v0, GLfloat v1)
-{
-    d_2_0_Core->f.Uniform2f(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUniform1f(GLint location, GLfloat v0)
-{
-    d_2_0_Core->f.Uniform1f(location, v0);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUseProgram(GLuint program)
-{
-    d_2_0_Core->f.UseProgram(program);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length)
-{
-    d_2_0_Core->f.ShaderSource(shader, count, string, length);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glLinkProgram(GLuint program)
-{
-    d_2_0_Core->f.LinkProgram(program);
-}
-
-inline GLboolean QOpenGLFunctions_4_1_Compatibility::glIsShader(GLuint shader)
-{
-    return d_2_0_Core->f.IsShader(shader);
-}
-
-inline GLboolean QOpenGLFunctions_4_1_Compatibility::glIsProgram(GLuint program)
-{
-    return d_2_0_Core->f.IsProgram(program);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer)
-{
-    d_2_0_Core->f.GetVertexAttribPointerv(index, pname, pointer);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetVertexAttribiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
-{
-    d_2_0_Core->f.GetVertexAttribfv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
-{
-    d_2_0_Core->f.GetVertexAttribdv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetUniformiv(GLuint program, GLint location, GLint *params)
-{
-    d_2_0_Core->f.GetUniformiv(program, location, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetUniformfv(GLuint program, GLint location, GLfloat *params)
-{
-    d_2_0_Core->f.GetUniformfv(program, location, params);
-}
-
-inline GLint QOpenGLFunctions_4_1_Compatibility::glGetUniformLocation(GLuint program, const GLchar *name)
-{
-    return d_2_0_Core->f.GetUniformLocation(program, name);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
-{
-    d_2_0_Core->f.GetShaderSource(shader, bufSize, length, source);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-{
-    d_2_0_Core->f.GetShaderInfoLog(shader, bufSize, length, infoLog);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetShaderiv(GLuint shader, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetShaderiv(shader, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-{
-    d_2_0_Core->f.GetProgramInfoLog(program, bufSize, length, infoLog);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetProgramiv(GLuint program, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetProgramiv(program, pname, params);
-}
-
-inline GLint QOpenGLFunctions_4_1_Compatibility::glGetAttribLocation(GLuint program, const GLchar *name)
-{
-    return d_2_0_Core->f.GetAttribLocation(program, name);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj)
-{
-    d_2_0_Core->f.GetAttachedShaders(program, maxCount, count, obj);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
-{
-    d_2_0_Core->f.GetActiveUniform(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
-{
-    d_2_0_Core->f.GetActiveAttrib(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glEnableVertexAttribArray(GLuint index)
-{
-    d_2_0_Core->f.EnableVertexAttribArray(index);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glDisableVertexAttribArray(GLuint index)
-{
-    d_2_0_Core->f.DisableVertexAttribArray(index);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glDetachShader(GLuint program, GLuint shader)
-{
-    d_2_0_Core->f.DetachShader(program, shader);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glDeleteShader(GLuint shader)
-{
-    d_2_0_Core->f.DeleteShader(shader);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glDeleteProgram(GLuint program)
-{
-    d_2_0_Core->f.DeleteProgram(program);
-}
-
-inline GLuint QOpenGLFunctions_4_1_Compatibility::glCreateShader(GLenum type)
-{
-    return d_2_0_Core->f.CreateShader(type);
-}
-
-inline GLuint QOpenGLFunctions_4_1_Compatibility::glCreateProgram()
-{
-    return d_2_0_Core->f.CreateProgram();
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glCompileShader(GLuint shader)
-{
-    d_2_0_Core->f.CompileShader(shader);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glBindAttribLocation(GLuint program, GLuint index, const GLchar *name)
-{
-    d_2_0_Core->f.BindAttribLocation(program, index, name);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glAttachShader(GLuint program, GLuint shader)
-{
-    d_2_0_Core->f.AttachShader(program, shader);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glStencilMaskSeparate(GLenum face, GLuint mask)
-{
-    d_2_0_Core->f.StencilMaskSeparate(face, mask);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
-{
-    d_2_0_Core->f.StencilFuncSeparate(face, func, ref, mask);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
-{
-    d_2_0_Core->f.StencilOpSeparate(face, sfail, dpfail, dppass);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glDrawBuffers(GLsizei n, const GLenum *bufs)
-{
-    d_2_0_Core->f.DrawBuffers(n, bufs);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
-{
-    d_2_0_Core->f.BlendEquationSeparate(modeRGB, modeAlpha);
-}
-
-
-// OpenGL 2.1 core functions
-inline void QOpenGLFunctions_4_1_Compatibility::glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix4x3fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix3x4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix4x2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix2x4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix3x2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix2x3fv(location, count, transpose, value);
-}
-
-
-// OpenGL 3.0 core functions
-inline GLboolean QOpenGLFunctions_4_1_Compatibility::glIsVertexArray(GLuint array)
-{
-    return d_3_0_Core->f.IsVertexArray(array);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGenVertexArrays(GLsizei n, GLuint *arrays)
-{
-    d_3_0_Core->f.GenVertexArrays(n, arrays);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glDeleteVertexArrays(GLsizei n, const GLuint *arrays)
-{
-    d_3_0_Core->f.DeleteVertexArrays(n, arrays);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glBindVertexArray(GLuint array)
-{
-    d_3_0_Core->f.BindVertexArray(array);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
-{
-    d_3_0_Core->f.FlushMappedBufferRange(target, offset, length);
-}
-
-inline GLvoid* QOpenGLFunctions_4_1_Compatibility::glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
-{
-    return d_3_0_Core->f.MapBufferRange(target, offset, length, access);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
-{
-    d_3_0_Core->f.FramebufferTextureLayer(target, attachment, texture, level, layer);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    d_3_0_Core->f.RenderbufferStorageMultisample(target, samples, internalformat, width, height);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
-{
-    d_3_0_Core->f.BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGenerateMipmap(GLenum target)
-{
-    d_3_0_Core->f.GenerateMipmap(target);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
-{
-    d_3_0_Core->f.FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
-{
-    d_3_0_Core->f.FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
-{
-    d_3_0_Core->f.FramebufferTexture2D(target, attachment, textarget, texture, level);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
-{
-    d_3_0_Core->f.FramebufferTexture1D(target, attachment, textarget, texture, level);
-}
-
-inline GLenum QOpenGLFunctions_4_1_Compatibility::glCheckFramebufferStatus(GLenum target)
-{
-    return d_3_0_Core->f.CheckFramebufferStatus(target);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGenFramebuffers(GLsizei n, GLuint *framebuffers)
-{
-    d_3_0_Core->f.GenFramebuffers(n, framebuffers);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
-{
-    d_3_0_Core->f.DeleteFramebuffers(n, framebuffers);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glBindFramebuffer(GLenum target, GLuint framebuffer)
-{
-    d_3_0_Core->f.BindFramebuffer(target, framebuffer);
-}
-
-inline GLboolean QOpenGLFunctions_4_1_Compatibility::glIsFramebuffer(GLuint framebuffer)
-{
-    return d_3_0_Core->f.IsFramebuffer(framebuffer);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetRenderbufferParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    d_3_0_Core->f.RenderbufferStorage(target, internalformat, width, height);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGenRenderbuffers(GLsizei n, GLuint *renderbuffers)
-{
-    d_3_0_Core->f.GenRenderbuffers(n, renderbuffers);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
-{
-    d_3_0_Core->f.DeleteRenderbuffers(n, renderbuffers);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glBindRenderbuffer(GLenum target, GLuint renderbuffer)
-{
-    d_3_0_Core->f.BindRenderbuffer(target, renderbuffer);
-}
-
-inline GLboolean QOpenGLFunctions_4_1_Compatibility::glIsRenderbuffer(GLuint renderbuffer)
-{
-    return d_3_0_Core->f.IsRenderbuffer(renderbuffer);
-}
-
-inline const GLubyte * QOpenGLFunctions_4_1_Compatibility::glGetStringi(GLenum name, GLuint index)
-{
-    return d_3_0_Core->f.GetStringi(name, index);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
-{
-    d_3_0_Core->f.ClearBufferfi(buffer, drawbuffer, depth, stencil);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
-{
-    d_3_0_Core->f.ClearBufferfv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
-{
-    d_3_0_Core->f.ClearBufferuiv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
-{
-    d_3_0_Core->f.ClearBufferiv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params)
-{
-    d_3_0_Core->f.GetTexParameterIuiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetTexParameterIiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params)
-{
-    d_3_0_Core->f.TexParameterIuiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexParameterIiv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_3_0_Core->f.TexParameterIiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUniform4uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform4uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUniform3uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform3uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUniform2uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform2uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUniform1uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform1uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
-{
-    d_3_0_Core->f.Uniform4ui(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
-{
-    d_3_0_Core->f.Uniform3ui(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUniform2ui(GLint location, GLuint v0, GLuint v1)
-{
-    d_3_0_Core->f.Uniform2ui(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUniform1ui(GLint location, GLuint v0)
-{
-    d_3_0_Core->f.Uniform1ui(location, v0);
-}
-
-inline GLint QOpenGLFunctions_4_1_Compatibility::glGetFragDataLocation(GLuint program, const GLchar *name)
-{
-    return d_3_0_Core->f.GetFragDataLocation(program, name);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name)
-{
-    d_3_0_Core->f.BindFragDataLocation(program, color, name);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetUniformuiv(GLuint program, GLint location, GLuint *params)
-{
-    d_3_0_Core->f.GetUniformuiv(program, location, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
-{
-    d_3_0_Core->f.GetVertexAttribIuiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetVertexAttribIiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_3_0_Core->f.VertexAttribIPointer(index, size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glEndConditionalRender()
-{
-    d_3_0_Core->f.EndConditionalRender();
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glBeginConditionalRender(GLuint id, GLenum mode)
-{
-    d_3_0_Core->f.BeginConditionalRender(id, mode);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glClampColor(GLenum target, GLenum clamp)
-{
-    d_3_0_Core->f.ClampColor(target, clamp);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
-{
-    d_3_0_Core->f.GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode)
-{
-    d_3_0_Core->f.TransformFeedbackVaryings(program, count, varyings, bufferMode);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
-{
-    d_3_0_Core->f.BindBufferBase(target, index, buffer);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
-{
-    d_3_0_Core->f.BindBufferRange(target, index, buffer, offset, size);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glEndTransformFeedback()
-{
-    d_3_0_Core->f.EndTransformFeedback();
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glBeginTransformFeedback(GLenum primitiveMode)
-{
-    d_3_0_Core->f.BeginTransformFeedback(primitiveMode);
-}
-
-inline GLboolean QOpenGLFunctions_4_1_Compatibility::glIsEnabledi(GLenum target, GLuint index)
-{
-    return d_3_0_Core->f.IsEnabledi(target, index);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glDisablei(GLenum target, GLuint index)
-{
-    d_3_0_Core->f.Disablei(target, index);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glEnablei(GLenum target, GLuint index)
-{
-    d_3_0_Core->f.Enablei(target, index);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetIntegeri_v(GLenum target, GLuint index, GLint *data)
-{
-    d_3_0_Core->f.GetIntegeri_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetBooleani_v(GLenum target, GLuint index, GLboolean *data)
-{
-    d_3_0_Core->f.GetBooleani_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
-{
-    d_3_0_Core->f.ColorMaski(index, r, g, b, a);
-}
-
-
-// OpenGL 3.1 core functions
-inline void QOpenGLFunctions_4_1_Compatibility::glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
-{
-    d_3_1_Core->f.CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
-{
-    d_3_1_Core->f.UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
-{
-    d_3_1_Core->f.GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params)
-{
-    d_3_1_Core->f.GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
-}
-
-inline GLuint QOpenGLFunctions_4_1_Compatibility::glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName)
-{
-    return d_3_1_Core->f.GetUniformBlockIndex(program, uniformBlockName);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName)
-{
-    d_3_1_Core->f.GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params)
-{
-    d_3_1_Core->f.GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const *uniformNames, GLuint *uniformIndices)
-{
-    d_3_1_Core->f.GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glPrimitiveRestartIndex(GLuint index)
-{
-    d_3_1_Core->f.PrimitiveRestartIndex(index);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer)
-{
-    d_3_1_Core->f.TexBuffer(target, internalformat, buffer);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount)
-{
-    d_3_1_Core->f.DrawElementsInstanced(mode, count, type, indices, instancecount);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount)
-{
-    d_3_1_Core->f.DrawArraysInstanced(mode, first, count, instancecount);
-}
-
-
-// OpenGL 3.2 core functions
-inline void QOpenGLFunctions_4_1_Compatibility::glSampleMaski(GLuint index, GLbitfield mask)
-{
-    d_3_2_Core->f.SampleMaski(index, mask);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val)
-{
-    d_3_2_Core->f.GetMultisamplefv(pname, index, val);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexImage3DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
-{
-    d_3_2_Core->f.TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexImage2DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
-{
-    d_3_2_Core->f.TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values)
-{
-    d_3_2_Core->f.GetSynciv(sync, pname, bufSize, length, values);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetInteger64v(GLenum pname, GLint64 *params)
-{
-    d_3_2_Core->f.GetInteger64v(pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
-{
-    d_3_2_Core->f.WaitSync(sync, flags, timeout);
-}
-
-inline GLenum QOpenGLFunctions_4_1_Compatibility::glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
-{
-    return d_3_2_Core->f.ClientWaitSync(sync, flags, timeout);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glDeleteSync(GLsync sync)
-{
-    d_3_2_Core->f.DeleteSync(sync);
-}
-
-inline GLboolean QOpenGLFunctions_4_1_Compatibility::glIsSync(GLsync sync)
-{
-    return d_3_2_Core->f.IsSync(sync);
-}
-
-inline GLsync QOpenGLFunctions_4_1_Compatibility::glFenceSync(GLenum condition, GLbitfield flags)
-{
-    return d_3_2_Core->f.FenceSync(condition, flags);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProvokingVertex(GLenum mode)
-{
-    d_3_2_Core->f.ProvokingVertex(mode);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount, const GLint *basevertex)
-{
-    d_3_2_Core->f.MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount, GLint basevertex)
-{
-    d_3_2_Core->f.DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)
-{
-    d_3_2_Core->f.DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)
-{
-    d_3_2_Core->f.DrawElementsBaseVertex(mode, count, type, indices, basevertex);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level)
-{
-    d_3_2_Core->f.FramebufferTexture(target, attachment, texture, level);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params)
-{
-    d_3_2_Core->f.GetBufferParameteri64v(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data)
-{
-    d_3_2_Core->f.GetInteger64i_v(target, index, data);
-}
-
-
-// OpenGL 3.3 core functions
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribP4uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP4uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP4ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribP3uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP3uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP3ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribP2uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP2uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP2ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribP1uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP1uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP1ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glSecondaryColorP3uiv(GLenum type, const GLuint *color)
-{
-    d_3_3_Deprecated->f.SecondaryColorP3uiv(type, color);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glSecondaryColorP3ui(GLenum type, GLuint color)
-{
-    d_3_3_Deprecated->f.SecondaryColorP3ui(type, color);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glColorP4uiv(GLenum type, const GLuint *color)
-{
-    d_3_3_Deprecated->f.ColorP4uiv(type, color);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glColorP4ui(GLenum type, GLuint color)
-{
-    d_3_3_Deprecated->f.ColorP4ui(type, color);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glColorP3uiv(GLenum type, const GLuint *color)
-{
-    d_3_3_Deprecated->f.ColorP3uiv(type, color);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glColorP3ui(GLenum type, GLuint color)
-{
-    d_3_3_Deprecated->f.ColorP3ui(type, color);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glNormalP3uiv(GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.NormalP3uiv(type, coords);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glNormalP3ui(GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.NormalP3ui(type, coords);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP4uiv(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP4ui(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP3uiv(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP3ui(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP2uiv(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP2ui(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP1uiv(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP1ui(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexCoordP4uiv(GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.TexCoordP4uiv(type, coords);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexCoordP4ui(GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.TexCoordP4ui(type, coords);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexCoordP3uiv(GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.TexCoordP3uiv(type, coords);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexCoordP3ui(GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.TexCoordP3ui(type, coords);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexCoordP2uiv(GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.TexCoordP2uiv(type, coords);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexCoordP2ui(GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.TexCoordP2ui(type, coords);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexCoordP1uiv(GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.TexCoordP1uiv(type, coords);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexCoordP1ui(GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.TexCoordP1ui(type, coords);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexP4uiv(GLenum type, const GLuint *value)
-{
-    d_3_3_Deprecated->f.VertexP4uiv(type, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexP4ui(GLenum type, GLuint value)
-{
-    d_3_3_Deprecated->f.VertexP4ui(type, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexP3uiv(GLenum type, const GLuint *value)
-{
-    d_3_3_Deprecated->f.VertexP3uiv(type, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexP3ui(GLenum type, GLuint value)
-{
-    d_3_3_Deprecated->f.VertexP3ui(type, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexP2uiv(GLenum type, const GLuint *value)
-{
-    d_3_3_Deprecated->f.VertexP2uiv(type, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexP2ui(GLenum type, GLuint value)
-{
-    d_3_3_Deprecated->f.VertexP2ui(type, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params)
-{
-    d_3_3_Core->f.GetQueryObjectui64v(id, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params)
-{
-    d_3_3_Core->f.GetQueryObjecti64v(id, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glQueryCounter(GLuint id, GLenum target)
-{
-    d_3_3_Core->f.QueryCounter(id, target);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params)
-{
-    d_3_3_Core->f.GetSamplerParameterIuiv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params)
-{
-    d_3_3_Core->f.GetSamplerParameterfv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params)
-{
-    d_3_3_Core->f.GetSamplerParameterIiv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params)
-{
-    d_3_3_Core->f.GetSamplerParameteriv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param)
-{
-    d_3_3_Core->f.SamplerParameterIuiv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param)
-{
-    d_3_3_Core->f.SamplerParameterIiv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param)
-{
-    d_3_3_Core->f.SamplerParameterfv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
-{
-    d_3_3_Core->f.SamplerParameterf(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param)
-{
-    d_3_3_Core->f.SamplerParameteriv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glSamplerParameteri(GLuint sampler, GLenum pname, GLint param)
-{
-    d_3_3_Core->f.SamplerParameteri(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glBindSampler(GLuint unit, GLuint sampler)
-{
-    d_3_3_Core->f.BindSampler(unit, sampler);
-}
-
-inline GLboolean QOpenGLFunctions_4_1_Compatibility::glIsSampler(GLuint sampler)
-{
-    return d_3_3_Core->f.IsSampler(sampler);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glDeleteSamplers(GLsizei count, const GLuint *samplers)
-{
-    d_3_3_Core->f.DeleteSamplers(count, samplers);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGenSamplers(GLsizei count, GLuint *samplers)
-{
-    d_3_3_Core->f.GenSamplers(count, samplers);
-}
-
-inline GLint QOpenGLFunctions_4_1_Compatibility::glGetFragDataIndex(GLuint program, const GLchar *name)
-{
-    return d_3_3_Core->f.GetFragDataIndex(program, name);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glBindFragDataLocationIndexed(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name)
-{
-    d_3_3_Core->f.BindFragDataLocationIndexed(program, colorNumber, index, name);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribDivisor(GLuint index, GLuint divisor)
-{
-    d_3_3_Core->f.VertexAttribDivisor(index, divisor);
-}
-
-
-// OpenGL 4.0 core functions
-inline void QOpenGLFunctions_4_1_Compatibility::glGetQueryIndexediv(GLenum target, GLuint index, GLenum pname, GLint *params)
-{
-    d_4_0_Core->f.GetQueryIndexediv(target, index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glEndQueryIndexed(GLenum target, GLuint index)
-{
-    d_4_0_Core->f.EndQueryIndexed(target, index);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glBeginQueryIndexed(GLenum target, GLuint index, GLuint id)
-{
-    d_4_0_Core->f.BeginQueryIndexed(target, index, id);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glDrawTransformFeedbackStream(GLenum mode, GLuint id, GLuint stream)
-{
-    d_4_0_Core->f.DrawTransformFeedbackStream(mode, id, stream);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glDrawTransformFeedback(GLenum mode, GLuint id)
-{
-    d_4_0_Core->f.DrawTransformFeedback(mode, id);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glResumeTransformFeedback()
-{
-    d_4_0_Core->f.ResumeTransformFeedback();
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glPauseTransformFeedback()
-{
-    d_4_0_Core->f.PauseTransformFeedback();
-}
-
-inline GLboolean QOpenGLFunctions_4_1_Compatibility::glIsTransformFeedback(GLuint id)
-{
-    return d_4_0_Core->f.IsTransformFeedback(id);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGenTransformFeedbacks(GLsizei n, GLuint *ids)
-{
-    d_4_0_Core->f.GenTransformFeedbacks(n, ids);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids)
-{
-    d_4_0_Core->f.DeleteTransformFeedbacks(n, ids);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glBindTransformFeedback(GLenum target, GLuint id)
-{
-    d_4_0_Core->f.BindTransformFeedback(target, id);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glPatchParameterfv(GLenum pname, const GLfloat *values)
-{
-    d_4_0_Core->f.PatchParameterfv(pname, values);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glPatchParameteri(GLenum pname, GLint value)
-{
-    d_4_0_Core->f.PatchParameteri(pname, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetProgramStageiv(GLuint program, GLenum shadertype, GLenum pname, GLint *values)
-{
-    d_4_0_Core->f.GetProgramStageiv(program, shadertype, pname, values);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetUniformSubroutineuiv(GLenum shadertype, GLint location, GLuint *params)
-{
-    d_4_0_Core->f.GetUniformSubroutineuiv(shadertype, location, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUniformSubroutinesuiv(GLenum shadertype, GLsizei count, const GLuint *indices)
-{
-    d_4_0_Core->f.UniformSubroutinesuiv(shadertype, count, indices);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetActiveSubroutineName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
-{
-    d_4_0_Core->f.GetActiveSubroutineName(program, shadertype, index, bufsize, length, name);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetActiveSubroutineUniformName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
-{
-    d_4_0_Core->f.GetActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetActiveSubroutineUniformiv(GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values)
-{
-    d_4_0_Core->f.GetActiveSubroutineUniformiv(program, shadertype, index, pname, values);
-}
-
-inline GLuint QOpenGLFunctions_4_1_Compatibility::glGetSubroutineIndex(GLuint program, GLenum shadertype, const GLchar *name)
-{
-    return d_4_0_Core->f.GetSubroutineIndex(program, shadertype, name);
-}
-
-inline GLint QOpenGLFunctions_4_1_Compatibility::glGetSubroutineUniformLocation(GLuint program, GLenum shadertype, const GLchar *name)
-{
-    return d_4_0_Core->f.GetSubroutineUniformLocation(program, shadertype, name);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetUniformdv(GLuint program, GLint location, GLdouble *params)
-{
-    d_4_0_Core->f.GetUniformdv(program, location, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUniformMatrix4x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix4x3dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUniformMatrix4x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix4x2dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUniformMatrix3x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix3x4dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUniformMatrix3x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix3x2dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUniformMatrix2x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix2x4dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUniformMatrix2x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix2x3dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix4dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUniformMatrix3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix3dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUniformMatrix2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix2dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUniform4dv(GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_0_Core->f.Uniform4dv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUniform3dv(GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_0_Core->f.Uniform3dv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUniform2dv(GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_0_Core->f.Uniform2dv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUniform1dv(GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_0_Core->f.Uniform1dv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUniform4d(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_4_0_Core->f.Uniform4d(location, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUniform3d(GLint location, GLdouble x, GLdouble y, GLdouble z)
-{
-    d_4_0_Core->f.Uniform3d(location, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUniform2d(GLint location, GLdouble x, GLdouble y)
-{
-    d_4_0_Core->f.Uniform2d(location, x, y);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUniform1d(GLint location, GLdouble x)
-{
-    d_4_0_Core->f.Uniform1d(location, x);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glDrawElementsIndirect(GLenum mode, GLenum type, const GLvoid *indirect)
-{
-    d_4_0_Core->f.DrawElementsIndirect(mode, type, indirect);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glDrawArraysIndirect(GLenum mode, const GLvoid *indirect)
-{
-    d_4_0_Core->f.DrawArraysIndirect(mode, indirect);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glBlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
-{
-    d_4_0_Core->f.BlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glBlendFunci(GLuint buf, GLenum src, GLenum dst)
-{
-    d_4_0_Core->f.BlendFunci(buf, src, dst);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glBlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha)
-{
-    d_4_0_Core->f.BlendEquationSeparatei(buf, modeRGB, modeAlpha);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glBlendEquationi(GLuint buf, GLenum mode)
-{
-    d_4_0_Core->f.BlendEquationi(buf, mode);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMinSampleShading(GLfloat value)
-{
-    d_4_0_Core->f.MinSampleShading(value);
-}
-
-
-// OpenGL 4.1 core functions
-inline void QOpenGLFunctions_4_1_Compatibility::glGetDoublei_v(GLenum target, GLuint index, GLdouble *data)
-{
-    d_4_1_Core->f.GetDoublei_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetFloati_v(GLenum target, GLuint index, GLfloat *data)
-{
-    d_4_1_Core->f.GetFloati_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glDepthRangeIndexed(GLuint index, GLdouble n, GLdouble f)
-{
-    d_4_1_Core->f.DepthRangeIndexed(index, n, f);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glDepthRangeArrayv(GLuint first, GLsizei count, const GLdouble *v)
-{
-    d_4_1_Core->f.DepthRangeArrayv(first, count, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glScissorIndexedv(GLuint index, const GLint *v)
-{
-    d_4_1_Core->f.ScissorIndexedv(index, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glScissorIndexed(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height)
-{
-    d_4_1_Core->f.ScissorIndexed(index, left, bottom, width, height);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glScissorArrayv(GLuint first, GLsizei count, const GLint *v)
-{
-    d_4_1_Core->f.ScissorArrayv(first, count, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glViewportIndexedfv(GLuint index, const GLfloat *v)
-{
-    d_4_1_Core->f.ViewportIndexedfv(index, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glViewportIndexedf(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h)
-{
-    d_4_1_Core->f.ViewportIndexedf(index, x, y, w, h);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glViewportArrayv(GLuint first, GLsizei count, const GLfloat *v)
-{
-    d_4_1_Core->f.ViewportArrayv(first, count, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetVertexAttribLdv(GLuint index, GLenum pname, GLdouble *params)
-{
-    d_4_1_Core->f.GetVertexAttribLdv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribLPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_4_1_Core->f.VertexAttribLPointer(index, size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribL4dv(GLuint index, const GLdouble *v)
-{
-    d_4_1_Core->f.VertexAttribL4dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribL3dv(GLuint index, const GLdouble *v)
-{
-    d_4_1_Core->f.VertexAttribL3dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribL2dv(GLuint index, const GLdouble *v)
-{
-    d_4_1_Core->f.VertexAttribL2dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribL1dv(GLuint index, const GLdouble *v)
-{
-    d_4_1_Core->f.VertexAttribL1dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribL4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_4_1_Core->f.VertexAttribL4d(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribL3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
-{
-    d_4_1_Core->f.VertexAttribL3d(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribL2d(GLuint index, GLdouble x, GLdouble y)
-{
-    d_4_1_Core->f.VertexAttribL2d(index, x, y);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribL1d(GLuint index, GLdouble x)
-{
-    d_4_1_Core->f.VertexAttribL1d(index, x);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-{
-    d_4_1_Core->f.GetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glValidateProgramPipeline(GLuint pipeline)
-{
-    d_4_1_Core->f.ValidateProgramPipeline(pipeline);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniformMatrix4x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4x3dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniformMatrix3x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3x4dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniformMatrix4x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4x2dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniformMatrix2x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2x4dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniformMatrix3x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3x2dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniformMatrix2x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2x3dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniformMatrix4x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4x3fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniformMatrix3x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3x4fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniformMatrix4x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4x2fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniformMatrix2x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2x4fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniformMatrix3x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3x2fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniformMatrix2x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2x3fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniformMatrix4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniformMatrix3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniformMatrix2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniformMatrix4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniformMatrix3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniformMatrix2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform4uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
-{
-    d_4_1_Core->f.ProgramUniform4uiv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
-{
-    d_4_1_Core->f.ProgramUniform4ui(program, location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform4dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniform4dv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform4d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3)
-{
-    d_4_1_Core->f.ProgramUniform4d(program, location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform4fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniform4fv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
-{
-    d_4_1_Core->f.ProgramUniform4f(program, location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform4iv(GLuint program, GLint location, GLsizei count, const GLint *value)
-{
-    d_4_1_Core->f.ProgramUniform4iv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
-{
-    d_4_1_Core->f.ProgramUniform4i(program, location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform3uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
-{
-    d_4_1_Core->f.ProgramUniform3uiv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2)
-{
-    d_4_1_Core->f.ProgramUniform3ui(program, location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform3dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniform3dv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform3d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2)
-{
-    d_4_1_Core->f.ProgramUniform3d(program, location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform3fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniform3fv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
-{
-    d_4_1_Core->f.ProgramUniform3f(program, location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform3iv(GLuint program, GLint location, GLsizei count, const GLint *value)
-{
-    d_4_1_Core->f.ProgramUniform3iv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2)
-{
-    d_4_1_Core->f.ProgramUniform3i(program, location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform2uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
-{
-    d_4_1_Core->f.ProgramUniform2uiv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1)
-{
-    d_4_1_Core->f.ProgramUniform2ui(program, location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform2dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniform2dv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform2d(GLuint program, GLint location, GLdouble v0, GLdouble v1)
-{
-    d_4_1_Core->f.ProgramUniform2d(program, location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform2fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniform2fv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1)
-{
-    d_4_1_Core->f.ProgramUniform2f(program, location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform2iv(GLuint program, GLint location, GLsizei count, const GLint *value)
-{
-    d_4_1_Core->f.ProgramUniform2iv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1)
-{
-    d_4_1_Core->f.ProgramUniform2i(program, location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform1uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
-{
-    d_4_1_Core->f.ProgramUniform1uiv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform1ui(GLuint program, GLint location, GLuint v0)
-{
-    d_4_1_Core->f.ProgramUniform1ui(program, location, v0);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform1dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniform1dv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform1d(GLuint program, GLint location, GLdouble v0)
-{
-    d_4_1_Core->f.ProgramUniform1d(program, location, v0);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform1fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniform1fv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform1f(GLuint program, GLint location, GLfloat v0)
-{
-    d_4_1_Core->f.ProgramUniform1f(program, location, v0);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform1iv(GLuint program, GLint location, GLsizei count, const GLint *value)
-{
-    d_4_1_Core->f.ProgramUniform1iv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform1i(GLuint program, GLint location, GLint v0)
-{
-    d_4_1_Core->f.ProgramUniform1i(program, location, v0);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params)
-{
-    d_4_1_Core->f.GetProgramPipelineiv(pipeline, pname, params);
-}
-
-inline GLboolean QOpenGLFunctions_4_1_Compatibility::glIsProgramPipeline(GLuint pipeline)
-{
-    return d_4_1_Core->f.IsProgramPipeline(pipeline);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGenProgramPipelines(GLsizei n, GLuint *pipelines)
-{
-    d_4_1_Core->f.GenProgramPipelines(n, pipelines);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glDeleteProgramPipelines(GLsizei n, const GLuint *pipelines)
-{
-    d_4_1_Core->f.DeleteProgramPipelines(n, pipelines);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glBindProgramPipeline(GLuint pipeline)
-{
-    d_4_1_Core->f.BindProgramPipeline(pipeline);
-}
-
-inline GLuint QOpenGLFunctions_4_1_Compatibility::glCreateShaderProgramv(GLenum type, GLsizei count, const GLchar* const *strings)
-{
-    return d_4_1_Core->f.CreateShaderProgramv(type, count, strings);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glActiveShaderProgram(GLuint pipeline, GLuint program)
-{
-    d_4_1_Core->f.ActiveShaderProgram(pipeline, program);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program)
-{
-    d_4_1_Core->f.UseProgramStages(pipeline, stages, program);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProgramParameteri(GLuint program, GLenum pname, GLint value)
-{
-    d_4_1_Core->f.ProgramParameteri(program, pname, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid *binary, GLsizei length)
-{
-    d_4_1_Core->f.ProgramBinary(program, binaryFormat, binary, length);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, GLvoid *binary)
-{
-    d_4_1_Core->f.GetProgramBinary(program, bufSize, length, binaryFormat, binary);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glClearDepthf(GLfloat dd)
-{
-    d_4_1_Core->f.ClearDepthf(dd);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glDepthRangef(GLfloat n, GLfloat f)
-{
-    d_4_1_Core->f.DepthRangef(n, f);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision)
-{
-    d_4_1_Core->f.GetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glShaderBinary(GLsizei count, const GLuint *shaders, GLenum binaryformat, const GLvoid *binary, GLsizei length)
-{
-    d_4_1_Core->f.ShaderBinary(count, shaders, binaryformat, binary, length);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glReleaseShaderCompiler()
-{
-    d_4_1_Core->f.ReleaseShaderCompiler();
-}
-
-
-// OpenGL 1.0 deprecated functions
-inline void QOpenGLFunctions_4_1_Compatibility::glTranslatef(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Translatef(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTranslated(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Translated(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glScalef(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Scalef(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glScaled(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Scaled(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Rotatef(angle, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Rotated(angle, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glPushMatrix()
-{
-    d_1_0_Deprecated->f.PushMatrix();
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glPopMatrix()
-{
-    d_1_0_Deprecated->f.PopMatrix();
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
-{
-    d_1_0_Deprecated->f.Ortho(left, right, bottom, top, zNear, zFar);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMultMatrixd(const GLdouble *m)
-{
-    d_1_0_Deprecated->f.MultMatrixd(m);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMultMatrixf(const GLfloat *m)
-{
-    d_1_0_Deprecated->f.MultMatrixf(m);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMatrixMode(GLenum mode)
-{
-    d_1_0_Deprecated->f.MatrixMode(mode);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glLoadMatrixd(const GLdouble *m)
-{
-    d_1_0_Deprecated->f.LoadMatrixd(m);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glLoadMatrixf(const GLfloat *m)
-{
-    d_1_0_Deprecated->f.LoadMatrixf(m);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glLoadIdentity()
-{
-    d_1_0_Deprecated->f.LoadIdentity();
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
-{
-    d_1_0_Deprecated->f.Frustum(left, right, bottom, top, zNear, zFar);
-}
-
-inline GLboolean QOpenGLFunctions_4_1_Compatibility::glIsList(GLuint list)
-{
-    return d_1_0_Deprecated->f.IsList(list);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetTexGeniv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetTexGenfv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
-{
-    d_1_0_Deprecated->f.GetTexGendv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetTexEnviv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetTexEnviv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetTexEnvfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetPolygonStipple(GLubyte *mask)
-{
-    d_1_0_Deprecated->f.GetPolygonStipple(mask);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetPixelMapusv(GLenum map, GLushort *values)
-{
-    d_1_0_Deprecated->f.GetPixelMapusv(map, values);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetPixelMapuiv(GLenum map, GLuint *values)
-{
-    d_1_0_Deprecated->f.GetPixelMapuiv(map, values);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetPixelMapfv(GLenum map, GLfloat *values)
-{
-    d_1_0_Deprecated->f.GetPixelMapfv(map, values);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetMaterialiv(GLenum face, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetMaterialiv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetMaterialfv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetMapiv(GLenum target, GLenum query, GLint *v)
-{
-    d_1_0_Deprecated->f.GetMapiv(target, query, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetMapfv(GLenum target, GLenum query, GLfloat *v)
-{
-    d_1_0_Deprecated->f.GetMapfv(target, query, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetMapdv(GLenum target, GLenum query, GLdouble *v)
-{
-    d_1_0_Deprecated->f.GetMapdv(target, query, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetLightiv(GLenum light, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetLightiv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetLightfv(GLenum light, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetLightfv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetClipPlane(GLenum plane, GLdouble *equation)
-{
-    d_1_0_Deprecated->f.GetClipPlane(plane, equation);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Deprecated->f.DrawPixels(width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
-{
-    d_1_0_Deprecated->f.CopyPixels(x, y, width, height, type);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values)
-{
-    d_1_0_Deprecated->f.PixelMapusv(map, mapsize, values);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values)
-{
-    d_1_0_Deprecated->f.PixelMapuiv(map, mapsize, values);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values)
-{
-    d_1_0_Deprecated->f.PixelMapfv(map, mapsize, values);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glPixelTransferi(GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.PixelTransferi(pname, param);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glPixelTransferf(GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.PixelTransferf(pname, param);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glPixelZoom(GLfloat xfactor, GLfloat yfactor)
-{
-    d_1_0_Deprecated->f.PixelZoom(xfactor, yfactor);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glAlphaFunc(GLenum func, GLfloat ref)
-{
-    d_1_0_Deprecated->f.AlphaFunc(func, ref);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glEvalPoint2(GLint i, GLint j)
-{
-    d_1_0_Deprecated->f.EvalPoint2(i, j);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
-{
-    d_1_0_Deprecated->f.EvalMesh2(mode, i1, i2, j1, j2);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glEvalPoint1(GLint i)
-{
-    d_1_0_Deprecated->f.EvalPoint1(i);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glEvalMesh1(GLenum mode, GLint i1, GLint i2)
-{
-    d_1_0_Deprecated->f.EvalMesh1(mode, i1, i2);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glEvalCoord2fv(const GLfloat *u)
-{
-    d_1_0_Deprecated->f.EvalCoord2fv(u);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glEvalCoord2f(GLfloat u, GLfloat v)
-{
-    d_1_0_Deprecated->f.EvalCoord2f(u, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glEvalCoord2dv(const GLdouble *u)
-{
-    d_1_0_Deprecated->f.EvalCoord2dv(u);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glEvalCoord2d(GLdouble u, GLdouble v)
-{
-    d_1_0_Deprecated->f.EvalCoord2d(u, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glEvalCoord1fv(const GLfloat *u)
-{
-    d_1_0_Deprecated->f.EvalCoord1fv(u);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glEvalCoord1f(GLfloat u)
-{
-    d_1_0_Deprecated->f.EvalCoord1f(u);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glEvalCoord1dv(const GLdouble *u)
-{
-    d_1_0_Deprecated->f.EvalCoord1dv(u);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glEvalCoord1d(GLdouble u)
-{
-    d_1_0_Deprecated->f.EvalCoord1d(u);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
-{
-    d_1_0_Deprecated->f.MapGrid2f(un, u1, u2, vn, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
-{
-    d_1_0_Deprecated->f.MapGrid2d(un, u1, u2, vn, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
-{
-    d_1_0_Deprecated->f.MapGrid1f(un, u1, u2);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
-{
-    d_1_0_Deprecated->f.MapGrid1d(un, u1, u2);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
-{
-    d_1_0_Deprecated->f.Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
-{
-    d_1_0_Deprecated->f.Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
-{
-    d_1_0_Deprecated->f.Map1f(target, u1, u2, stride, order, points);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
-{
-    d_1_0_Deprecated->f.Map1d(target, u1, u2, stride, order, points);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glPushAttrib(GLbitfield mask)
-{
-    d_1_0_Deprecated->f.PushAttrib(mask);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glPopAttrib()
-{
-    d_1_0_Deprecated->f.PopAttrib();
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glAccum(GLenum op, GLfloat value)
-{
-    d_1_0_Deprecated->f.Accum(op, value);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glIndexMask(GLuint mask)
-{
-    d_1_0_Deprecated->f.IndexMask(mask);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glClearIndex(GLfloat c)
-{
-    d_1_0_Deprecated->f.ClearIndex(c);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Deprecated->f.ClearAccum(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glPushName(GLuint name)
-{
-    d_1_0_Deprecated->f.PushName(name);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glPopName()
-{
-    d_1_0_Deprecated->f.PopName();
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glPassThrough(GLfloat token)
-{
-    d_1_0_Deprecated->f.PassThrough(token);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glLoadName(GLuint name)
-{
-    d_1_0_Deprecated->f.LoadName(name);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glInitNames()
-{
-    d_1_0_Deprecated->f.InitNames();
-}
-
-inline GLint QOpenGLFunctions_4_1_Compatibility::glRenderMode(GLenum mode)
-{
-    return d_1_0_Deprecated->f.RenderMode(mode);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glSelectBuffer(GLsizei size, GLuint *buffer)
-{
-    d_1_0_Deprecated->f.SelectBuffer(size, buffer);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
-{
-    d_1_0_Deprecated->f.FeedbackBuffer(size, type, buffer);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexGeniv(GLenum coord, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.TexGeniv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexGeni(GLenum coord, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.TexGeni(coord, pname, param);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.TexGenfv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexGenf(GLenum coord, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.TexGenf(coord, pname, param);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
-{
-    d_1_0_Deprecated->f.TexGendv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexGend(GLenum coord, GLenum pname, GLdouble param)
-{
-    d_1_0_Deprecated->f.TexGend(coord, pname, param);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexEnviv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.TexEnviv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexEnvi(GLenum target, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.TexEnvi(target, pname, param);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.TexEnvfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexEnvf(GLenum target, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.TexEnvf(target, pname, param);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glShadeModel(GLenum mode)
-{
-    d_1_0_Deprecated->f.ShadeModel(mode);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glPolygonStipple(const GLubyte *mask)
-{
-    d_1_0_Deprecated->f.PolygonStipple(mask);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMaterialiv(GLenum face, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.Materialiv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMateriali(GLenum face, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.Materiali(face, pname, param);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.Materialfv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMaterialf(GLenum face, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.Materialf(face, pname, param);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glLineStipple(GLint factor, GLushort pattern)
-{
-    d_1_0_Deprecated->f.LineStipple(factor, pattern);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glLightModeliv(GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.LightModeliv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glLightModeli(GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.LightModeli(pname, param);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glLightModelfv(GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.LightModelfv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glLightModelf(GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.LightModelf(pname, param);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glLightiv(GLenum light, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.Lightiv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glLighti(GLenum light, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.Lighti(light, pname, param);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glLightfv(GLenum light, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.Lightfv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glLightf(GLenum light, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.Lightf(light, pname, param);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glFogiv(GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.Fogiv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glFogi(GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.Fogi(pname, param);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glFogfv(GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.Fogfv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glFogf(GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.Fogf(pname, param);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glColorMaterial(GLenum face, GLenum mode)
-{
-    d_1_0_Deprecated->f.ColorMaterial(face, mode);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glClipPlane(GLenum plane, const GLdouble *equation)
-{
-    d_1_0_Deprecated->f.ClipPlane(plane, equation);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertex4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Vertex4sv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
-{
-    d_1_0_Deprecated->f.Vertex4s(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertex4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Vertex4iv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertex4i(GLint x, GLint y, GLint z, GLint w)
-{
-    d_1_0_Deprecated->f.Vertex4i(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertex4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Vertex4fv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    d_1_0_Deprecated->f.Vertex4f(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertex4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Vertex4dv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_1_0_Deprecated->f.Vertex4d(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertex3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Vertex3sv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertex3s(GLshort x, GLshort y, GLshort z)
-{
-    d_1_0_Deprecated->f.Vertex3s(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertex3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Vertex3iv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertex3i(GLint x, GLint y, GLint z)
-{
-    d_1_0_Deprecated->f.Vertex3i(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertex3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Vertex3fv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertex3f(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Vertex3f(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertex3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Vertex3dv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertex3d(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Vertex3d(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertex2sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Vertex2sv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertex2s(GLshort x, GLshort y)
-{
-    d_1_0_Deprecated->f.Vertex2s(x, y);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertex2iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Vertex2iv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertex2i(GLint x, GLint y)
-{
-    d_1_0_Deprecated->f.Vertex2i(x, y);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertex2fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Vertex2fv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertex2f(GLfloat x, GLfloat y)
-{
-    d_1_0_Deprecated->f.Vertex2f(x, y);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertex2dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Vertex2dv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertex2d(GLdouble x, GLdouble y)
-{
-    d_1_0_Deprecated->f.Vertex2d(x, y);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord4sv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
-{
-    d_1_0_Deprecated->f.TexCoord4s(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord4iv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
-{
-    d_1_0_Deprecated->f.TexCoord4i(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord4fv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
-{
-    d_1_0_Deprecated->f.TexCoord4f(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord4dv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
-{
-    d_1_0_Deprecated->f.TexCoord4d(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord3sv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord3s(GLshort s, GLshort t, GLshort r)
-{
-    d_1_0_Deprecated->f.TexCoord3s(s, t, r);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord3iv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord3i(GLint s, GLint t, GLint r)
-{
-    d_1_0_Deprecated->f.TexCoord3i(s, t, r);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord3fv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
-{
-    d_1_0_Deprecated->f.TexCoord3f(s, t, r);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord3dv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
-{
-    d_1_0_Deprecated->f.TexCoord3d(s, t, r);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord2sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord2sv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord2s(GLshort s, GLshort t)
-{
-    d_1_0_Deprecated->f.TexCoord2s(s, t);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord2iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord2iv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord2i(GLint s, GLint t)
-{
-    d_1_0_Deprecated->f.TexCoord2i(s, t);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord2fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord2fv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord2f(GLfloat s, GLfloat t)
-{
-    d_1_0_Deprecated->f.TexCoord2f(s, t);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord2dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord2dv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord2d(GLdouble s, GLdouble t)
-{
-    d_1_0_Deprecated->f.TexCoord2d(s, t);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord1sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord1sv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord1s(GLshort s)
-{
-    d_1_0_Deprecated->f.TexCoord1s(s);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord1iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord1iv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord1i(GLint s)
-{
-    d_1_0_Deprecated->f.TexCoord1i(s);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord1fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord1fv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord1f(GLfloat s)
-{
-    d_1_0_Deprecated->f.TexCoord1f(s);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord1dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord1dv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord1d(GLdouble s)
-{
-    d_1_0_Deprecated->f.TexCoord1d(s);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glRectsv(const GLshort *v1, const GLshort *v2)
-{
-    d_1_0_Deprecated->f.Rectsv(v1, v2);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
-{
-    d_1_0_Deprecated->f.Rects(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glRectiv(const GLint *v1, const GLint *v2)
-{
-    d_1_0_Deprecated->f.Rectiv(v1, v2);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
-{
-    d_1_0_Deprecated->f.Recti(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glRectfv(const GLfloat *v1, const GLfloat *v2)
-{
-    d_1_0_Deprecated->f.Rectfv(v1, v2);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
-{
-    d_1_0_Deprecated->f.Rectf(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glRectdv(const GLdouble *v1, const GLdouble *v2)
-{
-    d_1_0_Deprecated->f.Rectdv(v1, v2);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
-{
-    d_1_0_Deprecated->f.Rectd(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glRasterPos4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.RasterPos4sv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
-{
-    d_1_0_Deprecated->f.RasterPos4s(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glRasterPos4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.RasterPos4iv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
-{
-    d_1_0_Deprecated->f.RasterPos4i(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glRasterPos4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.RasterPos4fv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    d_1_0_Deprecated->f.RasterPos4f(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glRasterPos4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.RasterPos4dv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_1_0_Deprecated->f.RasterPos4d(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glRasterPos3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.RasterPos3sv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glRasterPos3s(GLshort x, GLshort y, GLshort z)
-{
-    d_1_0_Deprecated->f.RasterPos3s(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glRasterPos3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.RasterPos3iv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glRasterPos3i(GLint x, GLint y, GLint z)
-{
-    d_1_0_Deprecated->f.RasterPos3i(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glRasterPos3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.RasterPos3fv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.RasterPos3f(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glRasterPos3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.RasterPos3dv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.RasterPos3d(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glRasterPos2sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.RasterPos2sv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glRasterPos2s(GLshort x, GLshort y)
-{
-    d_1_0_Deprecated->f.RasterPos2s(x, y);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glRasterPos2iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.RasterPos2iv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glRasterPos2i(GLint x, GLint y)
-{
-    d_1_0_Deprecated->f.RasterPos2i(x, y);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glRasterPos2fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.RasterPos2fv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glRasterPos2f(GLfloat x, GLfloat y)
-{
-    d_1_0_Deprecated->f.RasterPos2f(x, y);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glRasterPos2dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.RasterPos2dv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glRasterPos2d(GLdouble x, GLdouble y)
-{
-    d_1_0_Deprecated->f.RasterPos2d(x, y);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glNormal3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Normal3sv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glNormal3s(GLshort nx, GLshort ny, GLshort nz)
-{
-    d_1_0_Deprecated->f.Normal3s(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glNormal3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Normal3iv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glNormal3i(GLint nx, GLint ny, GLint nz)
-{
-    d_1_0_Deprecated->f.Normal3i(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glNormal3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Normal3fv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
-{
-    d_1_0_Deprecated->f.Normal3f(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glNormal3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Normal3dv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
-{
-    d_1_0_Deprecated->f.Normal3d(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glNormal3bv(const GLbyte *v)
-{
-    d_1_0_Deprecated->f.Normal3bv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
-{
-    d_1_0_Deprecated->f.Normal3b(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glIndexsv(const GLshort *c)
-{
-    d_1_0_Deprecated->f.Indexsv(c);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glIndexs(GLshort c)
-{
-    d_1_0_Deprecated->f.Indexs(c);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glIndexiv(const GLint *c)
-{
-    d_1_0_Deprecated->f.Indexiv(c);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glIndexi(GLint c)
-{
-    d_1_0_Deprecated->f.Indexi(c);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glIndexfv(const GLfloat *c)
-{
-    d_1_0_Deprecated->f.Indexfv(c);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glIndexf(GLfloat c)
-{
-    d_1_0_Deprecated->f.Indexf(c);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glIndexdv(const GLdouble *c)
-{
-    d_1_0_Deprecated->f.Indexdv(c);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glIndexd(GLdouble c)
-{
-    d_1_0_Deprecated->f.Indexd(c);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glEnd()
-{
-    d_1_0_Deprecated->f.End();
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glEdgeFlagv(const GLboolean *flag)
-{
-    d_1_0_Deprecated->f.EdgeFlagv(flag);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glEdgeFlag(GLboolean flag)
-{
-    d_1_0_Deprecated->f.EdgeFlag(flag);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glColor4usv(const GLushort *v)
-{
-    d_1_0_Deprecated->f.Color4usv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
-{
-    d_1_0_Deprecated->f.Color4us(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glColor4uiv(const GLuint *v)
-{
-    d_1_0_Deprecated->f.Color4uiv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
-{
-    d_1_0_Deprecated->f.Color4ui(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glColor4ubv(const GLubyte *v)
-{
-    d_1_0_Deprecated->f.Color4ubv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
-{
-    d_1_0_Deprecated->f.Color4ub(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glColor4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Color4sv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
-{
-    d_1_0_Deprecated->f.Color4s(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glColor4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Color4iv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
-{
-    d_1_0_Deprecated->f.Color4i(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glColor4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Color4fv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Deprecated->f.Color4f(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glColor4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Color4dv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
-{
-    d_1_0_Deprecated->f.Color4d(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glColor4bv(const GLbyte *v)
-{
-    d_1_0_Deprecated->f.Color4bv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
-{
-    d_1_0_Deprecated->f.Color4b(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glColor3usv(const GLushort *v)
-{
-    d_1_0_Deprecated->f.Color3usv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glColor3us(GLushort red, GLushort green, GLushort blue)
-{
-    d_1_0_Deprecated->f.Color3us(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glColor3uiv(const GLuint *v)
-{
-    d_1_0_Deprecated->f.Color3uiv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glColor3ui(GLuint red, GLuint green, GLuint blue)
-{
-    d_1_0_Deprecated->f.Color3ui(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glColor3ubv(const GLubyte *v)
-{
-    d_1_0_Deprecated->f.Color3ubv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
-{
-    d_1_0_Deprecated->f.Color3ub(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glColor3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Color3sv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glColor3s(GLshort red, GLshort green, GLshort blue)
-{
-    d_1_0_Deprecated->f.Color3s(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glColor3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Color3iv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glColor3i(GLint red, GLint green, GLint blue)
-{
-    d_1_0_Deprecated->f.Color3i(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glColor3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Color3fv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glColor3f(GLfloat red, GLfloat green, GLfloat blue)
-{
-    d_1_0_Deprecated->f.Color3f(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glColor3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Color3dv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glColor3d(GLdouble red, GLdouble green, GLdouble blue)
-{
-    d_1_0_Deprecated->f.Color3d(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glColor3bv(const GLbyte *v)
-{
-    d_1_0_Deprecated->f.Color3bv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glColor3b(GLbyte red, GLbyte green, GLbyte blue)
-{
-    d_1_0_Deprecated->f.Color3b(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
-{
-    d_1_0_Deprecated->f.Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glBegin(GLenum mode)
-{
-    d_1_0_Deprecated->f.Begin(mode);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glListBase(GLuint base)
-{
-    d_1_0_Deprecated->f.ListBase(base);
-}
-
-inline GLuint QOpenGLFunctions_4_1_Compatibility::glGenLists(GLsizei range)
-{
-    return d_1_0_Deprecated->f.GenLists(range);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glDeleteLists(GLuint list, GLsizei range)
-{
-    d_1_0_Deprecated->f.DeleteLists(list, range);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glCallLists(GLsizei n, GLenum type, const GLvoid *lists)
-{
-    d_1_0_Deprecated->f.CallLists(n, type, lists);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glCallList(GLuint list)
-{
-    d_1_0_Deprecated->f.CallList(list);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glEndList()
-{
-    d_1_0_Deprecated->f.EndList();
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glNewList(GLuint list, GLenum mode)
-{
-    d_1_0_Deprecated->f.NewList(list, mode);
-}
-
-
-// OpenGL 1.1 deprecated functions
-inline void QOpenGLFunctions_4_1_Compatibility::glPushClientAttrib(GLbitfield mask)
-{
-    d_1_1_Deprecated->f.PushClientAttrib(mask);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glPopClientAttrib()
-{
-    d_1_1_Deprecated->f.PopClientAttrib();
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities)
-{
-    d_1_1_Deprecated->f.PrioritizeTextures(n, textures, priorities);
-}
-
-inline GLboolean QOpenGLFunctions_4_1_Compatibility::glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
-{
-    return d_1_1_Deprecated->f.AreTexturesResident(n, textures, residences);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.VertexPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.TexCoordPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.NormalPointer(type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.InterleavedArrays(format, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.IndexPointer(type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glEnableClientState(GLenum array)
-{
-    d_1_1_Deprecated->f.EnableClientState(array);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.EdgeFlagPointer(stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glDisableClientState(GLenum array)
-{
-    d_1_1_Deprecated->f.DisableClientState(array);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.ColorPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glArrayElement(GLint i)
-{
-    d_1_1_Deprecated->f.ArrayElement(i);
-}
-
-
-// OpenGL 1.2 deprecated functions
-inline void QOpenGLFunctions_4_1_Compatibility::glResetMinmax(GLenum target)
-{
-    d_1_2_Deprecated->f.ResetMinmax(target);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glResetHistogram(GLenum target)
-{
-    d_1_2_Deprecated->f.ResetHistogram(target);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMinmax(GLenum target, GLenum internalformat, GLboolean sink)
-{
-    d_1_2_Deprecated->f.Minmax(target, internalformat, sink);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
-{
-    d_1_2_Deprecated->f.Histogram(target, width, internalformat, sink);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetMinmaxParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetMinmaxParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
-{
-    d_1_2_Deprecated->f.GetMinmax(target, reset, format, type, values);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetHistogramParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetHistogramParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
-{
-    d_1_2_Deprecated->f.GetHistogram(target, reset, format, type, values);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column)
-{
-    d_1_2_Deprecated->f.SeparableFilter2D(target, internalformat, width, height, format, type, row, column);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span)
-{
-    d_1_2_Deprecated->f.GetSeparableFilter(target, format, type, row, column, span);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetConvolutionParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetConvolutionParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image)
-{
-    d_1_2_Deprecated->f.GetConvolutionFilter(target, format, type, image);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_2_Deprecated->f.CopyConvolutionFilter2D(target, internalformat, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
-{
-    d_1_2_Deprecated->f.CopyConvolutionFilter1D(target, internalformat, x, y, width);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glConvolutionParameteri(GLenum target, GLenum pname, GLint params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameteri(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameterf(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image)
-{
-    d_1_2_Deprecated->f.ConvolutionFilter2D(target, internalformat, width, height, format, type, image);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image)
-{
-    d_1_2_Deprecated->f.ConvolutionFilter1D(target, internalformat, width, format, type, image);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
-{
-    d_1_2_Deprecated->f.CopyColorSubTable(target, start, x, y, width);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data)
-{
-    d_1_2_Deprecated->f.ColorSubTable(target, start, count, format, type, data);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetColorTableParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetColorTableParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table)
-{
-    d_1_2_Deprecated->f.GetColorTable(target, format, type, table);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
-{
-    d_1_2_Deprecated->f.CopyColorTable(target, internalformat, x, y, width);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_2_Deprecated->f.ColorTableParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_2_Deprecated->f.ColorTableParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table)
-{
-    d_1_2_Deprecated->f.ColorTable(target, internalformat, width, format, type, table);
-}
-
-
-// OpenGL 1.3 deprecated functions
-inline void QOpenGLFunctions_4_1_Compatibility::glMultTransposeMatrixd(const GLdouble *m)
-{
-    d_1_3_Deprecated->f.MultTransposeMatrixd(m);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMultTransposeMatrixf(const GLfloat *m)
-{
-    d_1_3_Deprecated->f.MultTransposeMatrixf(m);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glLoadTransposeMatrixd(const GLdouble *m)
-{
-    d_1_3_Deprecated->f.LoadTransposeMatrixd(m);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glLoadTransposeMatrixf(const GLfloat *m)
-{
-    d_1_3_Deprecated->f.LoadTransposeMatrixf(m);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord4sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4sv(target, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4s(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord4iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4iv(target, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4i(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord4fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4fv(target, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4f(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord4dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4dv(target, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4d(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord3sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3sv(target, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3s(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord3iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3iv(target, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3i(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord3fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3fv(target, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3f(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord3dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3dv(target, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3d(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord2sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2sv(target, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord2s(GLenum target, GLshort s, GLshort t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2s(target, s, t);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord2iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2iv(target, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord2i(GLenum target, GLint s, GLint t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2i(target, s, t);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord2fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2fv(target, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2f(target, s, t);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord2dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2dv(target, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2d(target, s, t);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord1sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1sv(target, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord1s(GLenum target, GLshort s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1s(target, s);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord1iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1iv(target, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord1i(GLenum target, GLint s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1i(target, s);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord1fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1fv(target, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord1f(GLenum target, GLfloat s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1f(target, s);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord1dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1dv(target, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord1d(GLenum target, GLdouble s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1d(target, s);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glClientActiveTexture(GLenum texture)
-{
-    d_1_3_Deprecated->f.ClientActiveTexture(texture);
-}
-
-
-// OpenGL 1.4 deprecated functions
-inline void QOpenGLFunctions_4_1_Compatibility::glWindowPos3sv(const GLshort *v)
-{
-    d_1_4_Deprecated->f.WindowPos3sv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glWindowPos3s(GLshort x, GLshort y, GLshort z)
-{
-    d_1_4_Deprecated->f.WindowPos3s(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glWindowPos3iv(const GLint *v)
-{
-    d_1_4_Deprecated->f.WindowPos3iv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glWindowPos3i(GLint x, GLint y, GLint z)
-{
-    d_1_4_Deprecated->f.WindowPos3i(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glWindowPos3fv(const GLfloat *v)
-{
-    d_1_4_Deprecated->f.WindowPos3fv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glWindowPos3f(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_4_Deprecated->f.WindowPos3f(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glWindowPos3dv(const GLdouble *v)
-{
-    d_1_4_Deprecated->f.WindowPos3dv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glWindowPos3d(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_4_Deprecated->f.WindowPos3d(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glWindowPos2sv(const GLshort *v)
-{
-    d_1_4_Deprecated->f.WindowPos2sv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glWindowPos2s(GLshort x, GLshort y)
-{
-    d_1_4_Deprecated->f.WindowPos2s(x, y);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glWindowPos2iv(const GLint *v)
-{
-    d_1_4_Deprecated->f.WindowPos2iv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glWindowPos2i(GLint x, GLint y)
-{
-    d_1_4_Deprecated->f.WindowPos2i(x, y);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glWindowPos2fv(const GLfloat *v)
-{
-    d_1_4_Deprecated->f.WindowPos2fv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glWindowPos2f(GLfloat x, GLfloat y)
-{
-    d_1_4_Deprecated->f.WindowPos2f(x, y);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glWindowPos2dv(const GLdouble *v)
-{
-    d_1_4_Deprecated->f.WindowPos2dv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glWindowPos2d(GLdouble x, GLdouble y)
-{
-    d_1_4_Deprecated->f.WindowPos2d(x, y);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_4_Deprecated->f.SecondaryColorPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glSecondaryColor3usv(const GLushort *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3usv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glSecondaryColor3us(GLushort red, GLushort green, GLushort blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3us(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glSecondaryColor3uiv(const GLuint *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3uiv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3ui(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glSecondaryColor3ubv(const GLubyte *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3ubv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3ub(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glSecondaryColor3sv(const GLshort *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3sv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glSecondaryColor3s(GLshort red, GLshort green, GLshort blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3s(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glSecondaryColor3iv(const GLint *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3iv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glSecondaryColor3i(GLint red, GLint green, GLint blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3i(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glSecondaryColor3fv(const GLfloat *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3fv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3f(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glSecondaryColor3dv(const GLdouble *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3dv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3d(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glSecondaryColor3bv(const GLbyte *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3bv(v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3b(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glFogCoordPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_4_Deprecated->f.FogCoordPointer(type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glFogCoorddv(const GLdouble *coord)
-{
-    d_1_4_Deprecated->f.FogCoorddv(coord);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glFogCoordd(GLdouble coord)
-{
-    d_1_4_Deprecated->f.FogCoordd(coord);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glFogCoordfv(const GLfloat *coord)
-{
-    d_1_4_Deprecated->f.FogCoordfv(coord);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glFogCoordf(GLfloat coord)
-{
-    d_1_4_Deprecated->f.FogCoordf(coord);
-}
-
-
-// OpenGL 1.5 deprecated functions
-
-// OpenGL 2.0 deprecated functions
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4usv(GLuint index, const GLushort *v)
-{
-    d_2_0_Core->f.VertexAttrib4usv(index, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4uiv(GLuint index, const GLuint *v)
-{
-    d_2_0_Core->f.VertexAttrib4uiv(index, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4ubv(GLuint index, const GLubyte *v)
-{
-    d_2_0_Core->f.VertexAttrib4ubv(index, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4sv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib4sv(index, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
-{
-    d_2_0_Core->f.VertexAttrib4s(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4iv(GLuint index, const GLint *v)
-{
-    d_2_0_Core->f.VertexAttrib4iv(index, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4fv(GLuint index, const GLfloat *v)
-{
-    d_2_0_Core->f.VertexAttrib4fv(index, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    d_2_0_Core->f.VertexAttrib4f(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4dv(GLuint index, const GLdouble *v)
-{
-    d_2_0_Core->f.VertexAttrib4dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_2_0_Core->f.VertexAttrib4d(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4bv(GLuint index, const GLbyte *v)
-{
-    d_2_0_Core->f.VertexAttrib4bv(index, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4Nusv(GLuint index, const GLushort *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nusv(index, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4Nuiv(GLuint index, const GLuint *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nuiv(index, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4Nubv(GLuint index, const GLubyte *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nubv(index, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
-{
-    d_2_0_Core->f.VertexAttrib4Nub(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4Nsv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nsv(index, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4Niv(GLuint index, const GLint *v)
-{
-    d_2_0_Core->f.VertexAttrib4Niv(index, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4Nbv(GLuint index, const GLbyte *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nbv(index, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib3sv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib3sv(index, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
-{
-    d_2_0_Core->f.VertexAttrib3s(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib3fv(GLuint index, const GLfloat *v)
-{
-    d_2_0_Core->f.VertexAttrib3fv(index, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
-{
-    d_2_0_Core->f.VertexAttrib3f(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib3dv(GLuint index, const GLdouble *v)
-{
-    d_2_0_Core->f.VertexAttrib3dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
-{
-    d_2_0_Core->f.VertexAttrib3d(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib2sv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib2sv(index, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib2s(GLuint index, GLshort x, GLshort y)
-{
-    d_2_0_Core->f.VertexAttrib2s(index, x, y);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib2fv(GLuint index, const GLfloat *v)
-{
-    d_2_0_Core->f.VertexAttrib2fv(index, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
-{
-    d_2_0_Core->f.VertexAttrib2f(index, x, y);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib2dv(GLuint index, const GLdouble *v)
-{
-    d_2_0_Core->f.VertexAttrib2dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
-{
-    d_2_0_Core->f.VertexAttrib2d(index, x, y);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib1sv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib1sv(index, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib1s(GLuint index, GLshort x)
-{
-    d_2_0_Core->f.VertexAttrib1s(index, x);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib1fv(GLuint index, const GLfloat *v)
-{
-    d_2_0_Core->f.VertexAttrib1fv(index, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib1f(GLuint index, GLfloat x)
-{
-    d_2_0_Core->f.VertexAttrib1f(index, x);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib1dv(GLuint index, const GLdouble *v)
-{
-    d_2_0_Core->f.VertexAttrib1dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib1d(GLuint index, GLdouble x)
-{
-    d_2_0_Core->f.VertexAttrib1d(index, x);
-}
-
-
-// OpenGL 2.1 deprecated functions
-
-// OpenGL 3.0 deprecated functions
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI4usv(GLuint index, const GLushort *v)
-{
-    d_3_0_Core->f.VertexAttribI4usv(index, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI4ubv(GLuint index, const GLubyte *v)
-{
-    d_3_0_Core->f.VertexAttribI4ubv(index, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI4sv(GLuint index, const GLshort *v)
-{
-    d_3_0_Core->f.VertexAttribI4sv(index, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI4bv(GLuint index, const GLbyte *v)
-{
-    d_3_0_Core->f.VertexAttribI4bv(index, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI4uiv(GLuint index, const GLuint *v)
-{
-    d_3_0_Core->f.VertexAttribI4uiv(index, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI3uiv(GLuint index, const GLuint *v)
-{
-    d_3_0_Core->f.VertexAttribI3uiv(index, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI2uiv(GLuint index, const GLuint *v)
-{
-    d_3_0_Core->f.VertexAttribI2uiv(index, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI1uiv(GLuint index, const GLuint *v)
-{
-    d_3_0_Core->f.VertexAttribI1uiv(index, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI4iv(GLuint index, const GLint *v)
-{
-    d_3_0_Core->f.VertexAttribI4iv(index, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI3iv(GLuint index, const GLint *v)
-{
-    d_3_0_Core->f.VertexAttribI3iv(index, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI2iv(GLuint index, const GLint *v)
-{
-    d_3_0_Core->f.VertexAttribI2iv(index, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI1iv(GLuint index, const GLint *v)
-{
-    d_3_0_Core->f.VertexAttribI1iv(index, v);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
-{
-    d_3_0_Core->f.VertexAttribI4ui(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z)
-{
-    d_3_0_Core->f.VertexAttribI3ui(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI2ui(GLuint index, GLuint x, GLuint y)
-{
-    d_3_0_Core->f.VertexAttribI2ui(index, x, y);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI1ui(GLuint index, GLuint x)
-{
-    d_3_0_Core->f.VertexAttribI1ui(index, x);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
-{
-    d_3_0_Core->f.VertexAttribI4i(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI3i(GLuint index, GLint x, GLint y, GLint z)
-{
-    d_3_0_Core->f.VertexAttribI3i(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI2i(GLuint index, GLint x, GLint y)
-{
-    d_3_0_Core->f.VertexAttribI2i(index, x, y);
-}
-
-inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI1i(GLuint index, GLint x)
-{
-    d_3_0_Core->f.VertexAttribI1i(index, x);
-}
-
-
-// OpenGL 3.1 deprecated functions
-
-// OpenGL 3.2 deprecated functions
-
-// OpenGL 3.3 deprecated functions
-
-// OpenGL 4.0 deprecated functions
-
-// OpenGL 4.1 deprecated functions
-
-
-QT_END_NAMESPACE
-
-#endif // QT_NO_OPENGL && !QT_OPENGL_ES_2
-
-#endif
diff --git a/src/gui/opengl/qopenglfunctions_4_1_core.cpp b/src/gui/opengl/qopenglfunctions_4_1_core.cpp
deleted file mode 100644
index b21742d9c1..0000000000
--- a/src/gui/opengl/qopenglfunctions_4_1_core.cpp
+++ /dev/null
@@ -1,242 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#include "qopenglfunctions_4_1_core.h"
-#include "qopenglcontext.h"
-
-QT_BEGIN_NAMESPACE
-
-/*!
-    \class QOpenGLFunctions_4_1_Core
-    \inmodule QtGui
-    \since 5.1
-    \wrapper
-    \brief The QOpenGLFunctions_4_1_Core class provides all functions for OpenGL 4.1 core profile.
-
-    This class is a wrapper for functions from OpenGL 4.1 core profile.
-    See reference pages on \l {http://www.opengl.org/sdk/docs/}{opengl.org}
-    for function documentation.
-
-    \sa QAbstractOpenGLFunctions
-*/
-
-QOpenGLFunctions_4_1_Core::QOpenGLFunctions_4_1_Core()
- : QAbstractOpenGLFunctions()
- , d_1_0_Core(nullptr)
- , d_1_1_Core(nullptr)
- , d_1_2_Core(nullptr)
- , d_1_3_Core(nullptr)
- , d_1_4_Core(nullptr)
- , d_1_5_Core(nullptr)
- , d_2_0_Core(nullptr)
- , d_2_1_Core(nullptr)
- , d_3_0_Core(nullptr)
- , d_3_1_Core(nullptr)
- , d_3_2_Core(nullptr)
- , d_3_3_Core(nullptr)
- , d_4_0_Core(nullptr)
- , d_4_1_Core(nullptr)
-{
-}
-
-QOpenGLFunctions_4_1_Core::~QOpenGLFunctions_4_1_Core()
-{
-    if (d_1_0_Core) {
-        d_1_0_Core->refs.deref();
-        Q_ASSERT(d_1_0_Core->refs.loadRelaxed());
-    }
-    if (d_1_1_Core) {
-        d_1_1_Core->refs.deref();
-        Q_ASSERT(d_1_1_Core->refs.loadRelaxed());
-    }
-    if (d_1_2_Core) {
-        d_1_2_Core->refs.deref();
-        Q_ASSERT(d_1_2_Core->refs.loadRelaxed());
-    }
-    if (d_1_3_Core) {
-        d_1_3_Core->refs.deref();
-        Q_ASSERT(d_1_3_Core->refs.loadRelaxed());
-    }
-    if (d_1_4_Core) {
-        d_1_4_Core->refs.deref();
-        Q_ASSERT(d_1_4_Core->refs.loadRelaxed());
-    }
-    if (d_1_5_Core) {
-        d_1_5_Core->refs.deref();
-        Q_ASSERT(d_1_5_Core->refs.loadRelaxed());
-    }
-    if (d_2_0_Core) {
-        d_2_0_Core->refs.deref();
-        Q_ASSERT(d_2_0_Core->refs.loadRelaxed());
-    }
-    if (d_2_1_Core) {
-        d_2_1_Core->refs.deref();
-        Q_ASSERT(d_2_1_Core->refs.loadRelaxed());
-    }
-    if (d_3_0_Core) {
-        d_3_0_Core->refs.deref();
-        Q_ASSERT(d_3_0_Core->refs.loadRelaxed());
-    }
-    if (d_3_1_Core) {
-        d_3_1_Core->refs.deref();
-        Q_ASSERT(d_3_1_Core->refs.loadRelaxed());
-    }
-    if (d_3_2_Core) {
-        d_3_2_Core->refs.deref();
-        Q_ASSERT(d_3_2_Core->refs.loadRelaxed());
-    }
-    if (d_3_3_Core) {
-        d_3_3_Core->refs.deref();
-        Q_ASSERT(d_3_3_Core->refs.loadRelaxed());
-    }
-    if (d_4_0_Core) {
-        d_4_0_Core->refs.deref();
-        Q_ASSERT(d_4_0_Core->refs.loadRelaxed());
-    }
-    if (d_4_1_Core) {
-        d_4_1_Core->refs.deref();
-        Q_ASSERT(d_4_1_Core->refs.loadRelaxed());
-    }
-}
-
-bool QOpenGLFunctions_4_1_Core::initializeOpenGLFunctions()
-{
-    if ( isInitialized() )
-        return true;
-
-    QOpenGLContext* context = QOpenGLContext::currentContext();
-
-    // If owned by a context object make sure it is current.
-    // Also check that current context is capable of resolving all needed functions
-    if (((owningContext() && owningContext() == context) || !owningContext())
-        && QOpenGLFunctions_4_1_Core::isContextCompatible(context))
-    {
-        // Associate with private implementation, creating if necessary
-        // Function pointers in the backends are resolved at creation time
-        QOpenGLVersionFunctionsBackend* d = nullptr;
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        d_1_3_Core = static_cast<QOpenGLFunctions_1_3_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        d_1_4_Core = static_cast<QOpenGLFunctions_1_4_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        d_1_5_Core = static_cast<QOpenGLFunctions_1_5_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        d_2_0_Core = static_cast<QOpenGLFunctions_2_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        d_2_1_Core = static_cast<QOpenGLFunctions_2_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        d_3_0_Core = static_cast<QOpenGLFunctions_3_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
-        d_3_1_Core = static_cast<QOpenGLFunctions_3_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
-        d_3_2_Core = static_cast<QOpenGLFunctions_3_2_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_CoreBackend::versionStatus());
-        d_3_3_Core = static_cast<QOpenGLFunctions_3_3_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_0_CoreBackend::versionStatus());
-        d_4_0_Core = static_cast<QOpenGLFunctions_4_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_1_CoreBackend::versionStatus());
-        d_4_1_Core = static_cast<QOpenGLFunctions_4_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        QAbstractOpenGLFunctions::initializeOpenGLFunctions();
-    }
-    return isInitialized();
-}
-
-bool QOpenGLFunctions_4_1_Core::isContextCompatible(QOpenGLContext *context)
-{
-    Q_ASSERT(context);
-    QSurfaceFormat f = context->format();
-    const QPair<int, int> v = qMakePair(f.majorVersion(), f.minorVersion());
-    if (v < qMakePair(4, 1))
-        return false;
-
-    return true;
-}
-
-QOpenGLVersionProfile QOpenGLFunctions_4_1_Core::versionProfile()
-{
-    QOpenGLVersionProfile v;
-    v.setVersion(4, 1);
-    v.setProfile(QSurfaceFormat::CoreProfile);
-    return v;
-}
-
-QT_END_NAMESPACE
diff --git a/src/gui/opengl/qopenglfunctions_4_1_core.h b/src/gui/opengl/qopenglfunctions_4_1_core.h
deleted file mode 100644
index 3a4fd0743b..0000000000
--- a/src/gui/opengl/qopenglfunctions_4_1_core.h
+++ /dev/null
@@ -1,2955 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#ifndef QOPENGLVERSIONFUNCTIONS_4_1_CORE_H
-#define QOPENGLVERSIONFUNCTIONS_4_1_CORE_H
-
-#include <QtGui/qtguiglobal.h>
-
-#if !defined(QT_NO_OPENGL) && !defined(QT_OPENGL_ES_2)
-
-#include <QtGui/QOpenGLVersionFunctions>
-#include <QtGui/qopenglcontext.h>
-
-QT_BEGIN_NAMESPACE
-
-class Q_GUI_EXPORT QOpenGLFunctions_4_1_Core : public QAbstractOpenGLFunctions
-{
-public:
-    QOpenGLFunctions_4_1_Core();
-    ~QOpenGLFunctions_4_1_Core();
-
-    bool initializeOpenGLFunctions() override;
-
-    // OpenGL 1.0 core functions
-    void glViewport(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glDepthRange(GLdouble nearVal, GLdouble farVal);
-    GLboolean glIsEnabled(GLenum cap);
-    void glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params);
-    void glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params);
-    void glGetTexParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
-    const GLubyte * glGetString(GLenum name);
-    void glGetIntegerv(GLenum pname, GLint *params);
-    void glGetFloatv(GLenum pname, GLfloat *params);
-    GLenum glGetError();
-    void glGetDoublev(GLenum pname, GLdouble *params);
-    void glGetBooleanv(GLenum pname, GLboolean *params);
-    void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
-    void glReadBuffer(GLenum mode);
-    void glPixelStorei(GLenum pname, GLint param);
-    void glPixelStoref(GLenum pname, GLfloat param);
-    void glDepthFunc(GLenum func);
-    void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass);
-    void glStencilFunc(GLenum func, GLint ref, GLuint mask);
-    void glLogicOp(GLenum opcode);
-    void glBlendFunc(GLenum sfactor, GLenum dfactor);
-    void glFlush();
-    void glFinish();
-    void glEnable(GLenum cap);
-    void glDisable(GLenum cap);
-    void glDepthMask(GLboolean flag);
-    void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
-    void glStencilMask(GLuint mask);
-    void glClearDepth(GLdouble depth);
-    void glClearStencil(GLint s);
-    void glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glClear(GLbitfield mask);
-    void glDrawBuffer(GLenum mode);
-    void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glTexParameteri(GLenum target, GLenum pname, GLint param);
-    void glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glTexParameterf(GLenum target, GLenum pname, GLfloat param);
-    void glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glPolygonMode(GLenum face, GLenum mode);
-    void glPointSize(GLfloat size);
-    void glLineWidth(GLfloat width);
-    void glHint(GLenum target, GLenum mode);
-    void glFrontFace(GLenum mode);
-    void glCullFace(GLenum mode);
-
-    // OpenGL 1.1 core functions
-    void glIndexubv(const GLubyte *c);
-    void glIndexub(GLubyte c);
-    GLboolean glIsTexture(GLuint texture);
-    void glGenTextures(GLsizei n, GLuint *textures);
-    void glDeleteTextures(GLsizei n, const GLuint *textures);
-    void glBindTexture(GLenum target, GLuint texture);
-    void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
-    void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
-    void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
-    void glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
-    void glPolygonOffset(GLfloat factor, GLfloat units);
-    void glGetPointerv(GLenum pname, GLvoid* *params);
-    void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
-    void glDrawArrays(GLenum mode, GLint first, GLsizei count);
-
-    // OpenGL 1.2 core functions
-    void glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices);
-    void glBlendEquation(GLenum mode);
-    void glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-
-    // OpenGL 1.3 core functions
-    void glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img);
-    void glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glSampleCoverage(GLfloat value, GLboolean invert);
-    void glActiveTexture(GLenum texture);
-
-    // OpenGL 1.4 core functions
-    void glPointParameteriv(GLenum pname, const GLint *params);
-    void glPointParameteri(GLenum pname, GLint param);
-    void glPointParameterfv(GLenum pname, const GLfloat *params);
-    void glPointParameterf(GLenum pname, GLfloat param);
-    void glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount);
-    void glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount);
-    void glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
-
-    // OpenGL 1.5 core functions
-    void glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params);
-    void glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params);
-    GLboolean glUnmapBuffer(GLenum target);
-    GLvoid* glMapBuffer(GLenum target, GLenum access);
-    void glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data);
-    void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data);
-    void glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage);
-    GLboolean glIsBuffer(GLuint buffer);
-    void glGenBuffers(GLsizei n, GLuint *buffers);
-    void glDeleteBuffers(GLsizei n, const GLuint *buffers);
-    void glBindBuffer(GLenum target, GLuint buffer);
-    void glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params);
-    void glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params);
-    void glGetQueryiv(GLenum target, GLenum pname, GLint *params);
-    void glEndQuery(GLenum target);
-    void glBeginQuery(GLenum target, GLuint id);
-    GLboolean glIsQuery(GLuint id);
-    void glDeleteQueries(GLsizei n, const GLuint *ids);
-    void glGenQueries(GLsizei n, GLuint *ids);
-
-    // OpenGL 2.0 core functions
-    void glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer);
-    void glValidateProgram(GLuint program);
-    void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniform4iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform3iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform2iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform1iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform4fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform3fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform2fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform1fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
-    void glUniform3i(GLint location, GLint v0, GLint v1, GLint v2);
-    void glUniform2i(GLint location, GLint v0, GLint v1);
-    void glUniform1i(GLint location, GLint v0);
-    void glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
-    void glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
-    void glUniform2f(GLint location, GLfloat v0, GLfloat v1);
-    void glUniform1f(GLint location, GLfloat v0);
-    void glUseProgram(GLuint program);
-    void glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length);
-    void glLinkProgram(GLuint program);
-    GLboolean glIsShader(GLuint shader);
-    GLboolean glIsProgram(GLuint program);
-    void glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer);
-    void glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params);
-    void glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params);
-    void glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params);
-    void glGetUniformiv(GLuint program, GLint location, GLint *params);
-    void glGetUniformfv(GLuint program, GLint location, GLfloat *params);
-    GLint glGetUniformLocation(GLuint program, const GLchar *name);
-    void glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source);
-    void glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void glGetShaderiv(GLuint shader, GLenum pname, GLint *params);
-    void glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void glGetProgramiv(GLuint program, GLenum pname, GLint *params);
-    GLint glGetAttribLocation(GLuint program, const GLchar *name);
-    void glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj);
-    void glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
-    void glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
-    void glEnableVertexAttribArray(GLuint index);
-    void glDisableVertexAttribArray(GLuint index);
-    void glDetachShader(GLuint program, GLuint shader);
-    void glDeleteShader(GLuint shader);
-    void glDeleteProgram(GLuint program);
-    GLuint glCreateShader(GLenum type);
-    GLuint glCreateProgram();
-    void glCompileShader(GLuint shader);
-    void glBindAttribLocation(GLuint program, GLuint index, const GLchar *name);
-    void glAttachShader(GLuint program, GLuint shader);
-    void glStencilMaskSeparate(GLenum face, GLuint mask);
-    void glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask);
-    void glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);
-    void glDrawBuffers(GLsizei n, const GLenum *bufs);
-    void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha);
-
-    // OpenGL 2.1 core functions
-    void glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-
-    // OpenGL 3.0 core functions
-    GLboolean glIsVertexArray(GLuint array);
-    void glGenVertexArrays(GLsizei n, GLuint *arrays);
-    void glDeleteVertexArrays(GLsizei n, const GLuint *arrays);
-    void glBindVertexArray(GLuint array);
-    void glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length);
-    GLvoid* glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
-    void glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
-    void glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
-    void glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
-    void glGenerateMipmap(GLenum target);
-    void glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params);
-    void glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
-    void glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset);
-    void glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
-    void glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
-    GLenum glCheckFramebufferStatus(GLenum target);
-    void glGenFramebuffers(GLsizei n, GLuint *framebuffers);
-    void glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers);
-    void glBindFramebuffer(GLenum target, GLuint framebuffer);
-    GLboolean glIsFramebuffer(GLuint framebuffer);
-    void glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
-    void glGenRenderbuffers(GLsizei n, GLuint *renderbuffers);
-    void glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers);
-    void glBindRenderbuffer(GLenum target, GLuint renderbuffer);
-    GLboolean glIsRenderbuffer(GLuint renderbuffer);
-    const GLubyte * glGetStringi(GLenum name, GLuint index);
-    void glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
-    void glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value);
-    void glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value);
-    void glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value);
-    void glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params);
-    void glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params);
-    void glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params);
-    void glTexParameterIiv(GLenum target, GLenum pname, const GLint *params);
-    void glUniform4uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform3uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform2uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform1uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
-    void glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2);
-    void glUniform2ui(GLint location, GLuint v0, GLuint v1);
-    void glUniform1ui(GLint location, GLuint v0);
-    GLint glGetFragDataLocation(GLuint program, const GLchar *name);
-    void glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name);
-    void glGetUniformuiv(GLuint program, GLint location, GLuint *params);
-    void glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params);
-    void glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params);
-    void glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glEndConditionalRender();
-    void glBeginConditionalRender(GLuint id, GLenum mode);
-    void glClampColor(GLenum target, GLenum clamp);
-    void glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name);
-    void glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode);
-    void glBindBufferBase(GLenum target, GLuint index, GLuint buffer);
-    void glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
-    void glEndTransformFeedback();
-    void glBeginTransformFeedback(GLenum primitiveMode);
-    GLboolean glIsEnabledi(GLenum target, GLuint index);
-    void glDisablei(GLenum target, GLuint index);
-    void glEnablei(GLenum target, GLuint index);
-    void glGetIntegeri_v(GLenum target, GLuint index, GLint *data);
-    void glGetBooleani_v(GLenum target, GLuint index, GLboolean *data);
-    void glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a);
-
-    // OpenGL 3.1 core functions
-    void glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
-    void glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);
-    void glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName);
-    void glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params);
-    GLuint glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName);
-    void glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName);
-    void glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params);
-    void glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const *uniformNames, GLuint *uniformIndices);
-    void glPrimitiveRestartIndex(GLuint index);
-    void glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer);
-    void glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount);
-    void glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount);
-
-    // OpenGL 3.2 core functions
-    void glSampleMaski(GLuint index, GLbitfield mask);
-    void glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val);
-    void glTexImage3DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
-    void glTexImage2DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
-    void glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values);
-    void glGetInteger64v(GLenum pname, GLint64 *params);
-    void glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout);
-    GLenum glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout);
-    void glDeleteSync(GLsync sync);
-    GLboolean glIsSync(GLsync sync);
-    GLsync glFenceSync(GLenum condition, GLbitfield flags);
-    void glProvokingVertex(GLenum mode);
-    void glMultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount, const GLint *basevertex);
-    void glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount, GLint basevertex);
-    void glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex);
-    void glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex);
-    void glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level);
-    void glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params);
-    void glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data);
-
-    // OpenGL 3.3 core functions
-    void glVertexAttribP4uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glVertexAttribP3uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glVertexAttribP2uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glVertexAttribP1uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glSecondaryColorP3uiv(GLenum type, const GLuint *color);
-    void glSecondaryColorP3ui(GLenum type, GLuint color);
-    void glColorP4uiv(GLenum type, const GLuint *color);
-    void glColorP4ui(GLenum type, GLuint color);
-    void glColorP3uiv(GLenum type, const GLuint *color);
-    void glColorP3ui(GLenum type, GLuint color);
-    void glNormalP3uiv(GLenum type, const GLuint *coords);
-    void glNormalP3ui(GLenum type, GLuint coords);
-    void glMultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint *coords);
-    void glMultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords);
-    void glMultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint *coords);
-    void glMultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords);
-    void glMultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint *coords);
-    void glMultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords);
-    void glMultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint *coords);
-    void glMultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords);
-    void glTexCoordP4uiv(GLenum type, const GLuint *coords);
-    void glTexCoordP4ui(GLenum type, GLuint coords);
-    void glTexCoordP3uiv(GLenum type, const GLuint *coords);
-    void glTexCoordP3ui(GLenum type, GLuint coords);
-    void glTexCoordP2uiv(GLenum type, const GLuint *coords);
-    void glTexCoordP2ui(GLenum type, GLuint coords);
-    void glTexCoordP1uiv(GLenum type, const GLuint *coords);
-    void glTexCoordP1ui(GLenum type, GLuint coords);
-    void glVertexP4uiv(GLenum type, const GLuint *value);
-    void glVertexP4ui(GLenum type, GLuint value);
-    void glVertexP3uiv(GLenum type, const GLuint *value);
-    void glVertexP3ui(GLenum type, GLuint value);
-    void glVertexP2uiv(GLenum type, const GLuint *value);
-    void glVertexP2ui(GLenum type, GLuint value);
-    void glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params);
-    void glGetQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params);
-    void glQueryCounter(GLuint id, GLenum target);
-    void glGetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params);
-    void glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params);
-    void glGetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params);
-    void glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params);
-    void glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param);
-    void glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param);
-    void glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param);
-    void glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param);
-    void glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param);
-    void glSamplerParameteri(GLuint sampler, GLenum pname, GLint param);
-    void glBindSampler(GLuint unit, GLuint sampler);
-    GLboolean glIsSampler(GLuint sampler);
-    void glDeleteSamplers(GLsizei count, const GLuint *samplers);
-    void glGenSamplers(GLsizei count, GLuint *samplers);
-    GLint glGetFragDataIndex(GLuint program, const GLchar *name);
-    void glBindFragDataLocationIndexed(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name);
-    void glVertexAttribDivisor(GLuint index, GLuint divisor);
-
-    // OpenGL 4.0 core functions
-    void glGetQueryIndexediv(GLenum target, GLuint index, GLenum pname, GLint *params);
-    void glEndQueryIndexed(GLenum target, GLuint index);
-    void glBeginQueryIndexed(GLenum target, GLuint index, GLuint id);
-    void glDrawTransformFeedbackStream(GLenum mode, GLuint id, GLuint stream);
-    void glDrawTransformFeedback(GLenum mode, GLuint id);
-    void glResumeTransformFeedback();
-    void glPauseTransformFeedback();
-    GLboolean glIsTransformFeedback(GLuint id);
-    void glGenTransformFeedbacks(GLsizei n, GLuint *ids);
-    void glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids);
-    void glBindTransformFeedback(GLenum target, GLuint id);
-    void glPatchParameterfv(GLenum pname, const GLfloat *values);
-    void glPatchParameteri(GLenum pname, GLint value);
-    void glGetProgramStageiv(GLuint program, GLenum shadertype, GLenum pname, GLint *values);
-    void glGetUniformSubroutineuiv(GLenum shadertype, GLint location, GLuint *params);
-    void glUniformSubroutinesuiv(GLenum shadertype, GLsizei count, const GLuint *indices);
-    void glGetActiveSubroutineName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name);
-    void glGetActiveSubroutineUniformName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name);
-    void glGetActiveSubroutineUniformiv(GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values);
-    GLuint glGetSubroutineIndex(GLuint program, GLenum shadertype, const GLchar *name);
-    GLint glGetSubroutineUniformLocation(GLuint program, GLenum shadertype, const GLchar *name);
-    void glGetUniformdv(GLuint program, GLint location, GLdouble *params);
-    void glUniformMatrix4x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix4x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix3x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix3x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix2x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix2x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniform4dv(GLint location, GLsizei count, const GLdouble *value);
-    void glUniform3dv(GLint location, GLsizei count, const GLdouble *value);
-    void glUniform2dv(GLint location, GLsizei count, const GLdouble *value);
-    void glUniform1dv(GLint location, GLsizei count, const GLdouble *value);
-    void glUniform4d(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glUniform3d(GLint location, GLdouble x, GLdouble y, GLdouble z);
-    void glUniform2d(GLint location, GLdouble x, GLdouble y);
-    void glUniform1d(GLint location, GLdouble x);
-    void glDrawElementsIndirect(GLenum mode, GLenum type, const GLvoid *indirect);
-    void glDrawArraysIndirect(GLenum mode, const GLvoid *indirect);
-    void glBlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
-    void glBlendFunci(GLuint buf, GLenum src, GLenum dst);
-    void glBlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha);
-    void glBlendEquationi(GLuint buf, GLenum mode);
-    void glMinSampleShading(GLfloat value);
-
-    // OpenGL 4.1 core functions
-    void glGetDoublei_v(GLenum target, GLuint index, GLdouble *data);
-    void glGetFloati_v(GLenum target, GLuint index, GLfloat *data);
-    void glDepthRangeIndexed(GLuint index, GLdouble n, GLdouble f);
-    void glDepthRangeArrayv(GLuint first, GLsizei count, const GLdouble *v);
-    void glScissorIndexedv(GLuint index, const GLint *v);
-    void glScissorIndexed(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height);
-    void glScissorArrayv(GLuint first, GLsizei count, const GLint *v);
-    void glViewportIndexedfv(GLuint index, const GLfloat *v);
-    void glViewportIndexedf(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h);
-    void glViewportArrayv(GLuint first, GLsizei count, const GLfloat *v);
-    void glGetVertexAttribLdv(GLuint index, GLenum pname, GLdouble *params);
-    void glVertexAttribLPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glVertexAttribL4dv(GLuint index, const GLdouble *v);
-    void glVertexAttribL3dv(GLuint index, const GLdouble *v);
-    void glVertexAttribL2dv(GLuint index, const GLdouble *v);
-    void glVertexAttribL1dv(GLuint index, const GLdouble *v);
-    void glVertexAttribL4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glVertexAttribL3d(GLuint index, GLdouble x, GLdouble y, GLdouble z);
-    void glVertexAttribL2d(GLuint index, GLdouble x, GLdouble y);
-    void glVertexAttribL1d(GLuint index, GLdouble x);
-    void glGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void glValidateProgramPipeline(GLuint pipeline);
-    void glProgramUniformMatrix4x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix3x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix4x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix2x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix3x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix2x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix4x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix3x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix4x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix2x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix3x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix2x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniform4uiv(GLuint program, GLint location, GLsizei count, const GLuint *value);
-    void glProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
-    void glProgramUniform4dv(GLuint program, GLint location, GLsizei count, const GLdouble *value);
-    void glProgramUniform4d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3);
-    void glProgramUniform4fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-    void glProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
-    void glProgramUniform4iv(GLuint program, GLint location, GLsizei count, const GLint *value);
-    void glProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
-    void glProgramUniform3uiv(GLuint program, GLint location, GLsizei count, const GLuint *value);
-    void glProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2);
-    void glProgramUniform3dv(GLuint program, GLint location, GLsizei count, const GLdouble *value);
-    void glProgramUniform3d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2);
-    void glProgramUniform3fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-    void glProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
-    void glProgramUniform3iv(GLuint program, GLint location, GLsizei count, const GLint *value);
-    void glProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2);
-    void glProgramUniform2uiv(GLuint program, GLint location, GLsizei count, const GLuint *value);
-    void glProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1);
-    void glProgramUniform2dv(GLuint program, GLint location, GLsizei count, const GLdouble *value);
-    void glProgramUniform2d(GLuint program, GLint location, GLdouble v0, GLdouble v1);
-    void glProgramUniform2fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-    void glProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1);
-    void glProgramUniform2iv(GLuint program, GLint location, GLsizei count, const GLint *value);
-    void glProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1);
-    void glProgramUniform1uiv(GLuint program, GLint location, GLsizei count, const GLuint *value);
-    void glProgramUniform1ui(GLuint program, GLint location, GLuint v0);
-    void glProgramUniform1dv(GLuint program, GLint location, GLsizei count, const GLdouble *value);
-    void glProgramUniform1d(GLuint program, GLint location, GLdouble v0);
-    void glProgramUniform1fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-    void glProgramUniform1f(GLuint program, GLint location, GLfloat v0);
-    void glProgramUniform1iv(GLuint program, GLint location, GLsizei count, const GLint *value);
-    void glProgramUniform1i(GLuint program, GLint location, GLint v0);
-    void glGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params);
-    GLboolean glIsProgramPipeline(GLuint pipeline);
-    void glGenProgramPipelines(GLsizei n, GLuint *pipelines);
-    void glDeleteProgramPipelines(GLsizei n, const GLuint *pipelines);
-    void glBindProgramPipeline(GLuint pipeline);
-    GLuint glCreateShaderProgramv(GLenum type, GLsizei count, const GLchar* const *strings);
-    void glActiveShaderProgram(GLuint pipeline, GLuint program);
-    void glUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program);
-    void glProgramParameteri(GLuint program, GLenum pname, GLint value);
-    void glProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid *binary, GLsizei length);
-    void glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, GLvoid *binary);
-    void glClearDepthf(GLfloat dd);
-    void glDepthRangef(GLfloat n, GLfloat f);
-    void glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision);
-    void glShaderBinary(GLsizei count, const GLuint *shaders, GLenum binaryformat, const GLvoid *binary, GLsizei length);
-    void glReleaseShaderCompiler();
-
-private:
-    friend class QOpenGLContext;
-
-    static bool isContextCompatible(QOpenGLContext *context);
-    static QOpenGLVersionProfile versionProfile();
-
-    QOpenGLFunctions_1_0_CoreBackend* d_1_0_Core;
-    QOpenGLFunctions_1_1_CoreBackend* d_1_1_Core;
-    QOpenGLFunctions_1_2_CoreBackend* d_1_2_Core;
-    QOpenGLFunctions_1_3_CoreBackend* d_1_3_Core;
-    QOpenGLFunctions_1_4_CoreBackend* d_1_4_Core;
-    QOpenGLFunctions_1_5_CoreBackend* d_1_5_Core;
-    QOpenGLFunctions_2_0_CoreBackend* d_2_0_Core;
-    QOpenGLFunctions_2_1_CoreBackend* d_2_1_Core;
-    QOpenGLFunctions_3_0_CoreBackend* d_3_0_Core;
-    QOpenGLFunctions_3_1_CoreBackend* d_3_1_Core;
-    QOpenGLFunctions_3_2_CoreBackend* d_3_2_Core;
-    QOpenGLFunctions_3_3_CoreBackend* d_3_3_Core;
-    QOpenGLFunctions_4_0_CoreBackend* d_4_0_Core;
-    QOpenGLFunctions_4_1_CoreBackend* d_4_1_Core;
-};
-
-// OpenGL 1.0 core functions
-inline void QOpenGLFunctions_4_1_Core::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_0_Core->f.Viewport(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glDepthRange(GLdouble nearVal, GLdouble farVal)
-{
-    d_1_0_Core->f.DepthRange(nearVal, farVal);
-}
-
-inline GLboolean QOpenGLFunctions_4_1_Core::glIsEnabled(GLenum cap)
-{
-    return d_1_0_Core->f.IsEnabled(cap);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetTexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetTexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
-{
-    d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
-}
-
-inline const GLubyte * QOpenGLFunctions_4_1_Core::glGetString(GLenum name)
-{
-    return d_1_0_Core->f.GetString(name);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetIntegerv(GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetIntegerv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetFloatv(GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetFloatv(pname, params);
-}
-
-inline GLenum QOpenGLFunctions_4_1_Core::glGetError()
-{
-    return d_1_0_Core->f.GetError();
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetDoublev(GLenum pname, GLdouble *params)
-{
-    d_1_0_Core->f.GetDoublev(pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetBooleanv(GLenum pname, GLboolean *params)
-{
-    d_1_0_Core->f.GetBooleanv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
-{
-    d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glReadBuffer(GLenum mode)
-{
-    d_1_0_Core->f.ReadBuffer(mode);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glPixelStorei(GLenum pname, GLint param)
-{
-    d_1_0_Core->f.PixelStorei(pname, param);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glPixelStoref(GLenum pname, GLfloat param)
-{
-    d_1_0_Core->f.PixelStoref(pname, param);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glDepthFunc(GLenum func)
-{
-    d_1_0_Core->f.DepthFunc(func);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
-{
-    d_1_0_Core->f.StencilOp(fail, zfail, zpass);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glStencilFunc(GLenum func, GLint ref, GLuint mask)
-{
-    d_1_0_Core->f.StencilFunc(func, ref, mask);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glLogicOp(GLenum opcode)
-{
-    d_1_0_Core->f.LogicOp(opcode);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glBlendFunc(GLenum sfactor, GLenum dfactor)
-{
-    d_1_0_Core->f.BlendFunc(sfactor, dfactor);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glFlush()
-{
-    d_1_0_Core->f.Flush();
-}
-
-inline void QOpenGLFunctions_4_1_Core::glFinish()
-{
-    d_1_0_Core->f.Finish();
-}
-
-inline void QOpenGLFunctions_4_1_Core::glEnable(GLenum cap)
-{
-    d_1_0_Core->f.Enable(cap);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glDisable(GLenum cap)
-{
-    d_1_0_Core->f.Disable(cap);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glDepthMask(GLboolean flag)
-{
-    d_1_0_Core->f.DepthMask(flag);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
-{
-    d_1_0_Core->f.ColorMask(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glStencilMask(GLuint mask)
-{
-    d_1_0_Core->f.StencilMask(mask);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glClearDepth(GLdouble depth)
-{
-    d_1_0_Core->f.ClearDepth(depth);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glClearStencil(GLint s)
-{
-    d_1_0_Core->f.ClearStencil(s);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Core->f.ClearColor(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glClear(GLbitfield mask)
-{
-    d_1_0_Core->f.Clear(mask);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glDrawBuffer(GLenum mode)
-{
-    d_1_0_Core->f.DrawBuffer(mode);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Core->f.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Core->f.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_0_Core->f.TexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glTexParameteri(GLenum target, GLenum pname, GLint param)
-{
-    d_1_0_Core->f.TexParameteri(target, pname, param);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Core->f.TexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
-{
-    d_1_0_Core->f.TexParameterf(target, pname, param);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_0_Core->f.Scissor(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glPolygonMode(GLenum face, GLenum mode)
-{
-    d_1_0_Core->f.PolygonMode(face, mode);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glPointSize(GLfloat size)
-{
-    d_1_0_Core->f.PointSize(size);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glLineWidth(GLfloat width)
-{
-    d_1_0_Core->f.LineWidth(width);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glHint(GLenum target, GLenum mode)
-{
-    d_1_0_Core->f.Hint(target, mode);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glFrontFace(GLenum mode)
-{
-    d_1_0_Core->f.FrontFace(mode);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glCullFace(GLenum mode)
-{
-    d_1_0_Core->f.CullFace(mode);
-}
-
-
-// OpenGL 1.1 core functions
-inline void QOpenGLFunctions_4_1_Core::glIndexubv(const GLubyte *c)
-{
-    Q_UNUSED(c);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_1_Core::glIndexub(GLubyte c)
-{
-    Q_UNUSED(c);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline GLboolean QOpenGLFunctions_4_1_Core::glIsTexture(GLuint texture)
-{
-    return d_1_1_Core->f.IsTexture(texture);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGenTextures(GLsizei n, GLuint *textures)
-{
-    d_1_1_Core->f.GenTextures(n, textures);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glDeleteTextures(GLsizei n, const GLuint *textures)
-{
-    d_1_1_Core->f.DeleteTextures(n, textures);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glBindTexture(GLenum target, GLuint texture)
-{
-    d_1_1_Core->f.BindTexture(target, texture);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_1_Core->f.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_1_Core->f.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_1_Core->f.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
-{
-    d_1_1_Core->f.CopyTexSubImage1D(target, level, xoffset, x, y, width);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
-{
-    d_1_1_Core->f.CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
-{
-    d_1_1_Core->f.CopyTexImage1D(target, level, internalformat, x, y, width, border);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glPolygonOffset(GLfloat factor, GLfloat units)
-{
-    d_1_1_Core->f.PolygonOffset(factor, units);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetPointerv(GLenum pname, GLvoid* *params)
-{
-    Q_UNUSED(pname);
-    Q_UNUSED(params);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_1_Core::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
-{
-    d_1_1_Core->f.DrawElements(mode, count, type, indices);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glDrawArrays(GLenum mode, GLint first, GLsizei count)
-{
-    d_1_1_Core->f.DrawArrays(mode, first, count);
-}
-
-
-// OpenGL 1.2 core functions
-inline void QOpenGLFunctions_4_1_Core::glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_2_Core->f.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_2_Core->f.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_2_Core->f.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
-{
-    d_1_2_Core->f.DrawRangeElements(mode, start, end, count, type, indices);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glBlendEquation(GLenum mode)
-{
-    d_1_2_Core->f.BlendEquation(mode);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_2_Core->f.BlendColor(red, green, blue, alpha);
-}
-
-
-// OpenGL 1.3 core functions
-inline void QOpenGLFunctions_4_1_Core::glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img)
-{
-    d_1_3_Core->f.GetCompressedTexImage(target, level, img);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glSampleCoverage(GLfloat value, GLboolean invert)
-{
-    d_1_3_Core->f.SampleCoverage(value, invert);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glActiveTexture(GLenum texture)
-{
-    d_1_3_Core->f.ActiveTexture(texture);
-}
-
-
-// OpenGL 1.4 core functions
-inline void QOpenGLFunctions_4_1_Core::glPointParameteriv(GLenum pname, const GLint *params)
-{
-    d_1_4_Core->f.PointParameteriv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glPointParameteri(GLenum pname, GLint param)
-{
-    d_1_4_Core->f.PointParameteri(pname, param);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glPointParameterfv(GLenum pname, const GLfloat *params)
-{
-    d_1_4_Core->f.PointParameterfv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glPointParameterf(GLenum pname, GLfloat param)
-{
-    d_1_4_Core->f.PointParameterf(pname, param);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount)
-{
-    d_1_4_Core->f.MultiDrawElements(mode, count, type, indices, drawcount);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
-{
-    d_1_4_Core->f.MultiDrawArrays(mode, first, count, drawcount);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
-{
-    d_1_4_Core->f.BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
-}
-
-
-// OpenGL 1.5 core functions
-inline void QOpenGLFunctions_4_1_Core::glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params)
-{
-    d_1_5_Core->f.GetBufferPointerv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetBufferParameteriv(target, pname, params);
-}
-
-inline GLboolean QOpenGLFunctions_4_1_Core::glUnmapBuffer(GLenum target)
-{
-    return d_1_5_Core->f.UnmapBuffer(target);
-}
-
-inline GLvoid* QOpenGLFunctions_4_1_Core::glMapBuffer(GLenum target, GLenum access)
-{
-    return d_1_5_Core->f.MapBuffer(target, access);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data)
-{
-    d_1_5_Core->f.GetBufferSubData(target, offset, size, data);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data)
-{
-    d_1_5_Core->f.BufferSubData(target, offset, size, data);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)
-{
-    d_1_5_Core->f.BufferData(target, size, data, usage);
-}
-
-inline GLboolean QOpenGLFunctions_4_1_Core::glIsBuffer(GLuint buffer)
-{
-    return d_1_5_Core->f.IsBuffer(buffer);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGenBuffers(GLsizei n, GLuint *buffers)
-{
-    d_1_5_Core->f.GenBuffers(n, buffers);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glDeleteBuffers(GLsizei n, const GLuint *buffers)
-{
-    d_1_5_Core->f.DeleteBuffers(n, buffers);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glBindBuffer(GLenum target, GLuint buffer)
-{
-    d_1_5_Core->f.BindBuffer(target, buffer);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
-{
-    d_1_5_Core->f.GetQueryObjectuiv(id, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetQueryObjectiv(id, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetQueryiv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetQueryiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glEndQuery(GLenum target)
-{
-    d_1_5_Core->f.EndQuery(target);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glBeginQuery(GLenum target, GLuint id)
-{
-    d_1_5_Core->f.BeginQuery(target, id);
-}
-
-inline GLboolean QOpenGLFunctions_4_1_Core::glIsQuery(GLuint id)
-{
-    return d_1_5_Core->f.IsQuery(id);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glDeleteQueries(GLsizei n, const GLuint *ids)
-{
-    d_1_5_Core->f.DeleteQueries(n, ids);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGenQueries(GLsizei n, GLuint *ids)
-{
-    d_1_5_Core->f.GenQueries(n, ids);
-}
-
-
-// OpenGL 2.0 core functions
-inline void QOpenGLFunctions_4_1_Core::glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer)
-{
-    d_2_0_Core->f.VertexAttribPointer(index, size, type, normalized, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glValidateProgram(GLuint program)
-{
-    d_2_0_Core->f.ValidateProgram(program);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix3fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUniform4iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform4iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUniform3iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform3iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUniform2iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform2iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUniform1iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform1iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUniform4fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform4fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUniform3fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform3fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUniform2fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform2fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUniform1fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform1fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
-{
-    d_2_0_Core->f.Uniform4i(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUniform3i(GLint location, GLint v0, GLint v1, GLint v2)
-{
-    d_2_0_Core->f.Uniform3i(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUniform2i(GLint location, GLint v0, GLint v1)
-{
-    d_2_0_Core->f.Uniform2i(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUniform1i(GLint location, GLint v0)
-{
-    d_2_0_Core->f.Uniform1i(location, v0);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
-{
-    d_2_0_Core->f.Uniform4f(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
-{
-    d_2_0_Core->f.Uniform3f(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUniform2f(GLint location, GLfloat v0, GLfloat v1)
-{
-    d_2_0_Core->f.Uniform2f(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUniform1f(GLint location, GLfloat v0)
-{
-    d_2_0_Core->f.Uniform1f(location, v0);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUseProgram(GLuint program)
-{
-    d_2_0_Core->f.UseProgram(program);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length)
-{
-    d_2_0_Core->f.ShaderSource(shader, count, string, length);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glLinkProgram(GLuint program)
-{
-    d_2_0_Core->f.LinkProgram(program);
-}
-
-inline GLboolean QOpenGLFunctions_4_1_Core::glIsShader(GLuint shader)
-{
-    return d_2_0_Core->f.IsShader(shader);
-}
-
-inline GLboolean QOpenGLFunctions_4_1_Core::glIsProgram(GLuint program)
-{
-    return d_2_0_Core->f.IsProgram(program);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer)
-{
-    d_2_0_Core->f.GetVertexAttribPointerv(index, pname, pointer);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetVertexAttribiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
-{
-    d_2_0_Core->f.GetVertexAttribfv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
-{
-    d_2_0_Core->f.GetVertexAttribdv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetUniformiv(GLuint program, GLint location, GLint *params)
-{
-    d_2_0_Core->f.GetUniformiv(program, location, params);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetUniformfv(GLuint program, GLint location, GLfloat *params)
-{
-    d_2_0_Core->f.GetUniformfv(program, location, params);
-}
-
-inline GLint QOpenGLFunctions_4_1_Core::glGetUniformLocation(GLuint program, const GLchar *name)
-{
-    return d_2_0_Core->f.GetUniformLocation(program, name);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
-{
-    d_2_0_Core->f.GetShaderSource(shader, bufSize, length, source);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-{
-    d_2_0_Core->f.GetShaderInfoLog(shader, bufSize, length, infoLog);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetShaderiv(GLuint shader, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetShaderiv(shader, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-{
-    d_2_0_Core->f.GetProgramInfoLog(program, bufSize, length, infoLog);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetProgramiv(GLuint program, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetProgramiv(program, pname, params);
-}
-
-inline GLint QOpenGLFunctions_4_1_Core::glGetAttribLocation(GLuint program, const GLchar *name)
-{
-    return d_2_0_Core->f.GetAttribLocation(program, name);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj)
-{
-    d_2_0_Core->f.GetAttachedShaders(program, maxCount, count, obj);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
-{
-    d_2_0_Core->f.GetActiveUniform(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
-{
-    d_2_0_Core->f.GetActiveAttrib(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glEnableVertexAttribArray(GLuint index)
-{
-    d_2_0_Core->f.EnableVertexAttribArray(index);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glDisableVertexAttribArray(GLuint index)
-{
-    d_2_0_Core->f.DisableVertexAttribArray(index);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glDetachShader(GLuint program, GLuint shader)
-{
-    d_2_0_Core->f.DetachShader(program, shader);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glDeleteShader(GLuint shader)
-{
-    d_2_0_Core->f.DeleteShader(shader);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glDeleteProgram(GLuint program)
-{
-    d_2_0_Core->f.DeleteProgram(program);
-}
-
-inline GLuint QOpenGLFunctions_4_1_Core::glCreateShader(GLenum type)
-{
-    return d_2_0_Core->f.CreateShader(type);
-}
-
-inline GLuint QOpenGLFunctions_4_1_Core::glCreateProgram()
-{
-    return d_2_0_Core->f.CreateProgram();
-}
-
-inline void QOpenGLFunctions_4_1_Core::glCompileShader(GLuint shader)
-{
-    d_2_0_Core->f.CompileShader(shader);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glBindAttribLocation(GLuint program, GLuint index, const GLchar *name)
-{
-    d_2_0_Core->f.BindAttribLocation(program, index, name);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glAttachShader(GLuint program, GLuint shader)
-{
-    d_2_0_Core->f.AttachShader(program, shader);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glStencilMaskSeparate(GLenum face, GLuint mask)
-{
-    d_2_0_Core->f.StencilMaskSeparate(face, mask);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
-{
-    d_2_0_Core->f.StencilFuncSeparate(face, func, ref, mask);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
-{
-    d_2_0_Core->f.StencilOpSeparate(face, sfail, dpfail, dppass);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glDrawBuffers(GLsizei n, const GLenum *bufs)
-{
-    d_2_0_Core->f.DrawBuffers(n, bufs);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
-{
-    d_2_0_Core->f.BlendEquationSeparate(modeRGB, modeAlpha);
-}
-
-
-// OpenGL 2.1 core functions
-inline void QOpenGLFunctions_4_1_Core::glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix4x3fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix3x4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix4x2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix2x4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix3x2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix2x3fv(location, count, transpose, value);
-}
-
-
-// OpenGL 3.0 core functions
-inline GLboolean QOpenGLFunctions_4_1_Core::glIsVertexArray(GLuint array)
-{
-    return d_3_0_Core->f.IsVertexArray(array);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGenVertexArrays(GLsizei n, GLuint *arrays)
-{
-    d_3_0_Core->f.GenVertexArrays(n, arrays);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glDeleteVertexArrays(GLsizei n, const GLuint *arrays)
-{
-    d_3_0_Core->f.DeleteVertexArrays(n, arrays);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glBindVertexArray(GLuint array)
-{
-    d_3_0_Core->f.BindVertexArray(array);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
-{
-    d_3_0_Core->f.FlushMappedBufferRange(target, offset, length);
-}
-
-inline GLvoid* QOpenGLFunctions_4_1_Core::glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
-{
-    return d_3_0_Core->f.MapBufferRange(target, offset, length, access);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
-{
-    d_3_0_Core->f.FramebufferTextureLayer(target, attachment, texture, level, layer);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    d_3_0_Core->f.RenderbufferStorageMultisample(target, samples, internalformat, width, height);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
-{
-    d_3_0_Core->f.BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGenerateMipmap(GLenum target)
-{
-    d_3_0_Core->f.GenerateMipmap(target);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
-{
-    d_3_0_Core->f.FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
-{
-    d_3_0_Core->f.FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
-{
-    d_3_0_Core->f.FramebufferTexture2D(target, attachment, textarget, texture, level);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
-{
-    d_3_0_Core->f.FramebufferTexture1D(target, attachment, textarget, texture, level);
-}
-
-inline GLenum QOpenGLFunctions_4_1_Core::glCheckFramebufferStatus(GLenum target)
-{
-    return d_3_0_Core->f.CheckFramebufferStatus(target);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGenFramebuffers(GLsizei n, GLuint *framebuffers)
-{
-    d_3_0_Core->f.GenFramebuffers(n, framebuffers);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
-{
-    d_3_0_Core->f.DeleteFramebuffers(n, framebuffers);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glBindFramebuffer(GLenum target, GLuint framebuffer)
-{
-    d_3_0_Core->f.BindFramebuffer(target, framebuffer);
-}
-
-inline GLboolean QOpenGLFunctions_4_1_Core::glIsFramebuffer(GLuint framebuffer)
-{
-    return d_3_0_Core->f.IsFramebuffer(framebuffer);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetRenderbufferParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    d_3_0_Core->f.RenderbufferStorage(target, internalformat, width, height);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGenRenderbuffers(GLsizei n, GLuint *renderbuffers)
-{
-    d_3_0_Core->f.GenRenderbuffers(n, renderbuffers);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
-{
-    d_3_0_Core->f.DeleteRenderbuffers(n, renderbuffers);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glBindRenderbuffer(GLenum target, GLuint renderbuffer)
-{
-    d_3_0_Core->f.BindRenderbuffer(target, renderbuffer);
-}
-
-inline GLboolean QOpenGLFunctions_4_1_Core::glIsRenderbuffer(GLuint renderbuffer)
-{
-    return d_3_0_Core->f.IsRenderbuffer(renderbuffer);
-}
-
-inline const GLubyte * QOpenGLFunctions_4_1_Core::glGetStringi(GLenum name, GLuint index)
-{
-    return d_3_0_Core->f.GetStringi(name, index);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
-{
-    d_3_0_Core->f.ClearBufferfi(buffer, drawbuffer, depth, stencil);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
-{
-    d_3_0_Core->f.ClearBufferfv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
-{
-    d_3_0_Core->f.ClearBufferuiv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
-{
-    d_3_0_Core->f.ClearBufferiv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params)
-{
-    d_3_0_Core->f.GetTexParameterIuiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetTexParameterIiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params)
-{
-    d_3_0_Core->f.TexParameterIuiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glTexParameterIiv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_3_0_Core->f.TexParameterIiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUniform4uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform4uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUniform3uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform3uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUniform2uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform2uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUniform1uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform1uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
-{
-    d_3_0_Core->f.Uniform4ui(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
-{
-    d_3_0_Core->f.Uniform3ui(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUniform2ui(GLint location, GLuint v0, GLuint v1)
-{
-    d_3_0_Core->f.Uniform2ui(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUniform1ui(GLint location, GLuint v0)
-{
-    d_3_0_Core->f.Uniform1ui(location, v0);
-}
-
-inline GLint QOpenGLFunctions_4_1_Core::glGetFragDataLocation(GLuint program, const GLchar *name)
-{
-    return d_3_0_Core->f.GetFragDataLocation(program, name);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name)
-{
-    d_3_0_Core->f.BindFragDataLocation(program, color, name);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetUniformuiv(GLuint program, GLint location, GLuint *params)
-{
-    d_3_0_Core->f.GetUniformuiv(program, location, params);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
-{
-    d_3_0_Core->f.GetVertexAttribIuiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetVertexAttribIiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_3_0_Core->f.VertexAttribIPointer(index, size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glEndConditionalRender()
-{
-    d_3_0_Core->f.EndConditionalRender();
-}
-
-inline void QOpenGLFunctions_4_1_Core::glBeginConditionalRender(GLuint id, GLenum mode)
-{
-    d_3_0_Core->f.BeginConditionalRender(id, mode);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glClampColor(GLenum target, GLenum clamp)
-{
-    d_3_0_Core->f.ClampColor(target, clamp);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
-{
-    d_3_0_Core->f.GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode)
-{
-    d_3_0_Core->f.TransformFeedbackVaryings(program, count, varyings, bufferMode);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
-{
-    d_3_0_Core->f.BindBufferBase(target, index, buffer);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
-{
-    d_3_0_Core->f.BindBufferRange(target, index, buffer, offset, size);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glEndTransformFeedback()
-{
-    d_3_0_Core->f.EndTransformFeedback();
-}
-
-inline void QOpenGLFunctions_4_1_Core::glBeginTransformFeedback(GLenum primitiveMode)
-{
-    d_3_0_Core->f.BeginTransformFeedback(primitiveMode);
-}
-
-inline GLboolean QOpenGLFunctions_4_1_Core::glIsEnabledi(GLenum target, GLuint index)
-{
-    return d_3_0_Core->f.IsEnabledi(target, index);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glDisablei(GLenum target, GLuint index)
-{
-    d_3_0_Core->f.Disablei(target, index);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glEnablei(GLenum target, GLuint index)
-{
-    d_3_0_Core->f.Enablei(target, index);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetIntegeri_v(GLenum target, GLuint index, GLint *data)
-{
-    d_3_0_Core->f.GetIntegeri_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetBooleani_v(GLenum target, GLuint index, GLboolean *data)
-{
-    d_3_0_Core->f.GetBooleani_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
-{
-    d_3_0_Core->f.ColorMaski(index, r, g, b, a);
-}
-
-
-// OpenGL 3.1 core functions
-inline void QOpenGLFunctions_4_1_Core::glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
-{
-    d_3_1_Core->f.CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
-{
-    d_3_1_Core->f.UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
-{
-    d_3_1_Core->f.GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params)
-{
-    d_3_1_Core->f.GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
-}
-
-inline GLuint QOpenGLFunctions_4_1_Core::glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName)
-{
-    return d_3_1_Core->f.GetUniformBlockIndex(program, uniformBlockName);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName)
-{
-    d_3_1_Core->f.GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params)
-{
-    d_3_1_Core->f.GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const *uniformNames, GLuint *uniformIndices)
-{
-    d_3_1_Core->f.GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glPrimitiveRestartIndex(GLuint index)
-{
-    d_3_1_Core->f.PrimitiveRestartIndex(index);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer)
-{
-    d_3_1_Core->f.TexBuffer(target, internalformat, buffer);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount)
-{
-    d_3_1_Core->f.DrawElementsInstanced(mode, count, type, indices, instancecount);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount)
-{
-    d_3_1_Core->f.DrawArraysInstanced(mode, first, count, instancecount);
-}
-
-
-// OpenGL 3.2 core functions
-inline void QOpenGLFunctions_4_1_Core::glSampleMaski(GLuint index, GLbitfield mask)
-{
-    d_3_2_Core->f.SampleMaski(index, mask);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val)
-{
-    d_3_2_Core->f.GetMultisamplefv(pname, index, val);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glTexImage3DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
-{
-    d_3_2_Core->f.TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glTexImage2DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
-{
-    d_3_2_Core->f.TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values)
-{
-    d_3_2_Core->f.GetSynciv(sync, pname, bufSize, length, values);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetInteger64v(GLenum pname, GLint64 *params)
-{
-    d_3_2_Core->f.GetInteger64v(pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
-{
-    d_3_2_Core->f.WaitSync(sync, flags, timeout);
-}
-
-inline GLenum QOpenGLFunctions_4_1_Core::glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
-{
-    return d_3_2_Core->f.ClientWaitSync(sync, flags, timeout);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glDeleteSync(GLsync sync)
-{
-    d_3_2_Core->f.DeleteSync(sync);
-}
-
-inline GLboolean QOpenGLFunctions_4_1_Core::glIsSync(GLsync sync)
-{
-    return d_3_2_Core->f.IsSync(sync);
-}
-
-inline GLsync QOpenGLFunctions_4_1_Core::glFenceSync(GLenum condition, GLbitfield flags)
-{
-    return d_3_2_Core->f.FenceSync(condition, flags);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProvokingVertex(GLenum mode)
-{
-    d_3_2_Core->f.ProvokingVertex(mode);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glMultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount, const GLint *basevertex)
-{
-    d_3_2_Core->f.MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount, GLint basevertex)
-{
-    d_3_2_Core->f.DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)
-{
-    d_3_2_Core->f.DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)
-{
-    d_3_2_Core->f.DrawElementsBaseVertex(mode, count, type, indices, basevertex);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level)
-{
-    d_3_2_Core->f.FramebufferTexture(target, attachment, texture, level);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params)
-{
-    d_3_2_Core->f.GetBufferParameteri64v(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data)
-{
-    d_3_2_Core->f.GetInteger64i_v(target, index, data);
-}
-
-
-// OpenGL 3.3 core functions
-inline void QOpenGLFunctions_4_1_Core::glVertexAttribP4uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP4uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glVertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP4ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glVertexAttribP3uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP3uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glVertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP3ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glVertexAttribP2uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP2uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glVertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP2ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glVertexAttribP1uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP1uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glVertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP1ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glSecondaryColorP3uiv(GLenum type, const GLuint *color)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(color);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_1_Core::glSecondaryColorP3ui(GLenum type, GLuint color)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(color);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_1_Core::glColorP4uiv(GLenum type, const GLuint *color)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(color);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_1_Core::glColorP4ui(GLenum type, GLuint color)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(color);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_1_Core::glColorP3uiv(GLenum type, const GLuint *color)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(color);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_1_Core::glColorP3ui(GLenum type, GLuint color)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(color);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_1_Core::glNormalP3uiv(GLenum type, const GLuint *coords)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_1_Core::glNormalP3ui(GLenum type, GLuint coords)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_1_Core::glMultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint *coords)
-{
-    Q_UNUSED(texture);
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_1_Core::glMultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords)
-{
-    Q_UNUSED(texture);
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_1_Core::glMultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint *coords)
-{
-    Q_UNUSED(texture);
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_1_Core::glMultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords)
-{
-    Q_UNUSED(texture);
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_1_Core::glMultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint *coords)
-{
-    Q_UNUSED(texture);
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_1_Core::glMultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords)
-{
-    Q_UNUSED(texture);
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_1_Core::glMultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint *coords)
-{
-    Q_UNUSED(texture);
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_1_Core::glMultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords)
-{
-    Q_UNUSED(texture);
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_1_Core::glTexCoordP4uiv(GLenum type, const GLuint *coords)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_1_Core::glTexCoordP4ui(GLenum type, GLuint coords)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_1_Core::glTexCoordP3uiv(GLenum type, const GLuint *coords)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_1_Core::glTexCoordP3ui(GLenum type, GLuint coords)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_1_Core::glTexCoordP2uiv(GLenum type, const GLuint *coords)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_1_Core::glTexCoordP2ui(GLenum type, GLuint coords)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_1_Core::glTexCoordP1uiv(GLenum type, const GLuint *coords)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_1_Core::glTexCoordP1ui(GLenum type, GLuint coords)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_1_Core::glVertexP4uiv(GLenum type, const GLuint *value)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(value);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_1_Core::glVertexP4ui(GLenum type, GLuint value)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(value);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_1_Core::glVertexP3uiv(GLenum type, const GLuint *value)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(value);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_1_Core::glVertexP3ui(GLenum type, GLuint value)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(value);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_1_Core::glVertexP2uiv(GLenum type, const GLuint *value)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(value);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_1_Core::glVertexP2ui(GLenum type, GLuint value)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(value);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params)
-{
-    d_3_3_Core->f.GetQueryObjectui64v(id, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params)
-{
-    d_3_3_Core->f.GetQueryObjecti64v(id, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glQueryCounter(GLuint id, GLenum target)
-{
-    d_3_3_Core->f.QueryCounter(id, target);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params)
-{
-    d_3_3_Core->f.GetSamplerParameterIuiv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params)
-{
-    d_3_3_Core->f.GetSamplerParameterfv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params)
-{
-    d_3_3_Core->f.GetSamplerParameterIiv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params)
-{
-    d_3_3_Core->f.GetSamplerParameteriv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param)
-{
-    d_3_3_Core->f.SamplerParameterIuiv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param)
-{
-    d_3_3_Core->f.SamplerParameterIiv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param)
-{
-    d_3_3_Core->f.SamplerParameterfv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
-{
-    d_3_3_Core->f.SamplerParameterf(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param)
-{
-    d_3_3_Core->f.SamplerParameteriv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glSamplerParameteri(GLuint sampler, GLenum pname, GLint param)
-{
-    d_3_3_Core->f.SamplerParameteri(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glBindSampler(GLuint unit, GLuint sampler)
-{
-    d_3_3_Core->f.BindSampler(unit, sampler);
-}
-
-inline GLboolean QOpenGLFunctions_4_1_Core::glIsSampler(GLuint sampler)
-{
-    return d_3_3_Core->f.IsSampler(sampler);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glDeleteSamplers(GLsizei count, const GLuint *samplers)
-{
-    d_3_3_Core->f.DeleteSamplers(count, samplers);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGenSamplers(GLsizei count, GLuint *samplers)
-{
-    d_3_3_Core->f.GenSamplers(count, samplers);
-}
-
-inline GLint QOpenGLFunctions_4_1_Core::glGetFragDataIndex(GLuint program, const GLchar *name)
-{
-    return d_3_3_Core->f.GetFragDataIndex(program, name);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glBindFragDataLocationIndexed(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name)
-{
-    d_3_3_Core->f.BindFragDataLocationIndexed(program, colorNumber, index, name);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glVertexAttribDivisor(GLuint index, GLuint divisor)
-{
-    d_3_3_Core->f.VertexAttribDivisor(index, divisor);
-}
-
-
-// OpenGL 4.0 core functions
-inline void QOpenGLFunctions_4_1_Core::glGetQueryIndexediv(GLenum target, GLuint index, GLenum pname, GLint *params)
-{
-    d_4_0_Core->f.GetQueryIndexediv(target, index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glEndQueryIndexed(GLenum target, GLuint index)
-{
-    d_4_0_Core->f.EndQueryIndexed(target, index);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glBeginQueryIndexed(GLenum target, GLuint index, GLuint id)
-{
-    d_4_0_Core->f.BeginQueryIndexed(target, index, id);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glDrawTransformFeedbackStream(GLenum mode, GLuint id, GLuint stream)
-{
-    d_4_0_Core->f.DrawTransformFeedbackStream(mode, id, stream);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glDrawTransformFeedback(GLenum mode, GLuint id)
-{
-    d_4_0_Core->f.DrawTransformFeedback(mode, id);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glResumeTransformFeedback()
-{
-    d_4_0_Core->f.ResumeTransformFeedback();
-}
-
-inline void QOpenGLFunctions_4_1_Core::glPauseTransformFeedback()
-{
-    d_4_0_Core->f.PauseTransformFeedback();
-}
-
-inline GLboolean QOpenGLFunctions_4_1_Core::glIsTransformFeedback(GLuint id)
-{
-    return d_4_0_Core->f.IsTransformFeedback(id);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGenTransformFeedbacks(GLsizei n, GLuint *ids)
-{
-    d_4_0_Core->f.GenTransformFeedbacks(n, ids);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids)
-{
-    d_4_0_Core->f.DeleteTransformFeedbacks(n, ids);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glBindTransformFeedback(GLenum target, GLuint id)
-{
-    d_4_0_Core->f.BindTransformFeedback(target, id);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glPatchParameterfv(GLenum pname, const GLfloat *values)
-{
-    d_4_0_Core->f.PatchParameterfv(pname, values);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glPatchParameteri(GLenum pname, GLint value)
-{
-    d_4_0_Core->f.PatchParameteri(pname, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetProgramStageiv(GLuint program, GLenum shadertype, GLenum pname, GLint *values)
-{
-    d_4_0_Core->f.GetProgramStageiv(program, shadertype, pname, values);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetUniformSubroutineuiv(GLenum shadertype, GLint location, GLuint *params)
-{
-    d_4_0_Core->f.GetUniformSubroutineuiv(shadertype, location, params);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUniformSubroutinesuiv(GLenum shadertype, GLsizei count, const GLuint *indices)
-{
-    d_4_0_Core->f.UniformSubroutinesuiv(shadertype, count, indices);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetActiveSubroutineName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
-{
-    d_4_0_Core->f.GetActiveSubroutineName(program, shadertype, index, bufsize, length, name);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetActiveSubroutineUniformName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
-{
-    d_4_0_Core->f.GetActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetActiveSubroutineUniformiv(GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values)
-{
-    d_4_0_Core->f.GetActiveSubroutineUniformiv(program, shadertype, index, pname, values);
-}
-
-inline GLuint QOpenGLFunctions_4_1_Core::glGetSubroutineIndex(GLuint program, GLenum shadertype, const GLchar *name)
-{
-    return d_4_0_Core->f.GetSubroutineIndex(program, shadertype, name);
-}
-
-inline GLint QOpenGLFunctions_4_1_Core::glGetSubroutineUniformLocation(GLuint program, GLenum shadertype, const GLchar *name)
-{
-    return d_4_0_Core->f.GetSubroutineUniformLocation(program, shadertype, name);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetUniformdv(GLuint program, GLint location, GLdouble *params)
-{
-    d_4_0_Core->f.GetUniformdv(program, location, params);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUniformMatrix4x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix4x3dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUniformMatrix4x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix4x2dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUniformMatrix3x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix3x4dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUniformMatrix3x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix3x2dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUniformMatrix2x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix2x4dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUniformMatrix2x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix2x3dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix4dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUniformMatrix3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix3dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUniformMatrix2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix2dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUniform4dv(GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_0_Core->f.Uniform4dv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUniform3dv(GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_0_Core->f.Uniform3dv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUniform2dv(GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_0_Core->f.Uniform2dv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUniform1dv(GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_0_Core->f.Uniform1dv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUniform4d(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_4_0_Core->f.Uniform4d(location, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUniform3d(GLint location, GLdouble x, GLdouble y, GLdouble z)
-{
-    d_4_0_Core->f.Uniform3d(location, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUniform2d(GLint location, GLdouble x, GLdouble y)
-{
-    d_4_0_Core->f.Uniform2d(location, x, y);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUniform1d(GLint location, GLdouble x)
-{
-    d_4_0_Core->f.Uniform1d(location, x);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glDrawElementsIndirect(GLenum mode, GLenum type, const GLvoid *indirect)
-{
-    d_4_0_Core->f.DrawElementsIndirect(mode, type, indirect);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glDrawArraysIndirect(GLenum mode, const GLvoid *indirect)
-{
-    d_4_0_Core->f.DrawArraysIndirect(mode, indirect);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glBlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
-{
-    d_4_0_Core->f.BlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glBlendFunci(GLuint buf, GLenum src, GLenum dst)
-{
-    d_4_0_Core->f.BlendFunci(buf, src, dst);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glBlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha)
-{
-    d_4_0_Core->f.BlendEquationSeparatei(buf, modeRGB, modeAlpha);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glBlendEquationi(GLuint buf, GLenum mode)
-{
-    d_4_0_Core->f.BlendEquationi(buf, mode);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glMinSampleShading(GLfloat value)
-{
-    d_4_0_Core->f.MinSampleShading(value);
-}
-
-
-// OpenGL 4.1 core functions
-inline void QOpenGLFunctions_4_1_Core::glGetDoublei_v(GLenum target, GLuint index, GLdouble *data)
-{
-    d_4_1_Core->f.GetDoublei_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetFloati_v(GLenum target, GLuint index, GLfloat *data)
-{
-    d_4_1_Core->f.GetFloati_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glDepthRangeIndexed(GLuint index, GLdouble n, GLdouble f)
-{
-    d_4_1_Core->f.DepthRangeIndexed(index, n, f);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glDepthRangeArrayv(GLuint first, GLsizei count, const GLdouble *v)
-{
-    d_4_1_Core->f.DepthRangeArrayv(first, count, v);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glScissorIndexedv(GLuint index, const GLint *v)
-{
-    d_4_1_Core->f.ScissorIndexedv(index, v);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glScissorIndexed(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height)
-{
-    d_4_1_Core->f.ScissorIndexed(index, left, bottom, width, height);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glScissorArrayv(GLuint first, GLsizei count, const GLint *v)
-{
-    d_4_1_Core->f.ScissorArrayv(first, count, v);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glViewportIndexedfv(GLuint index, const GLfloat *v)
-{
-    d_4_1_Core->f.ViewportIndexedfv(index, v);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glViewportIndexedf(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h)
-{
-    d_4_1_Core->f.ViewportIndexedf(index, x, y, w, h);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glViewportArrayv(GLuint first, GLsizei count, const GLfloat *v)
-{
-    d_4_1_Core->f.ViewportArrayv(first, count, v);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetVertexAttribLdv(GLuint index, GLenum pname, GLdouble *params)
-{
-    d_4_1_Core->f.GetVertexAttribLdv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glVertexAttribLPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_4_1_Core->f.VertexAttribLPointer(index, size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glVertexAttribL4dv(GLuint index, const GLdouble *v)
-{
-    d_4_1_Core->f.VertexAttribL4dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glVertexAttribL3dv(GLuint index, const GLdouble *v)
-{
-    d_4_1_Core->f.VertexAttribL3dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glVertexAttribL2dv(GLuint index, const GLdouble *v)
-{
-    d_4_1_Core->f.VertexAttribL2dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glVertexAttribL1dv(GLuint index, const GLdouble *v)
-{
-    d_4_1_Core->f.VertexAttribL1dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glVertexAttribL4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_4_1_Core->f.VertexAttribL4d(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glVertexAttribL3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
-{
-    d_4_1_Core->f.VertexAttribL3d(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glVertexAttribL2d(GLuint index, GLdouble x, GLdouble y)
-{
-    d_4_1_Core->f.VertexAttribL2d(index, x, y);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glVertexAttribL1d(GLuint index, GLdouble x)
-{
-    d_4_1_Core->f.VertexAttribL1d(index, x);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-{
-    d_4_1_Core->f.GetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glValidateProgramPipeline(GLuint pipeline)
-{
-    d_4_1_Core->f.ValidateProgramPipeline(pipeline);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProgramUniformMatrix4x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4x3dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProgramUniformMatrix3x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3x4dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProgramUniformMatrix4x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4x2dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProgramUniformMatrix2x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2x4dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProgramUniformMatrix3x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3x2dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProgramUniformMatrix2x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2x3dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProgramUniformMatrix4x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4x3fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProgramUniformMatrix3x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3x4fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProgramUniformMatrix4x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4x2fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProgramUniformMatrix2x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2x4fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProgramUniformMatrix3x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3x2fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProgramUniformMatrix2x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2x3fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProgramUniformMatrix4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProgramUniformMatrix3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProgramUniformMatrix2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProgramUniformMatrix4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProgramUniformMatrix3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProgramUniformMatrix2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProgramUniform4uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
-{
-    d_4_1_Core->f.ProgramUniform4uiv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
-{
-    d_4_1_Core->f.ProgramUniform4ui(program, location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProgramUniform4dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniform4dv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProgramUniform4d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3)
-{
-    d_4_1_Core->f.ProgramUniform4d(program, location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProgramUniform4fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniform4fv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
-{
-    d_4_1_Core->f.ProgramUniform4f(program, location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProgramUniform4iv(GLuint program, GLint location, GLsizei count, const GLint *value)
-{
-    d_4_1_Core->f.ProgramUniform4iv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
-{
-    d_4_1_Core->f.ProgramUniform4i(program, location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProgramUniform3uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
-{
-    d_4_1_Core->f.ProgramUniform3uiv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2)
-{
-    d_4_1_Core->f.ProgramUniform3ui(program, location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProgramUniform3dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniform3dv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProgramUniform3d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2)
-{
-    d_4_1_Core->f.ProgramUniform3d(program, location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProgramUniform3fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniform3fv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
-{
-    d_4_1_Core->f.ProgramUniform3f(program, location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProgramUniform3iv(GLuint program, GLint location, GLsizei count, const GLint *value)
-{
-    d_4_1_Core->f.ProgramUniform3iv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2)
-{
-    d_4_1_Core->f.ProgramUniform3i(program, location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProgramUniform2uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
-{
-    d_4_1_Core->f.ProgramUniform2uiv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1)
-{
-    d_4_1_Core->f.ProgramUniform2ui(program, location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProgramUniform2dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniform2dv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProgramUniform2d(GLuint program, GLint location, GLdouble v0, GLdouble v1)
-{
-    d_4_1_Core->f.ProgramUniform2d(program, location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProgramUniform2fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniform2fv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1)
-{
-    d_4_1_Core->f.ProgramUniform2f(program, location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProgramUniform2iv(GLuint program, GLint location, GLsizei count, const GLint *value)
-{
-    d_4_1_Core->f.ProgramUniform2iv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1)
-{
-    d_4_1_Core->f.ProgramUniform2i(program, location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProgramUniform1uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
-{
-    d_4_1_Core->f.ProgramUniform1uiv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProgramUniform1ui(GLuint program, GLint location, GLuint v0)
-{
-    d_4_1_Core->f.ProgramUniform1ui(program, location, v0);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProgramUniform1dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniform1dv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProgramUniform1d(GLuint program, GLint location, GLdouble v0)
-{
-    d_4_1_Core->f.ProgramUniform1d(program, location, v0);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProgramUniform1fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniform1fv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProgramUniform1f(GLuint program, GLint location, GLfloat v0)
-{
-    d_4_1_Core->f.ProgramUniform1f(program, location, v0);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProgramUniform1iv(GLuint program, GLint location, GLsizei count, const GLint *value)
-{
-    d_4_1_Core->f.ProgramUniform1iv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProgramUniform1i(GLuint program, GLint location, GLint v0)
-{
-    d_4_1_Core->f.ProgramUniform1i(program, location, v0);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params)
-{
-    d_4_1_Core->f.GetProgramPipelineiv(pipeline, pname, params);
-}
-
-inline GLboolean QOpenGLFunctions_4_1_Core::glIsProgramPipeline(GLuint pipeline)
-{
-    return d_4_1_Core->f.IsProgramPipeline(pipeline);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGenProgramPipelines(GLsizei n, GLuint *pipelines)
-{
-    d_4_1_Core->f.GenProgramPipelines(n, pipelines);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glDeleteProgramPipelines(GLsizei n, const GLuint *pipelines)
-{
-    d_4_1_Core->f.DeleteProgramPipelines(n, pipelines);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glBindProgramPipeline(GLuint pipeline)
-{
-    d_4_1_Core->f.BindProgramPipeline(pipeline);
-}
-
-inline GLuint QOpenGLFunctions_4_1_Core::glCreateShaderProgramv(GLenum type, GLsizei count, const GLchar* const *strings)
-{
-    return d_4_1_Core->f.CreateShaderProgramv(type, count, strings);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glActiveShaderProgram(GLuint pipeline, GLuint program)
-{
-    d_4_1_Core->f.ActiveShaderProgram(pipeline, program);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program)
-{
-    d_4_1_Core->f.UseProgramStages(pipeline, stages, program);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProgramParameteri(GLuint program, GLenum pname, GLint value)
-{
-    d_4_1_Core->f.ProgramParameteri(program, pname, value);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid *binary, GLsizei length)
-{
-    d_4_1_Core->f.ProgramBinary(program, binaryFormat, binary, length);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, GLvoid *binary)
-{
-    d_4_1_Core->f.GetProgramBinary(program, bufSize, length, binaryFormat, binary);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glClearDepthf(GLfloat dd)
-{
-    d_4_1_Core->f.ClearDepthf(dd);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glDepthRangef(GLfloat n, GLfloat f)
-{
-    d_4_1_Core->f.DepthRangef(n, f);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision)
-{
-    d_4_1_Core->f.GetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glShaderBinary(GLsizei count, const GLuint *shaders, GLenum binaryformat, const GLvoid *binary, GLsizei length)
-{
-    d_4_1_Core->f.ShaderBinary(count, shaders, binaryformat, binary, length);
-}
-
-inline void QOpenGLFunctions_4_1_Core::glReleaseShaderCompiler()
-{
-    d_4_1_Core->f.ReleaseShaderCompiler();
-}
-
-
-
-QT_END_NAMESPACE
-
-#endif // QT_NO_OPENGL && !QT_OPENGL_ES_2
-
-#endif
diff --git a/src/gui/opengl/qopenglfunctions_4_2_compatibility.cpp b/src/gui/opengl/qopenglfunctions_4_2_compatibility.cpp
deleted file mode 100644
index 41ab9ae762..0000000000
--- a/src/gui/opengl/qopenglfunctions_4_2_compatibility.cpp
+++ /dev/null
@@ -1,309 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#include "qopenglfunctions_4_2_compatibility.h"
-#include "qopenglcontext.h"
-
-QT_BEGIN_NAMESPACE
-
-/*!
-    \class QOpenGLFunctions_4_2_Compatibility
-    \inmodule QtGui
-    \since 5.1
-    \wrapper
-    \brief The QOpenGLFunctions_4_2_Compatibility class provides all functions for OpenGL 4.2 compatibility profile.
-
-    This class is a wrapper for functions from OpenGL 4.2 compatibility profile.
-    See reference pages on \l {http://www.opengl.org/sdk/docs/}{opengl.org}
-    for function documentation.
-
-    \sa QAbstractOpenGLFunctions
-*/
-
-QOpenGLFunctions_4_2_Compatibility::QOpenGLFunctions_4_2_Compatibility()
- : QAbstractOpenGLFunctions()
- , d_1_0_Core(nullptr)
- , d_1_1_Core(nullptr)
- , d_1_2_Core(nullptr)
- , d_1_3_Core(nullptr)
- , d_1_4_Core(nullptr)
- , d_1_5_Core(nullptr)
- , d_2_0_Core(nullptr)
- , d_2_1_Core(nullptr)
- , d_3_0_Core(nullptr)
- , d_3_1_Core(nullptr)
- , d_3_2_Core(nullptr)
- , d_3_3_Core(nullptr)
- , d_4_0_Core(nullptr)
- , d_4_1_Core(nullptr)
- , d_4_2_Core(nullptr)
- , d_1_0_Deprecated(nullptr)
- , d_1_1_Deprecated(nullptr)
- , d_1_2_Deprecated(nullptr)
- , d_1_3_Deprecated(nullptr)
- , d_1_4_Deprecated(nullptr)
- , m_reserved_2_0_Deprecated(nullptr)
- , d_3_3_Deprecated(nullptr)
-{
-}
-
-QOpenGLFunctions_4_2_Compatibility::~QOpenGLFunctions_4_2_Compatibility()
-{
-    if (d_1_0_Core) {
-        d_1_0_Core->refs.deref();
-        Q_ASSERT(d_1_0_Core->refs.loadRelaxed());
-    }
-    if (d_1_1_Core) {
-        d_1_1_Core->refs.deref();
-        Q_ASSERT(d_1_1_Core->refs.loadRelaxed());
-    }
-    if (d_1_2_Core) {
-        d_1_2_Core->refs.deref();
-        Q_ASSERT(d_1_2_Core->refs.loadRelaxed());
-    }
-    if (d_1_3_Core) {
-        d_1_3_Core->refs.deref();
-        Q_ASSERT(d_1_3_Core->refs.loadRelaxed());
-    }
-    if (d_1_4_Core) {
-        d_1_4_Core->refs.deref();
-        Q_ASSERT(d_1_4_Core->refs.loadRelaxed());
-    }
-    if (d_1_5_Core) {
-        d_1_5_Core->refs.deref();
-        Q_ASSERT(d_1_5_Core->refs.loadRelaxed());
-    }
-    if (d_2_0_Core) {
-        d_2_0_Core->refs.deref();
-        Q_ASSERT(d_2_0_Core->refs.loadRelaxed());
-    }
-    if (d_2_1_Core) {
-        d_2_1_Core->refs.deref();
-        Q_ASSERT(d_2_1_Core->refs.loadRelaxed());
-    }
-    if (d_3_0_Core) {
-        d_3_0_Core->refs.deref();
-        Q_ASSERT(d_3_0_Core->refs.loadRelaxed());
-    }
-    if (d_3_1_Core) {
-        d_3_1_Core->refs.deref();
-        Q_ASSERT(d_3_1_Core->refs.loadRelaxed());
-    }
-    if (d_3_2_Core) {
-        d_3_2_Core->refs.deref();
-        Q_ASSERT(d_3_2_Core->refs.loadRelaxed());
-    }
-    if (d_3_3_Core) {
-        d_3_3_Core->refs.deref();
-        Q_ASSERT(d_3_3_Core->refs.loadRelaxed());
-    }
-    if (d_4_0_Core) {
-        d_4_0_Core->refs.deref();
-        Q_ASSERT(d_4_0_Core->refs.loadRelaxed());
-    }
-    if (d_4_1_Core) {
-        d_4_1_Core->refs.deref();
-        Q_ASSERT(d_4_1_Core->refs.loadRelaxed());
-    }
-    if (d_4_2_Core) {
-        d_4_2_Core->refs.deref();
-        Q_ASSERT(d_4_2_Core->refs.loadRelaxed());
-    }
-    if (d_1_0_Deprecated) {
-        d_1_0_Deprecated->refs.deref();
-        Q_ASSERT(d_1_0_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_1_Deprecated) {
-        d_1_1_Deprecated->refs.deref();
-        Q_ASSERT(d_1_1_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_2_Deprecated) {
-        d_1_2_Deprecated->refs.deref();
-        Q_ASSERT(d_1_2_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_3_Deprecated) {
-        d_1_3_Deprecated->refs.deref();
-        Q_ASSERT(d_1_3_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_4_Deprecated) {
-        d_1_4_Deprecated->refs.deref();
-        Q_ASSERT(d_1_4_Deprecated->refs.loadRelaxed());
-    }
-    if (d_3_3_Deprecated) {
-        d_3_3_Deprecated->refs.deref();
-        Q_ASSERT(d_3_3_Deprecated->refs.loadRelaxed());
-    }
-}
-
-bool QOpenGLFunctions_4_2_Compatibility::initializeOpenGLFunctions()
-{
-    if ( isInitialized() )
-        return true;
-
-    QOpenGLContext* context = QOpenGLContext::currentContext();
-
-    // If owned by a context object make sure it is current.
-    // Also check that current context is capable of resolving all needed functions
-    if (((owningContext() && owningContext() == context) || !owningContext())
-        && QOpenGLFunctions_4_2_Compatibility::isContextCompatible(context))
-    {
-        // Associate with private implementation, creating if necessary
-        // Function pointers in the backends are resolved at creation time
-        QOpenGLVersionFunctionsBackend* d = nullptr;
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        d_1_3_Core = static_cast<QOpenGLFunctions_1_3_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        d_1_4_Core = static_cast<QOpenGLFunctions_1_4_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        d_1_5_Core = static_cast<QOpenGLFunctions_1_5_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        d_2_0_Core = static_cast<QOpenGLFunctions_2_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        d_2_1_Core = static_cast<QOpenGLFunctions_2_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        d_3_0_Core = static_cast<QOpenGLFunctions_3_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
-        d_3_1_Core = static_cast<QOpenGLFunctions_3_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
-        d_3_2_Core = static_cast<QOpenGLFunctions_3_2_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_CoreBackend::versionStatus());
-        d_3_3_Core = static_cast<QOpenGLFunctions_3_3_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_0_CoreBackend::versionStatus());
-        d_4_0_Core = static_cast<QOpenGLFunctions_4_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_1_CoreBackend::versionStatus());
-        d_4_1_Core = static_cast<QOpenGLFunctions_4_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_2_CoreBackend::versionStatus());
-        d_4_2_Core = static_cast<QOpenGLFunctions_4_2_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
-        d_1_0_Deprecated = static_cast<QOpenGLFunctions_1_0_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
-        d_1_1_Deprecated = static_cast<QOpenGLFunctions_1_1_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus());
-        d_1_2_Deprecated = static_cast<QOpenGLFunctions_1_2_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus());
-        d_1_3_Deprecated = static_cast<QOpenGLFunctions_1_3_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
-        d_1_4_Deprecated = static_cast<QOpenGLFunctions_1_4_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_DeprecatedBackend::versionStatus());
-        d_3_3_Deprecated = static_cast<QOpenGLFunctions_3_3_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        QAbstractOpenGLFunctions::initializeOpenGLFunctions();
-    }
-    return isInitialized();
-}
-
-bool QOpenGLFunctions_4_2_Compatibility::isContextCompatible(QOpenGLContext *context)
-{
-    Q_ASSERT(context);
-    QSurfaceFormat f = context->format();
-    const QPair<int, int> v = qMakePair(f.majorVersion(), f.minorVersion());
-    if (v < qMakePair(4, 2))
-        return false;
-
-    if (f.profile() == QSurfaceFormat::CoreProfile)
-        return false;
-
-    return true;
-}
-
-QOpenGLVersionProfile QOpenGLFunctions_4_2_Compatibility::versionProfile()
-{
-    QOpenGLVersionProfile v;
-    v.setVersion(4, 2);
-    v.setProfile(QSurfaceFormat::CompatibilityProfile);
-    return v;
-}
-
-QT_END_NAMESPACE
diff --git a/src/gui/opengl/qopenglfunctions_4_2_compatibility.h b/src/gui/opengl/qopenglfunctions_4_2_compatibility.h
deleted file mode 100644
index a48d581c2d..0000000000
--- a/src/gui/opengl/qopenglfunctions_4_2_compatibility.h
+++ /dev/null
@@ -1,5647 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#ifndef QOPENGLVERSIONFUNCTIONS_4_2_COMPATIBILITY_H
-#define QOPENGLVERSIONFUNCTIONS_4_2_COMPATIBILITY_H
-
-#include <QtGui/qtguiglobal.h>
-
-#if !defined(QT_NO_OPENGL) && !defined(QT_OPENGL_ES_2)
-
-#include <QtGui/QOpenGLVersionFunctions>
-#include <QtGui/qopenglcontext.h>
-
-// MemoryBarrier is a macro on some architectures on Windows
-#ifdef Q_OS_WIN
-#pragma push_macro("MemoryBarrier")
-#undef MemoryBarrier
-#endif
-
-QT_BEGIN_NAMESPACE
-
-class Q_GUI_EXPORT QOpenGLFunctions_4_2_Compatibility : public QAbstractOpenGLFunctions
-{
-public:
-    QOpenGLFunctions_4_2_Compatibility();
-    ~QOpenGLFunctions_4_2_Compatibility();
-
-    bool initializeOpenGLFunctions() override;
-
-    // OpenGL 1.0 core functions
-    void glViewport(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glDepthRange(GLdouble nearVal, GLdouble farVal);
-    GLboolean glIsEnabled(GLenum cap);
-    void glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params);
-    void glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params);
-    void glGetTexParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
-    const GLubyte * glGetString(GLenum name);
-    void glGetIntegerv(GLenum pname, GLint *params);
-    void glGetFloatv(GLenum pname, GLfloat *params);
-    GLenum glGetError();
-    void glGetDoublev(GLenum pname, GLdouble *params);
-    void glGetBooleanv(GLenum pname, GLboolean *params);
-    void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
-    void glReadBuffer(GLenum mode);
-    void glPixelStorei(GLenum pname, GLint param);
-    void glPixelStoref(GLenum pname, GLfloat param);
-    void glDepthFunc(GLenum func);
-    void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass);
-    void glStencilFunc(GLenum func, GLint ref, GLuint mask);
-    void glLogicOp(GLenum opcode);
-    void glBlendFunc(GLenum sfactor, GLenum dfactor);
-    void glFlush();
-    void glFinish();
-    void glEnable(GLenum cap);
-    void glDisable(GLenum cap);
-    void glDepthMask(GLboolean flag);
-    void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
-    void glStencilMask(GLuint mask);
-    void glClearDepth(GLdouble depth);
-    void glClearStencil(GLint s);
-    void glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glClear(GLbitfield mask);
-    void glDrawBuffer(GLenum mode);
-    void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glTexParameteri(GLenum target, GLenum pname, GLint param);
-    void glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glTexParameterf(GLenum target, GLenum pname, GLfloat param);
-    void glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glPolygonMode(GLenum face, GLenum mode);
-    void glPointSize(GLfloat size);
-    void glLineWidth(GLfloat width);
-    void glHint(GLenum target, GLenum mode);
-    void glFrontFace(GLenum mode);
-    void glCullFace(GLenum mode);
-
-    // OpenGL 1.1 core functions
-    void glIndexubv(const GLubyte *c);
-    void glIndexub(GLubyte c);
-    GLboolean glIsTexture(GLuint texture);
-    void glGenTextures(GLsizei n, GLuint *textures);
-    void glDeleteTextures(GLsizei n, const GLuint *textures);
-    void glBindTexture(GLenum target, GLuint texture);
-    void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
-    void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
-    void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
-    void glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
-    void glPolygonOffset(GLfloat factor, GLfloat units);
-    void glGetPointerv(GLenum pname, GLvoid* *params);
-    void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
-    void glDrawArrays(GLenum mode, GLint first, GLsizei count);
-
-    // OpenGL 1.2 core functions
-    void glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices);
-    void glBlendEquation(GLenum mode);
-    void glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-
-    // OpenGL 1.3 core functions
-    void glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img);
-    void glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glSampleCoverage(GLfloat value, GLboolean invert);
-    void glActiveTexture(GLenum texture);
-
-    // OpenGL 1.4 core functions
-    void glPointParameteriv(GLenum pname, const GLint *params);
-    void glPointParameteri(GLenum pname, GLint param);
-    void glPointParameterfv(GLenum pname, const GLfloat *params);
-    void glPointParameterf(GLenum pname, GLfloat param);
-    void glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount);
-    void glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount);
-    void glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
-
-    // OpenGL 1.5 core functions
-    void glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params);
-    void glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params);
-    GLboolean glUnmapBuffer(GLenum target);
-    GLvoid* glMapBuffer(GLenum target, GLenum access);
-    void glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data);
-    void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data);
-    void glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage);
-    GLboolean glIsBuffer(GLuint buffer);
-    void glGenBuffers(GLsizei n, GLuint *buffers);
-    void glDeleteBuffers(GLsizei n, const GLuint *buffers);
-    void glBindBuffer(GLenum target, GLuint buffer);
-    void glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params);
-    void glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params);
-    void glGetQueryiv(GLenum target, GLenum pname, GLint *params);
-    void glEndQuery(GLenum target);
-    void glBeginQuery(GLenum target, GLuint id);
-    GLboolean glIsQuery(GLuint id);
-    void glDeleteQueries(GLsizei n, const GLuint *ids);
-    void glGenQueries(GLsizei n, GLuint *ids);
-
-    // OpenGL 2.0 core functions
-    void glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer);
-    void glValidateProgram(GLuint program);
-    void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniform4iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform3iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform2iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform1iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform4fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform3fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform2fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform1fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
-    void glUniform3i(GLint location, GLint v0, GLint v1, GLint v2);
-    void glUniform2i(GLint location, GLint v0, GLint v1);
-    void glUniform1i(GLint location, GLint v0);
-    void glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
-    void glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
-    void glUniform2f(GLint location, GLfloat v0, GLfloat v1);
-    void glUniform1f(GLint location, GLfloat v0);
-    void glUseProgram(GLuint program);
-    void glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length);
-    void glLinkProgram(GLuint program);
-    GLboolean glIsShader(GLuint shader);
-    GLboolean glIsProgram(GLuint program);
-    void glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer);
-    void glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params);
-    void glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params);
-    void glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params);
-    void glGetUniformiv(GLuint program, GLint location, GLint *params);
-    void glGetUniformfv(GLuint program, GLint location, GLfloat *params);
-    GLint glGetUniformLocation(GLuint program, const GLchar *name);
-    void glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source);
-    void glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void glGetShaderiv(GLuint shader, GLenum pname, GLint *params);
-    void glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void glGetProgramiv(GLuint program, GLenum pname, GLint *params);
-    GLint glGetAttribLocation(GLuint program, const GLchar *name);
-    void glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj);
-    void glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
-    void glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
-    void glEnableVertexAttribArray(GLuint index);
-    void glDisableVertexAttribArray(GLuint index);
-    void glDetachShader(GLuint program, GLuint shader);
-    void glDeleteShader(GLuint shader);
-    void glDeleteProgram(GLuint program);
-    GLuint glCreateShader(GLenum type);
-    GLuint glCreateProgram();
-    void glCompileShader(GLuint shader);
-    void glBindAttribLocation(GLuint program, GLuint index, const GLchar *name);
-    void glAttachShader(GLuint program, GLuint shader);
-    void glStencilMaskSeparate(GLenum face, GLuint mask);
-    void glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask);
-    void glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);
-    void glDrawBuffers(GLsizei n, const GLenum *bufs);
-    void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha);
-
-    // OpenGL 2.1 core functions
-    void glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-
-    // OpenGL 3.0 core functions
-    GLboolean glIsVertexArray(GLuint array);
-    void glGenVertexArrays(GLsizei n, GLuint *arrays);
-    void glDeleteVertexArrays(GLsizei n, const GLuint *arrays);
-    void glBindVertexArray(GLuint array);
-    void glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length);
-    GLvoid* glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
-    void glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
-    void glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
-    void glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
-    void glGenerateMipmap(GLenum target);
-    void glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params);
-    void glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
-    void glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset);
-    void glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
-    void glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
-    GLenum glCheckFramebufferStatus(GLenum target);
-    void glGenFramebuffers(GLsizei n, GLuint *framebuffers);
-    void glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers);
-    void glBindFramebuffer(GLenum target, GLuint framebuffer);
-    GLboolean glIsFramebuffer(GLuint framebuffer);
-    void glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
-    void glGenRenderbuffers(GLsizei n, GLuint *renderbuffers);
-    void glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers);
-    void glBindRenderbuffer(GLenum target, GLuint renderbuffer);
-    GLboolean glIsRenderbuffer(GLuint renderbuffer);
-    const GLubyte * glGetStringi(GLenum name, GLuint index);
-    void glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
-    void glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value);
-    void glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value);
-    void glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value);
-    void glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params);
-    void glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params);
-    void glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params);
-    void glTexParameterIiv(GLenum target, GLenum pname, const GLint *params);
-    void glUniform4uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform3uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform2uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform1uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
-    void glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2);
-    void glUniform2ui(GLint location, GLuint v0, GLuint v1);
-    void glUniform1ui(GLint location, GLuint v0);
-    GLint glGetFragDataLocation(GLuint program, const GLchar *name);
-    void glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name);
-    void glGetUniformuiv(GLuint program, GLint location, GLuint *params);
-    void glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params);
-    void glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params);
-    void glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glEndConditionalRender();
-    void glBeginConditionalRender(GLuint id, GLenum mode);
-    void glClampColor(GLenum target, GLenum clamp);
-    void glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name);
-    void glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode);
-    void glBindBufferBase(GLenum target, GLuint index, GLuint buffer);
-    void glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
-    void glEndTransformFeedback();
-    void glBeginTransformFeedback(GLenum primitiveMode);
-    GLboolean glIsEnabledi(GLenum target, GLuint index);
-    void glDisablei(GLenum target, GLuint index);
-    void glEnablei(GLenum target, GLuint index);
-    void glGetIntegeri_v(GLenum target, GLuint index, GLint *data);
-    void glGetBooleani_v(GLenum target, GLuint index, GLboolean *data);
-    void glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a);
-
-    // OpenGL 3.1 core functions
-    void glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
-    void glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);
-    void glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName);
-    void glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params);
-    GLuint glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName);
-    void glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName);
-    void glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params);
-    void glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const *uniformNames, GLuint *uniformIndices);
-    void glPrimitiveRestartIndex(GLuint index);
-    void glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer);
-    void glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount);
-    void glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount);
-
-    // OpenGL 3.2 core functions
-    void glSampleMaski(GLuint index, GLbitfield mask);
-    void glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val);
-    void glTexImage3DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
-    void glTexImage2DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
-    void glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values);
-    void glGetInteger64v(GLenum pname, GLint64 *params);
-    void glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout);
-    GLenum glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout);
-    void glDeleteSync(GLsync sync);
-    GLboolean glIsSync(GLsync sync);
-    GLsync glFenceSync(GLenum condition, GLbitfield flags);
-    void glProvokingVertex(GLenum mode);
-    void glMultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount, const GLint *basevertex);
-    void glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount, GLint basevertex);
-    void glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex);
-    void glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex);
-    void glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level);
-    void glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params);
-    void glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data);
-
-    // OpenGL 3.3 core functions
-    void glVertexAttribP4uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glVertexAttribP3uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glVertexAttribP2uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glVertexAttribP1uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glSecondaryColorP3uiv(GLenum type, const GLuint *color);
-    void glSecondaryColorP3ui(GLenum type, GLuint color);
-    void glColorP4uiv(GLenum type, const GLuint *color);
-    void glColorP4ui(GLenum type, GLuint color);
-    void glColorP3uiv(GLenum type, const GLuint *color);
-    void glColorP3ui(GLenum type, GLuint color);
-    void glNormalP3uiv(GLenum type, const GLuint *coords);
-    void glNormalP3ui(GLenum type, GLuint coords);
-    void glMultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint *coords);
-    void glMultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords);
-    void glMultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint *coords);
-    void glMultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords);
-    void glMultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint *coords);
-    void glMultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords);
-    void glMultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint *coords);
-    void glMultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords);
-    void glTexCoordP4uiv(GLenum type, const GLuint *coords);
-    void glTexCoordP4ui(GLenum type, GLuint coords);
-    void glTexCoordP3uiv(GLenum type, const GLuint *coords);
-    void glTexCoordP3ui(GLenum type, GLuint coords);
-    void glTexCoordP2uiv(GLenum type, const GLuint *coords);
-    void glTexCoordP2ui(GLenum type, GLuint coords);
-    void glTexCoordP1uiv(GLenum type, const GLuint *coords);
-    void glTexCoordP1ui(GLenum type, GLuint coords);
-    void glVertexP4uiv(GLenum type, const GLuint *value);
-    void glVertexP4ui(GLenum type, GLuint value);
-    void glVertexP3uiv(GLenum type, const GLuint *value);
-    void glVertexP3ui(GLenum type, GLuint value);
-    void glVertexP2uiv(GLenum type, const GLuint *value);
-    void glVertexP2ui(GLenum type, GLuint value);
-    void glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params);
-    void glGetQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params);
-    void glQueryCounter(GLuint id, GLenum target);
-    void glGetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params);
-    void glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params);
-    void glGetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params);
-    void glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params);
-    void glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param);
-    void glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param);
-    void glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param);
-    void glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param);
-    void glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param);
-    void glSamplerParameteri(GLuint sampler, GLenum pname, GLint param);
-    void glBindSampler(GLuint unit, GLuint sampler);
-    GLboolean glIsSampler(GLuint sampler);
-    void glDeleteSamplers(GLsizei count, const GLuint *samplers);
-    void glGenSamplers(GLsizei count, GLuint *samplers);
-    GLint glGetFragDataIndex(GLuint program, const GLchar *name);
-    void glBindFragDataLocationIndexed(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name);
-    void glVertexAttribDivisor(GLuint index, GLuint divisor);
-
-    // OpenGL 4.0 core functions
-    void glGetQueryIndexediv(GLenum target, GLuint index, GLenum pname, GLint *params);
-    void glEndQueryIndexed(GLenum target, GLuint index);
-    void glBeginQueryIndexed(GLenum target, GLuint index, GLuint id);
-    void glDrawTransformFeedbackStream(GLenum mode, GLuint id, GLuint stream);
-    void glDrawTransformFeedback(GLenum mode, GLuint id);
-    void glResumeTransformFeedback();
-    void glPauseTransformFeedback();
-    GLboolean glIsTransformFeedback(GLuint id);
-    void glGenTransformFeedbacks(GLsizei n, GLuint *ids);
-    void glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids);
-    void glBindTransformFeedback(GLenum target, GLuint id);
-    void glPatchParameterfv(GLenum pname, const GLfloat *values);
-    void glPatchParameteri(GLenum pname, GLint value);
-    void glGetProgramStageiv(GLuint program, GLenum shadertype, GLenum pname, GLint *values);
-    void glGetUniformSubroutineuiv(GLenum shadertype, GLint location, GLuint *params);
-    void glUniformSubroutinesuiv(GLenum shadertype, GLsizei count, const GLuint *indices);
-    void glGetActiveSubroutineName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name);
-    void glGetActiveSubroutineUniformName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name);
-    void glGetActiveSubroutineUniformiv(GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values);
-    GLuint glGetSubroutineIndex(GLuint program, GLenum shadertype, const GLchar *name);
-    GLint glGetSubroutineUniformLocation(GLuint program, GLenum shadertype, const GLchar *name);
-    void glGetUniformdv(GLuint program, GLint location, GLdouble *params);
-    void glUniformMatrix4x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix4x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix3x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix3x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix2x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix2x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniform4dv(GLint location, GLsizei count, const GLdouble *value);
-    void glUniform3dv(GLint location, GLsizei count, const GLdouble *value);
-    void glUniform2dv(GLint location, GLsizei count, const GLdouble *value);
-    void glUniform1dv(GLint location, GLsizei count, const GLdouble *value);
-    void glUniform4d(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glUniform3d(GLint location, GLdouble x, GLdouble y, GLdouble z);
-    void glUniform2d(GLint location, GLdouble x, GLdouble y);
-    void glUniform1d(GLint location, GLdouble x);
-    void glDrawElementsIndirect(GLenum mode, GLenum type, const GLvoid *indirect);
-    void glDrawArraysIndirect(GLenum mode, const GLvoid *indirect);
-    void glBlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
-    void glBlendFunci(GLuint buf, GLenum src, GLenum dst);
-    void glBlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha);
-    void glBlendEquationi(GLuint buf, GLenum mode);
-    void glMinSampleShading(GLfloat value);
-
-    // OpenGL 4.1 core functions
-    void glGetDoublei_v(GLenum target, GLuint index, GLdouble *data);
-    void glGetFloati_v(GLenum target, GLuint index, GLfloat *data);
-    void glDepthRangeIndexed(GLuint index, GLdouble n, GLdouble f);
-    void glDepthRangeArrayv(GLuint first, GLsizei count, const GLdouble *v);
-    void glScissorIndexedv(GLuint index, const GLint *v);
-    void glScissorIndexed(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height);
-    void glScissorArrayv(GLuint first, GLsizei count, const GLint *v);
-    void glViewportIndexedfv(GLuint index, const GLfloat *v);
-    void glViewportIndexedf(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h);
-    void glViewportArrayv(GLuint first, GLsizei count, const GLfloat *v);
-    void glGetVertexAttribLdv(GLuint index, GLenum pname, GLdouble *params);
-    void glVertexAttribLPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glVertexAttribL4dv(GLuint index, const GLdouble *v);
-    void glVertexAttribL3dv(GLuint index, const GLdouble *v);
-    void glVertexAttribL2dv(GLuint index, const GLdouble *v);
-    void glVertexAttribL1dv(GLuint index, const GLdouble *v);
-    void glVertexAttribL4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glVertexAttribL3d(GLuint index, GLdouble x, GLdouble y, GLdouble z);
-    void glVertexAttribL2d(GLuint index, GLdouble x, GLdouble y);
-    void glVertexAttribL1d(GLuint index, GLdouble x);
-    void glGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void glValidateProgramPipeline(GLuint pipeline);
-    void glProgramUniformMatrix4x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix3x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix4x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix2x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix3x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix2x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix4x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix3x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix4x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix2x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix3x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix2x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniform4uiv(GLuint program, GLint location, GLsizei count, const GLuint *value);
-    void glProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
-    void glProgramUniform4dv(GLuint program, GLint location, GLsizei count, const GLdouble *value);
-    void glProgramUniform4d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3);
-    void glProgramUniform4fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-    void glProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
-    void glProgramUniform4iv(GLuint program, GLint location, GLsizei count, const GLint *value);
-    void glProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
-    void glProgramUniform3uiv(GLuint program, GLint location, GLsizei count, const GLuint *value);
-    void glProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2);
-    void glProgramUniform3dv(GLuint program, GLint location, GLsizei count, const GLdouble *value);
-    void glProgramUniform3d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2);
-    void glProgramUniform3fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-    void glProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
-    void glProgramUniform3iv(GLuint program, GLint location, GLsizei count, const GLint *value);
-    void glProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2);
-    void glProgramUniform2uiv(GLuint program, GLint location, GLsizei count, const GLuint *value);
-    void glProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1);
-    void glProgramUniform2dv(GLuint program, GLint location, GLsizei count, const GLdouble *value);
-    void glProgramUniform2d(GLuint program, GLint location, GLdouble v0, GLdouble v1);
-    void glProgramUniform2fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-    void glProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1);
-    void glProgramUniform2iv(GLuint program, GLint location, GLsizei count, const GLint *value);
-    void glProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1);
-    void glProgramUniform1uiv(GLuint program, GLint location, GLsizei count, const GLuint *value);
-    void glProgramUniform1ui(GLuint program, GLint location, GLuint v0);
-    void glProgramUniform1dv(GLuint program, GLint location, GLsizei count, const GLdouble *value);
-    void glProgramUniform1d(GLuint program, GLint location, GLdouble v0);
-    void glProgramUniform1fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-    void glProgramUniform1f(GLuint program, GLint location, GLfloat v0);
-    void glProgramUniform1iv(GLuint program, GLint location, GLsizei count, const GLint *value);
-    void glProgramUniform1i(GLuint program, GLint location, GLint v0);
-    void glGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params);
-    GLboolean glIsProgramPipeline(GLuint pipeline);
-    void glGenProgramPipelines(GLsizei n, GLuint *pipelines);
-    void glDeleteProgramPipelines(GLsizei n, const GLuint *pipelines);
-    void glBindProgramPipeline(GLuint pipeline);
-    GLuint glCreateShaderProgramv(GLenum type, GLsizei count, const GLchar* const *strings);
-    void glActiveShaderProgram(GLuint pipeline, GLuint program);
-    void glUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program);
-    void glProgramParameteri(GLuint program, GLenum pname, GLint value);
-    void glProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid *binary, GLsizei length);
-    void glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, GLvoid *binary);
-    void glClearDepthf(GLfloat dd);
-    void glDepthRangef(GLfloat n, GLfloat f);
-    void glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision);
-    void glShaderBinary(GLsizei count, const GLuint *shaders, GLenum binaryformat, const GLvoid *binary, GLsizei length);
-    void glReleaseShaderCompiler();
-
-    // OpenGL 4.2 core functions
-    void glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
-    void glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);
-    void glTexStorage1D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width);
-    void glMemoryBarrier(GLbitfield barriers);
-    void glBindImageTexture(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format);
-    void glGetActiveAtomicCounterBufferiv(GLuint program, GLuint bufferIndex, GLenum pname, GLint *params);
-    void glGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params);
-    void glDrawTransformFeedbackStreamInstanced(GLenum mode, GLuint id, GLuint stream, GLsizei instancecount);
-    void glDrawTransformFeedbackInstanced(GLenum mode, GLuint id, GLsizei instancecount);
-    void glDrawElementsInstancedBaseVertexBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance);
-    void glDrawElementsInstancedBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLuint baseinstance);
-    void glDrawArraysInstancedBaseInstance(GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance);
-
-    // OpenGL 1.0 deprecated functions
-    void glTranslatef(GLfloat x, GLfloat y, GLfloat z);
-    void glTranslated(GLdouble x, GLdouble y, GLdouble z);
-    void glScalef(GLfloat x, GLfloat y, GLfloat z);
-    void glScaled(GLdouble x, GLdouble y, GLdouble z);
-    void glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
-    void glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
-    void glPushMatrix();
-    void glPopMatrix();
-    void glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
-    void glMultMatrixd(const GLdouble *m);
-    void glMultMatrixf(const GLfloat *m);
-    void glMatrixMode(GLenum mode);
-    void glLoadMatrixd(const GLdouble *m);
-    void glLoadMatrixf(const GLfloat *m);
-    void glLoadIdentity();
-    void glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
-    GLboolean glIsList(GLuint list);
-    void glGetTexGeniv(GLenum coord, GLenum pname, GLint *params);
-    void glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params);
-    void glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params);
-    void glGetTexEnviv(GLenum target, GLenum pname, GLint *params);
-    void glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetPolygonStipple(GLubyte *mask);
-    void glGetPixelMapusv(GLenum map, GLushort *values);
-    void glGetPixelMapuiv(GLenum map, GLuint *values);
-    void glGetPixelMapfv(GLenum map, GLfloat *values);
-    void glGetMaterialiv(GLenum face, GLenum pname, GLint *params);
-    void glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params);
-    void glGetMapiv(GLenum target, GLenum query, GLint *v);
-    void glGetMapfv(GLenum target, GLenum query, GLfloat *v);
-    void glGetMapdv(GLenum target, GLenum query, GLdouble *v);
-    void glGetLightiv(GLenum light, GLenum pname, GLint *params);
-    void glGetLightfv(GLenum light, GLenum pname, GLfloat *params);
-    void glGetClipPlane(GLenum plane, GLdouble *equation);
-    void glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
-    void glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
-    void glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values);
-    void glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values);
-    void glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values);
-    void glPixelTransferi(GLenum pname, GLint param);
-    void glPixelTransferf(GLenum pname, GLfloat param);
-    void glPixelZoom(GLfloat xfactor, GLfloat yfactor);
-    void glAlphaFunc(GLenum func, GLfloat ref);
-    void glEvalPoint2(GLint i, GLint j);
-    void glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
-    void glEvalPoint1(GLint i);
-    void glEvalMesh1(GLenum mode, GLint i1, GLint i2);
-    void glEvalCoord2fv(const GLfloat *u);
-    void glEvalCoord2f(GLfloat u, GLfloat v);
-    void glEvalCoord2dv(const GLdouble *u);
-    void glEvalCoord2d(GLdouble u, GLdouble v);
-    void glEvalCoord1fv(const GLfloat *u);
-    void glEvalCoord1f(GLfloat u);
-    void glEvalCoord1dv(const GLdouble *u);
-    void glEvalCoord1d(GLdouble u);
-    void glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
-    void glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
-    void glMapGrid1f(GLint un, GLfloat u1, GLfloat u2);
-    void glMapGrid1d(GLint un, GLdouble u1, GLdouble u2);
-    void glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);
-    void glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);
-    void glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);
-    void glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);
-    void glPushAttrib(GLbitfield mask);
-    void glPopAttrib();
-    void glAccum(GLenum op, GLfloat value);
-    void glIndexMask(GLuint mask);
-    void glClearIndex(GLfloat c);
-    void glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glPushName(GLuint name);
-    void glPopName();
-    void glPassThrough(GLfloat token);
-    void glLoadName(GLuint name);
-    void glInitNames();
-    GLint glRenderMode(GLenum mode);
-    void glSelectBuffer(GLsizei size, GLuint *buffer);
-    void glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer);
-    void glTexGeniv(GLenum coord, GLenum pname, const GLint *params);
-    void glTexGeni(GLenum coord, GLenum pname, GLint param);
-    void glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params);
-    void glTexGenf(GLenum coord, GLenum pname, GLfloat param);
-    void glTexGendv(GLenum coord, GLenum pname, const GLdouble *params);
-    void glTexGend(GLenum coord, GLenum pname, GLdouble param);
-    void glTexEnviv(GLenum target, GLenum pname, const GLint *params);
-    void glTexEnvi(GLenum target, GLenum pname, GLint param);
-    void glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glTexEnvf(GLenum target, GLenum pname, GLfloat param);
-    void glShadeModel(GLenum mode);
-    void glPolygonStipple(const GLubyte *mask);
-    void glMaterialiv(GLenum face, GLenum pname, const GLint *params);
-    void glMateriali(GLenum face, GLenum pname, GLint param);
-    void glMaterialfv(GLenum face, GLenum pname, const GLfloat *params);
-    void glMaterialf(GLenum face, GLenum pname, GLfloat param);
-    void glLineStipple(GLint factor, GLushort pattern);
-    void glLightModeliv(GLenum pname, const GLint *params);
-    void glLightModeli(GLenum pname, GLint param);
-    void glLightModelfv(GLenum pname, const GLfloat *params);
-    void glLightModelf(GLenum pname, GLfloat param);
-    void glLightiv(GLenum light, GLenum pname, const GLint *params);
-    void glLighti(GLenum light, GLenum pname, GLint param);
-    void glLightfv(GLenum light, GLenum pname, const GLfloat *params);
-    void glLightf(GLenum light, GLenum pname, GLfloat param);
-    void glFogiv(GLenum pname, const GLint *params);
-    void glFogi(GLenum pname, GLint param);
-    void glFogfv(GLenum pname, const GLfloat *params);
-    void glFogf(GLenum pname, GLfloat param);
-    void glColorMaterial(GLenum face, GLenum mode);
-    void glClipPlane(GLenum plane, const GLdouble *equation);
-    void glVertex4sv(const GLshort *v);
-    void glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w);
-    void glVertex4iv(const GLint *v);
-    void glVertex4i(GLint x, GLint y, GLint z, GLint w);
-    void glVertex4fv(const GLfloat *v);
-    void glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void glVertex4dv(const GLdouble *v);
-    void glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glVertex3sv(const GLshort *v);
-    void glVertex3s(GLshort x, GLshort y, GLshort z);
-    void glVertex3iv(const GLint *v);
-    void glVertex3i(GLint x, GLint y, GLint z);
-    void glVertex3fv(const GLfloat *v);
-    void glVertex3f(GLfloat x, GLfloat y, GLfloat z);
-    void glVertex3dv(const GLdouble *v);
-    void glVertex3d(GLdouble x, GLdouble y, GLdouble z);
-    void glVertex2sv(const GLshort *v);
-    void glVertex2s(GLshort x, GLshort y);
-    void glVertex2iv(const GLint *v);
-    void glVertex2i(GLint x, GLint y);
-    void glVertex2fv(const GLfloat *v);
-    void glVertex2f(GLfloat x, GLfloat y);
-    void glVertex2dv(const GLdouble *v);
-    void glVertex2d(GLdouble x, GLdouble y);
-    void glTexCoord4sv(const GLshort *v);
-    void glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q);
-    void glTexCoord4iv(const GLint *v);
-    void glTexCoord4i(GLint s, GLint t, GLint r, GLint q);
-    void glTexCoord4fv(const GLfloat *v);
-    void glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
-    void glTexCoord4dv(const GLdouble *v);
-    void glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q);
-    void glTexCoord3sv(const GLshort *v);
-    void glTexCoord3s(GLshort s, GLshort t, GLshort r);
-    void glTexCoord3iv(const GLint *v);
-    void glTexCoord3i(GLint s, GLint t, GLint r);
-    void glTexCoord3fv(const GLfloat *v);
-    void glTexCoord3f(GLfloat s, GLfloat t, GLfloat r);
-    void glTexCoord3dv(const GLdouble *v);
-    void glTexCoord3d(GLdouble s, GLdouble t, GLdouble r);
-    void glTexCoord2sv(const GLshort *v);
-    void glTexCoord2s(GLshort s, GLshort t);
-    void glTexCoord2iv(const GLint *v);
-    void glTexCoord2i(GLint s, GLint t);
-    void glTexCoord2fv(const GLfloat *v);
-    void glTexCoord2f(GLfloat s, GLfloat t);
-    void glTexCoord2dv(const GLdouble *v);
-    void glTexCoord2d(GLdouble s, GLdouble t);
-    void glTexCoord1sv(const GLshort *v);
-    void glTexCoord1s(GLshort s);
-    void glTexCoord1iv(const GLint *v);
-    void glTexCoord1i(GLint s);
-    void glTexCoord1fv(const GLfloat *v);
-    void glTexCoord1f(GLfloat s);
-    void glTexCoord1dv(const GLdouble *v);
-    void glTexCoord1d(GLdouble s);
-    void glRectsv(const GLshort *v1, const GLshort *v2);
-    void glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
-    void glRectiv(const GLint *v1, const GLint *v2);
-    void glRecti(GLint x1, GLint y1, GLint x2, GLint y2);
-    void glRectfv(const GLfloat *v1, const GLfloat *v2);
-    void glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
-    void glRectdv(const GLdouble *v1, const GLdouble *v2);
-    void glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
-    void glRasterPos4sv(const GLshort *v);
-    void glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w);
-    void glRasterPos4iv(const GLint *v);
-    void glRasterPos4i(GLint x, GLint y, GLint z, GLint w);
-    void glRasterPos4fv(const GLfloat *v);
-    void glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void glRasterPos4dv(const GLdouble *v);
-    void glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glRasterPos3sv(const GLshort *v);
-    void glRasterPos3s(GLshort x, GLshort y, GLshort z);
-    void glRasterPos3iv(const GLint *v);
-    void glRasterPos3i(GLint x, GLint y, GLint z);
-    void glRasterPos3fv(const GLfloat *v);
-    void glRasterPos3f(GLfloat x, GLfloat y, GLfloat z);
-    void glRasterPos3dv(const GLdouble *v);
-    void glRasterPos3d(GLdouble x, GLdouble y, GLdouble z);
-    void glRasterPos2sv(const GLshort *v);
-    void glRasterPos2s(GLshort x, GLshort y);
-    void glRasterPos2iv(const GLint *v);
-    void glRasterPos2i(GLint x, GLint y);
-    void glRasterPos2fv(const GLfloat *v);
-    void glRasterPos2f(GLfloat x, GLfloat y);
-    void glRasterPos2dv(const GLdouble *v);
-    void glRasterPos2d(GLdouble x, GLdouble y);
-    void glNormal3sv(const GLshort *v);
-    void glNormal3s(GLshort nx, GLshort ny, GLshort nz);
-    void glNormal3iv(const GLint *v);
-    void glNormal3i(GLint nx, GLint ny, GLint nz);
-    void glNormal3fv(const GLfloat *v);
-    void glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz);
-    void glNormal3dv(const GLdouble *v);
-    void glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz);
-    void glNormal3bv(const GLbyte *v);
-    void glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz);
-    void glIndexsv(const GLshort *c);
-    void glIndexs(GLshort c);
-    void glIndexiv(const GLint *c);
-    void glIndexi(GLint c);
-    void glIndexfv(const GLfloat *c);
-    void glIndexf(GLfloat c);
-    void glIndexdv(const GLdouble *c);
-    void glIndexd(GLdouble c);
-    void glEnd();
-    void glEdgeFlagv(const GLboolean *flag);
-    void glEdgeFlag(GLboolean flag);
-    void glColor4usv(const GLushort *v);
-    void glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha);
-    void glColor4uiv(const GLuint *v);
-    void glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha);
-    void glColor4ubv(const GLubyte *v);
-    void glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
-    void glColor4sv(const GLshort *v);
-    void glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha);
-    void glColor4iv(const GLint *v);
-    void glColor4i(GLint red, GLint green, GLint blue, GLint alpha);
-    void glColor4fv(const GLfloat *v);
-    void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glColor4dv(const GLdouble *v);
-    void glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
-    void glColor4bv(const GLbyte *v);
-    void glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
-    void glColor3usv(const GLushort *v);
-    void glColor3us(GLushort red, GLushort green, GLushort blue);
-    void glColor3uiv(const GLuint *v);
-    void glColor3ui(GLuint red, GLuint green, GLuint blue);
-    void glColor3ubv(const GLubyte *v);
-    void glColor3ub(GLubyte red, GLubyte green, GLubyte blue);
-    void glColor3sv(const GLshort *v);
-    void glColor3s(GLshort red, GLshort green, GLshort blue);
-    void glColor3iv(const GLint *v);
-    void glColor3i(GLint red, GLint green, GLint blue);
-    void glColor3fv(const GLfloat *v);
-    void glColor3f(GLfloat red, GLfloat green, GLfloat blue);
-    void glColor3dv(const GLdouble *v);
-    void glColor3d(GLdouble red, GLdouble green, GLdouble blue);
-    void glColor3bv(const GLbyte *v);
-    void glColor3b(GLbyte red, GLbyte green, GLbyte blue);
-    void glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap);
-    void glBegin(GLenum mode);
-    void glListBase(GLuint base);
-    GLuint glGenLists(GLsizei range);
-    void glDeleteLists(GLuint list, GLsizei range);
-    void glCallLists(GLsizei n, GLenum type, const GLvoid *lists);
-    void glCallList(GLuint list);
-    void glEndList();
-    void glNewList(GLuint list, GLenum mode);
-
-    // OpenGL 1.1 deprecated functions
-    void glPushClientAttrib(GLbitfield mask);
-    void glPopClientAttrib();
-    void glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities);
-    GLboolean glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences);
-    void glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer);
-    void glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glEnableClientState(GLenum array);
-    void glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer);
-    void glDisableClientState(GLenum array);
-    void glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glArrayElement(GLint i);
-
-    // OpenGL 1.2 deprecated functions
-    void glResetMinmax(GLenum target);
-    void glResetHistogram(GLenum target);
-    void glMinmax(GLenum target, GLenum internalformat, GLboolean sink);
-    void glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink);
-    void glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
-    void glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
-    void glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column);
-    void glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span);
-    void glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image);
-    void glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
-    void glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glConvolutionParameteri(GLenum target, GLenum pname, GLint params);
-    void glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params);
-    void glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image);
-    void glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image);
-    void glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width);
-    void glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data);
-    void glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table);
-    void glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
-    void glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table);
-
-    // OpenGL 1.3 deprecated functions
-    void glMultTransposeMatrixd(const GLdouble *m);
-    void glMultTransposeMatrixf(const GLfloat *m);
-    void glLoadTransposeMatrixd(const GLdouble *m);
-    void glLoadTransposeMatrixf(const GLfloat *m);
-    void glMultiTexCoord4sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);
-    void glMultiTexCoord4iv(GLenum target, const GLint *v);
-    void glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q);
-    void glMultiTexCoord4fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
-    void glMultiTexCoord4dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
-    void glMultiTexCoord3sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r);
-    void glMultiTexCoord3iv(GLenum target, const GLint *v);
-    void glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r);
-    void glMultiTexCoord3fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r);
-    void glMultiTexCoord3dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r);
-    void glMultiTexCoord2sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord2s(GLenum target, GLshort s, GLshort t);
-    void glMultiTexCoord2iv(GLenum target, const GLint *v);
-    void glMultiTexCoord2i(GLenum target, GLint s, GLint t);
-    void glMultiTexCoord2fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t);
-    void glMultiTexCoord2dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t);
-    void glMultiTexCoord1sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord1s(GLenum target, GLshort s);
-    void glMultiTexCoord1iv(GLenum target, const GLint *v);
-    void glMultiTexCoord1i(GLenum target, GLint s);
-    void glMultiTexCoord1fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord1f(GLenum target, GLfloat s);
-    void glMultiTexCoord1dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord1d(GLenum target, GLdouble s);
-    void glClientActiveTexture(GLenum texture);
-
-    // OpenGL 1.4 deprecated functions
-    void glWindowPos3sv(const GLshort *v);
-    void glWindowPos3s(GLshort x, GLshort y, GLshort z);
-    void glWindowPos3iv(const GLint *v);
-    void glWindowPos3i(GLint x, GLint y, GLint z);
-    void glWindowPos3fv(const GLfloat *v);
-    void glWindowPos3f(GLfloat x, GLfloat y, GLfloat z);
-    void glWindowPos3dv(const GLdouble *v);
-    void glWindowPos3d(GLdouble x, GLdouble y, GLdouble z);
-    void glWindowPos2sv(const GLshort *v);
-    void glWindowPos2s(GLshort x, GLshort y);
-    void glWindowPos2iv(const GLint *v);
-    void glWindowPos2i(GLint x, GLint y);
-    void glWindowPos2fv(const GLfloat *v);
-    void glWindowPos2f(GLfloat x, GLfloat y);
-    void glWindowPos2dv(const GLdouble *v);
-    void glWindowPos2d(GLdouble x, GLdouble y);
-    void glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glSecondaryColor3usv(const GLushort *v);
-    void glSecondaryColor3us(GLushort red, GLushort green, GLushort blue);
-    void glSecondaryColor3uiv(const GLuint *v);
-    void glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue);
-    void glSecondaryColor3ubv(const GLubyte *v);
-    void glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue);
-    void glSecondaryColor3sv(const GLshort *v);
-    void glSecondaryColor3s(GLshort red, GLshort green, GLshort blue);
-    void glSecondaryColor3iv(const GLint *v);
-    void glSecondaryColor3i(GLint red, GLint green, GLint blue);
-    void glSecondaryColor3fv(const GLfloat *v);
-    void glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue);
-    void glSecondaryColor3dv(const GLdouble *v);
-    void glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue);
-    void glSecondaryColor3bv(const GLbyte *v);
-    void glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue);
-    void glFogCoordPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glFogCoorddv(const GLdouble *coord);
-    void glFogCoordd(GLdouble coord);
-    void glFogCoordfv(const GLfloat *coord);
-    void glFogCoordf(GLfloat coord);
-
-    // OpenGL 1.5 deprecated functions
-
-    // OpenGL 2.0 deprecated functions
-    void glVertexAttrib4usv(GLuint index, const GLushort *v);
-    void glVertexAttrib4uiv(GLuint index, const GLuint *v);
-    void glVertexAttrib4ubv(GLuint index, const GLubyte *v);
-    void glVertexAttrib4sv(GLuint index, const GLshort *v);
-    void glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
-    void glVertexAttrib4iv(GLuint index, const GLint *v);
-    void glVertexAttrib4fv(GLuint index, const GLfloat *v);
-    void glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void glVertexAttrib4dv(GLuint index, const GLdouble *v);
-    void glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glVertexAttrib4bv(GLuint index, const GLbyte *v);
-    void glVertexAttrib4Nusv(GLuint index, const GLushort *v);
-    void glVertexAttrib4Nuiv(GLuint index, const GLuint *v);
-    void glVertexAttrib4Nubv(GLuint index, const GLubyte *v);
-    void glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
-    void glVertexAttrib4Nsv(GLuint index, const GLshort *v);
-    void glVertexAttrib4Niv(GLuint index, const GLint *v);
-    void glVertexAttrib4Nbv(GLuint index, const GLbyte *v);
-    void glVertexAttrib3sv(GLuint index, const GLshort *v);
-    void glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z);
-    void glVertexAttrib3fv(GLuint index, const GLfloat *v);
-    void glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z);
-    void glVertexAttrib3dv(GLuint index, const GLdouble *v);
-    void glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z);
-    void glVertexAttrib2sv(GLuint index, const GLshort *v);
-    void glVertexAttrib2s(GLuint index, GLshort x, GLshort y);
-    void glVertexAttrib2fv(GLuint index, const GLfloat *v);
-    void glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y);
-    void glVertexAttrib2dv(GLuint index, const GLdouble *v);
-    void glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y);
-    void glVertexAttrib1sv(GLuint index, const GLshort *v);
-    void glVertexAttrib1s(GLuint index, GLshort x);
-    void glVertexAttrib1fv(GLuint index, const GLfloat *v);
-    void glVertexAttrib1f(GLuint index, GLfloat x);
-    void glVertexAttrib1dv(GLuint index, const GLdouble *v);
-    void glVertexAttrib1d(GLuint index, GLdouble x);
-
-    // OpenGL 2.1 deprecated functions
-
-    // OpenGL 3.0 deprecated functions
-    void glVertexAttribI4usv(GLuint index, const GLushort *v);
-    void glVertexAttribI4ubv(GLuint index, const GLubyte *v);
-    void glVertexAttribI4sv(GLuint index, const GLshort *v);
-    void glVertexAttribI4bv(GLuint index, const GLbyte *v);
-    void glVertexAttribI4uiv(GLuint index, const GLuint *v);
-    void glVertexAttribI3uiv(GLuint index, const GLuint *v);
-    void glVertexAttribI2uiv(GLuint index, const GLuint *v);
-    void glVertexAttribI1uiv(GLuint index, const GLuint *v);
-    void glVertexAttribI4iv(GLuint index, const GLint *v);
-    void glVertexAttribI3iv(GLuint index, const GLint *v);
-    void glVertexAttribI2iv(GLuint index, const GLint *v);
-    void glVertexAttribI1iv(GLuint index, const GLint *v);
-    void glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
-    void glVertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z);
-    void glVertexAttribI2ui(GLuint index, GLuint x, GLuint y);
-    void glVertexAttribI1ui(GLuint index, GLuint x);
-    void glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w);
-    void glVertexAttribI3i(GLuint index, GLint x, GLint y, GLint z);
-    void glVertexAttribI2i(GLuint index, GLint x, GLint y);
-    void glVertexAttribI1i(GLuint index, GLint x);
-
-    // OpenGL 3.1 deprecated functions
-
-    // OpenGL 3.2 deprecated functions
-
-    // OpenGL 3.3 deprecated functions
-
-    // OpenGL 4.0 deprecated functions
-
-    // OpenGL 4.1 deprecated functions
-
-    // OpenGL 4.2 deprecated functions
-
-private:
-    friend class QOpenGLContext;
-
-    static bool isContextCompatible(QOpenGLContext *context);
-    static QOpenGLVersionProfile versionProfile();
-
-    QOpenGLFunctions_1_0_CoreBackend* d_1_0_Core;
-    QOpenGLFunctions_1_1_CoreBackend* d_1_1_Core;
-    QOpenGLFunctions_1_2_CoreBackend* d_1_2_Core;
-    QOpenGLFunctions_1_3_CoreBackend* d_1_3_Core;
-    QOpenGLFunctions_1_4_CoreBackend* d_1_4_Core;
-    QOpenGLFunctions_1_5_CoreBackend* d_1_5_Core;
-    QOpenGLFunctions_2_0_CoreBackend* d_2_0_Core;
-    QOpenGLFunctions_2_1_CoreBackend* d_2_1_Core;
-    QOpenGLFunctions_3_0_CoreBackend* d_3_0_Core;
-    QOpenGLFunctions_3_1_CoreBackend* d_3_1_Core;
-    QOpenGLFunctions_3_2_CoreBackend* d_3_2_Core;
-    QOpenGLFunctions_3_3_CoreBackend* d_3_3_Core;
-    QOpenGLFunctions_4_0_CoreBackend* d_4_0_Core;
-    QOpenGLFunctions_4_1_CoreBackend* d_4_1_Core;
-    QOpenGLFunctions_4_2_CoreBackend* d_4_2_Core;
-    QOpenGLFunctions_1_0_DeprecatedBackend* d_1_0_Deprecated;
-    QOpenGLFunctions_1_1_DeprecatedBackend* d_1_1_Deprecated;
-    QOpenGLFunctions_1_2_DeprecatedBackend* d_1_2_Deprecated;
-    QOpenGLFunctions_1_3_DeprecatedBackend* d_1_3_Deprecated;
-    QOpenGLFunctions_1_4_DeprecatedBackend* d_1_4_Deprecated;
-    void *m_reserved_2_0_Deprecated; // To maintain BC
-    QOpenGLFunctions_3_3_DeprecatedBackend* d_3_3_Deprecated;
-};
-
-// OpenGL 1.0 core functions
-inline void QOpenGLFunctions_4_2_Compatibility::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_0_Core->f.Viewport(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glDepthRange(GLdouble nearVal, GLdouble farVal)
-{
-    d_1_0_Core->f.DepthRange(nearVal, farVal);
-}
-
-inline GLboolean QOpenGLFunctions_4_2_Compatibility::glIsEnabled(GLenum cap)
-{
-    return d_1_0_Core->f.IsEnabled(cap);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetTexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetTexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
-{
-    d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
-}
-
-inline const GLubyte * QOpenGLFunctions_4_2_Compatibility::glGetString(GLenum name)
-{
-    return d_1_0_Core->f.GetString(name);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetIntegerv(GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetIntegerv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetFloatv(GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetFloatv(pname, params);
-}
-
-inline GLenum QOpenGLFunctions_4_2_Compatibility::glGetError()
-{
-    return d_1_0_Core->f.GetError();
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetDoublev(GLenum pname, GLdouble *params)
-{
-    d_1_0_Core->f.GetDoublev(pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetBooleanv(GLenum pname, GLboolean *params)
-{
-    d_1_0_Core->f.GetBooleanv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
-{
-    d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glReadBuffer(GLenum mode)
-{
-    d_1_0_Core->f.ReadBuffer(mode);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glPixelStorei(GLenum pname, GLint param)
-{
-    d_1_0_Core->f.PixelStorei(pname, param);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glPixelStoref(GLenum pname, GLfloat param)
-{
-    d_1_0_Core->f.PixelStoref(pname, param);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glDepthFunc(GLenum func)
-{
-    d_1_0_Core->f.DepthFunc(func);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
-{
-    d_1_0_Core->f.StencilOp(fail, zfail, zpass);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glStencilFunc(GLenum func, GLint ref, GLuint mask)
-{
-    d_1_0_Core->f.StencilFunc(func, ref, mask);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glLogicOp(GLenum opcode)
-{
-    d_1_0_Core->f.LogicOp(opcode);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glBlendFunc(GLenum sfactor, GLenum dfactor)
-{
-    d_1_0_Core->f.BlendFunc(sfactor, dfactor);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glFlush()
-{
-    d_1_0_Core->f.Flush();
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glFinish()
-{
-    d_1_0_Core->f.Finish();
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glEnable(GLenum cap)
-{
-    d_1_0_Core->f.Enable(cap);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glDisable(GLenum cap)
-{
-    d_1_0_Core->f.Disable(cap);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glDepthMask(GLboolean flag)
-{
-    d_1_0_Core->f.DepthMask(flag);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
-{
-    d_1_0_Core->f.ColorMask(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glStencilMask(GLuint mask)
-{
-    d_1_0_Core->f.StencilMask(mask);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glClearDepth(GLdouble depth)
-{
-    d_1_0_Core->f.ClearDepth(depth);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glClearStencil(GLint s)
-{
-    d_1_0_Core->f.ClearStencil(s);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Core->f.ClearColor(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glClear(GLbitfield mask)
-{
-    d_1_0_Core->f.Clear(mask);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glDrawBuffer(GLenum mode)
-{
-    d_1_0_Core->f.DrawBuffer(mode);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Core->f.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Core->f.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_0_Core->f.TexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexParameteri(GLenum target, GLenum pname, GLint param)
-{
-    d_1_0_Core->f.TexParameteri(target, pname, param);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Core->f.TexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
-{
-    d_1_0_Core->f.TexParameterf(target, pname, param);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_0_Core->f.Scissor(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glPolygonMode(GLenum face, GLenum mode)
-{
-    d_1_0_Core->f.PolygonMode(face, mode);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glPointSize(GLfloat size)
-{
-    d_1_0_Core->f.PointSize(size);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glLineWidth(GLfloat width)
-{
-    d_1_0_Core->f.LineWidth(width);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glHint(GLenum target, GLenum mode)
-{
-    d_1_0_Core->f.Hint(target, mode);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glFrontFace(GLenum mode)
-{
-    d_1_0_Core->f.FrontFace(mode);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glCullFace(GLenum mode)
-{
-    d_1_0_Core->f.CullFace(mode);
-}
-
-
-// OpenGL 1.1 core functions
-inline void QOpenGLFunctions_4_2_Compatibility::glIndexubv(const GLubyte *c)
-{
-    d_1_1_Deprecated->f.Indexubv(c);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glIndexub(GLubyte c)
-{
-    d_1_1_Deprecated->f.Indexub(c);
-}
-
-inline GLboolean QOpenGLFunctions_4_2_Compatibility::glIsTexture(GLuint texture)
-{
-    return d_1_1_Core->f.IsTexture(texture);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGenTextures(GLsizei n, GLuint *textures)
-{
-    d_1_1_Core->f.GenTextures(n, textures);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glDeleteTextures(GLsizei n, const GLuint *textures)
-{
-    d_1_1_Core->f.DeleteTextures(n, textures);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glBindTexture(GLenum target, GLuint texture)
-{
-    d_1_1_Core->f.BindTexture(target, texture);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_1_Core->f.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_1_Core->f.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_1_Core->f.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
-{
-    d_1_1_Core->f.CopyTexSubImage1D(target, level, xoffset, x, y, width);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
-{
-    d_1_1_Core->f.CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
-{
-    d_1_1_Core->f.CopyTexImage1D(target, level, internalformat, x, y, width, border);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glPolygonOffset(GLfloat factor, GLfloat units)
-{
-    d_1_1_Core->f.PolygonOffset(factor, units);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetPointerv(GLenum pname, GLvoid* *params)
-{
-    d_1_1_Deprecated->f.GetPointerv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
-{
-    d_1_1_Core->f.DrawElements(mode, count, type, indices);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glDrawArrays(GLenum mode, GLint first, GLsizei count)
-{
-    d_1_1_Core->f.DrawArrays(mode, first, count);
-}
-
-
-// OpenGL 1.2 core functions
-inline void QOpenGLFunctions_4_2_Compatibility::glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_2_Core->f.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_2_Core->f.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_2_Core->f.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
-{
-    d_1_2_Core->f.DrawRangeElements(mode, start, end, count, type, indices);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glBlendEquation(GLenum mode)
-{
-    d_1_2_Core->f.BlendEquation(mode);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_2_Core->f.BlendColor(red, green, blue, alpha);
-}
-
-
-// OpenGL 1.3 core functions
-inline void QOpenGLFunctions_4_2_Compatibility::glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img)
-{
-    d_1_3_Core->f.GetCompressedTexImage(target, level, img);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glSampleCoverage(GLfloat value, GLboolean invert)
-{
-    d_1_3_Core->f.SampleCoverage(value, invert);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glActiveTexture(GLenum texture)
-{
-    d_1_3_Core->f.ActiveTexture(texture);
-}
-
-
-// OpenGL 1.4 core functions
-inline void QOpenGLFunctions_4_2_Compatibility::glPointParameteriv(GLenum pname, const GLint *params)
-{
-    d_1_4_Core->f.PointParameteriv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glPointParameteri(GLenum pname, GLint param)
-{
-    d_1_4_Core->f.PointParameteri(pname, param);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glPointParameterfv(GLenum pname, const GLfloat *params)
-{
-    d_1_4_Core->f.PointParameterfv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glPointParameterf(GLenum pname, GLfloat param)
-{
-    d_1_4_Core->f.PointParameterf(pname, param);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount)
-{
-    d_1_4_Core->f.MultiDrawElements(mode, count, type, indices, drawcount);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
-{
-    d_1_4_Core->f.MultiDrawArrays(mode, first, count, drawcount);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
-{
-    d_1_4_Core->f.BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
-}
-
-
-// OpenGL 1.5 core functions
-inline void QOpenGLFunctions_4_2_Compatibility::glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params)
-{
-    d_1_5_Core->f.GetBufferPointerv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetBufferParameteriv(target, pname, params);
-}
-
-inline GLboolean QOpenGLFunctions_4_2_Compatibility::glUnmapBuffer(GLenum target)
-{
-    return d_1_5_Core->f.UnmapBuffer(target);
-}
-
-inline GLvoid* QOpenGLFunctions_4_2_Compatibility::glMapBuffer(GLenum target, GLenum access)
-{
-    return d_1_5_Core->f.MapBuffer(target, access);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data)
-{
-    d_1_5_Core->f.GetBufferSubData(target, offset, size, data);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data)
-{
-    d_1_5_Core->f.BufferSubData(target, offset, size, data);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)
-{
-    d_1_5_Core->f.BufferData(target, size, data, usage);
-}
-
-inline GLboolean QOpenGLFunctions_4_2_Compatibility::glIsBuffer(GLuint buffer)
-{
-    return d_1_5_Core->f.IsBuffer(buffer);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGenBuffers(GLsizei n, GLuint *buffers)
-{
-    d_1_5_Core->f.GenBuffers(n, buffers);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glDeleteBuffers(GLsizei n, const GLuint *buffers)
-{
-    d_1_5_Core->f.DeleteBuffers(n, buffers);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glBindBuffer(GLenum target, GLuint buffer)
-{
-    d_1_5_Core->f.BindBuffer(target, buffer);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
-{
-    d_1_5_Core->f.GetQueryObjectuiv(id, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetQueryObjectiv(id, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetQueryiv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetQueryiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glEndQuery(GLenum target)
-{
-    d_1_5_Core->f.EndQuery(target);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glBeginQuery(GLenum target, GLuint id)
-{
-    d_1_5_Core->f.BeginQuery(target, id);
-}
-
-inline GLboolean QOpenGLFunctions_4_2_Compatibility::glIsQuery(GLuint id)
-{
-    return d_1_5_Core->f.IsQuery(id);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glDeleteQueries(GLsizei n, const GLuint *ids)
-{
-    d_1_5_Core->f.DeleteQueries(n, ids);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGenQueries(GLsizei n, GLuint *ids)
-{
-    d_1_5_Core->f.GenQueries(n, ids);
-}
-
-
-// OpenGL 2.0 core functions
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer)
-{
-    d_2_0_Core->f.VertexAttribPointer(index, size, type, normalized, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glValidateProgram(GLuint program)
-{
-    d_2_0_Core->f.ValidateProgram(program);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix3fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUniform4iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform4iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUniform3iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform3iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUniform2iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform2iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUniform1iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform1iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUniform4fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform4fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUniform3fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform3fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUniform2fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform2fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUniform1fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform1fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
-{
-    d_2_0_Core->f.Uniform4i(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUniform3i(GLint location, GLint v0, GLint v1, GLint v2)
-{
-    d_2_0_Core->f.Uniform3i(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUniform2i(GLint location, GLint v0, GLint v1)
-{
-    d_2_0_Core->f.Uniform2i(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUniform1i(GLint location, GLint v0)
-{
-    d_2_0_Core->f.Uniform1i(location, v0);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
-{
-    d_2_0_Core->f.Uniform4f(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
-{
-    d_2_0_Core->f.Uniform3f(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUniform2f(GLint location, GLfloat v0, GLfloat v1)
-{
-    d_2_0_Core->f.Uniform2f(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUniform1f(GLint location, GLfloat v0)
-{
-    d_2_0_Core->f.Uniform1f(location, v0);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUseProgram(GLuint program)
-{
-    d_2_0_Core->f.UseProgram(program);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length)
-{
-    d_2_0_Core->f.ShaderSource(shader, count, string, length);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glLinkProgram(GLuint program)
-{
-    d_2_0_Core->f.LinkProgram(program);
-}
-
-inline GLboolean QOpenGLFunctions_4_2_Compatibility::glIsShader(GLuint shader)
-{
-    return d_2_0_Core->f.IsShader(shader);
-}
-
-inline GLboolean QOpenGLFunctions_4_2_Compatibility::glIsProgram(GLuint program)
-{
-    return d_2_0_Core->f.IsProgram(program);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer)
-{
-    d_2_0_Core->f.GetVertexAttribPointerv(index, pname, pointer);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetVertexAttribiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
-{
-    d_2_0_Core->f.GetVertexAttribfv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
-{
-    d_2_0_Core->f.GetVertexAttribdv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetUniformiv(GLuint program, GLint location, GLint *params)
-{
-    d_2_0_Core->f.GetUniformiv(program, location, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetUniformfv(GLuint program, GLint location, GLfloat *params)
-{
-    d_2_0_Core->f.GetUniformfv(program, location, params);
-}
-
-inline GLint QOpenGLFunctions_4_2_Compatibility::glGetUniformLocation(GLuint program, const GLchar *name)
-{
-    return d_2_0_Core->f.GetUniformLocation(program, name);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
-{
-    d_2_0_Core->f.GetShaderSource(shader, bufSize, length, source);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-{
-    d_2_0_Core->f.GetShaderInfoLog(shader, bufSize, length, infoLog);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetShaderiv(GLuint shader, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetShaderiv(shader, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-{
-    d_2_0_Core->f.GetProgramInfoLog(program, bufSize, length, infoLog);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetProgramiv(GLuint program, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetProgramiv(program, pname, params);
-}
-
-inline GLint QOpenGLFunctions_4_2_Compatibility::glGetAttribLocation(GLuint program, const GLchar *name)
-{
-    return d_2_0_Core->f.GetAttribLocation(program, name);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj)
-{
-    d_2_0_Core->f.GetAttachedShaders(program, maxCount, count, obj);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
-{
-    d_2_0_Core->f.GetActiveUniform(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
-{
-    d_2_0_Core->f.GetActiveAttrib(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glEnableVertexAttribArray(GLuint index)
-{
-    d_2_0_Core->f.EnableVertexAttribArray(index);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glDisableVertexAttribArray(GLuint index)
-{
-    d_2_0_Core->f.DisableVertexAttribArray(index);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glDetachShader(GLuint program, GLuint shader)
-{
-    d_2_0_Core->f.DetachShader(program, shader);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glDeleteShader(GLuint shader)
-{
-    d_2_0_Core->f.DeleteShader(shader);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glDeleteProgram(GLuint program)
-{
-    d_2_0_Core->f.DeleteProgram(program);
-}
-
-inline GLuint QOpenGLFunctions_4_2_Compatibility::glCreateShader(GLenum type)
-{
-    return d_2_0_Core->f.CreateShader(type);
-}
-
-inline GLuint QOpenGLFunctions_4_2_Compatibility::glCreateProgram()
-{
-    return d_2_0_Core->f.CreateProgram();
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glCompileShader(GLuint shader)
-{
-    d_2_0_Core->f.CompileShader(shader);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glBindAttribLocation(GLuint program, GLuint index, const GLchar *name)
-{
-    d_2_0_Core->f.BindAttribLocation(program, index, name);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glAttachShader(GLuint program, GLuint shader)
-{
-    d_2_0_Core->f.AttachShader(program, shader);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glStencilMaskSeparate(GLenum face, GLuint mask)
-{
-    d_2_0_Core->f.StencilMaskSeparate(face, mask);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
-{
-    d_2_0_Core->f.StencilFuncSeparate(face, func, ref, mask);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
-{
-    d_2_0_Core->f.StencilOpSeparate(face, sfail, dpfail, dppass);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glDrawBuffers(GLsizei n, const GLenum *bufs)
-{
-    d_2_0_Core->f.DrawBuffers(n, bufs);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
-{
-    d_2_0_Core->f.BlendEquationSeparate(modeRGB, modeAlpha);
-}
-
-
-// OpenGL 2.1 core functions
-inline void QOpenGLFunctions_4_2_Compatibility::glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix4x3fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix3x4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix4x2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix2x4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix3x2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix2x3fv(location, count, transpose, value);
-}
-
-
-// OpenGL 3.0 core functions
-inline GLboolean QOpenGLFunctions_4_2_Compatibility::glIsVertexArray(GLuint array)
-{
-    return d_3_0_Core->f.IsVertexArray(array);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGenVertexArrays(GLsizei n, GLuint *arrays)
-{
-    d_3_0_Core->f.GenVertexArrays(n, arrays);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glDeleteVertexArrays(GLsizei n, const GLuint *arrays)
-{
-    d_3_0_Core->f.DeleteVertexArrays(n, arrays);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glBindVertexArray(GLuint array)
-{
-    d_3_0_Core->f.BindVertexArray(array);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
-{
-    d_3_0_Core->f.FlushMappedBufferRange(target, offset, length);
-}
-
-inline GLvoid* QOpenGLFunctions_4_2_Compatibility::glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
-{
-    return d_3_0_Core->f.MapBufferRange(target, offset, length, access);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
-{
-    d_3_0_Core->f.FramebufferTextureLayer(target, attachment, texture, level, layer);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    d_3_0_Core->f.RenderbufferStorageMultisample(target, samples, internalformat, width, height);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
-{
-    d_3_0_Core->f.BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGenerateMipmap(GLenum target)
-{
-    d_3_0_Core->f.GenerateMipmap(target);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
-{
-    d_3_0_Core->f.FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
-{
-    d_3_0_Core->f.FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
-{
-    d_3_0_Core->f.FramebufferTexture2D(target, attachment, textarget, texture, level);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
-{
-    d_3_0_Core->f.FramebufferTexture1D(target, attachment, textarget, texture, level);
-}
-
-inline GLenum QOpenGLFunctions_4_2_Compatibility::glCheckFramebufferStatus(GLenum target)
-{
-    return d_3_0_Core->f.CheckFramebufferStatus(target);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGenFramebuffers(GLsizei n, GLuint *framebuffers)
-{
-    d_3_0_Core->f.GenFramebuffers(n, framebuffers);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
-{
-    d_3_0_Core->f.DeleteFramebuffers(n, framebuffers);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glBindFramebuffer(GLenum target, GLuint framebuffer)
-{
-    d_3_0_Core->f.BindFramebuffer(target, framebuffer);
-}
-
-inline GLboolean QOpenGLFunctions_4_2_Compatibility::glIsFramebuffer(GLuint framebuffer)
-{
-    return d_3_0_Core->f.IsFramebuffer(framebuffer);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetRenderbufferParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    d_3_0_Core->f.RenderbufferStorage(target, internalformat, width, height);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGenRenderbuffers(GLsizei n, GLuint *renderbuffers)
-{
-    d_3_0_Core->f.GenRenderbuffers(n, renderbuffers);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
-{
-    d_3_0_Core->f.DeleteRenderbuffers(n, renderbuffers);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glBindRenderbuffer(GLenum target, GLuint renderbuffer)
-{
-    d_3_0_Core->f.BindRenderbuffer(target, renderbuffer);
-}
-
-inline GLboolean QOpenGLFunctions_4_2_Compatibility::glIsRenderbuffer(GLuint renderbuffer)
-{
-    return d_3_0_Core->f.IsRenderbuffer(renderbuffer);
-}
-
-inline const GLubyte * QOpenGLFunctions_4_2_Compatibility::glGetStringi(GLenum name, GLuint index)
-{
-    return d_3_0_Core->f.GetStringi(name, index);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
-{
-    d_3_0_Core->f.ClearBufferfi(buffer, drawbuffer, depth, stencil);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
-{
-    d_3_0_Core->f.ClearBufferfv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
-{
-    d_3_0_Core->f.ClearBufferuiv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
-{
-    d_3_0_Core->f.ClearBufferiv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params)
-{
-    d_3_0_Core->f.GetTexParameterIuiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetTexParameterIiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params)
-{
-    d_3_0_Core->f.TexParameterIuiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexParameterIiv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_3_0_Core->f.TexParameterIiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUniform4uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform4uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUniform3uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform3uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUniform2uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform2uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUniform1uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform1uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
-{
-    d_3_0_Core->f.Uniform4ui(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
-{
-    d_3_0_Core->f.Uniform3ui(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUniform2ui(GLint location, GLuint v0, GLuint v1)
-{
-    d_3_0_Core->f.Uniform2ui(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUniform1ui(GLint location, GLuint v0)
-{
-    d_3_0_Core->f.Uniform1ui(location, v0);
-}
-
-inline GLint QOpenGLFunctions_4_2_Compatibility::glGetFragDataLocation(GLuint program, const GLchar *name)
-{
-    return d_3_0_Core->f.GetFragDataLocation(program, name);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name)
-{
-    d_3_0_Core->f.BindFragDataLocation(program, color, name);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetUniformuiv(GLuint program, GLint location, GLuint *params)
-{
-    d_3_0_Core->f.GetUniformuiv(program, location, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
-{
-    d_3_0_Core->f.GetVertexAttribIuiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetVertexAttribIiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_3_0_Core->f.VertexAttribIPointer(index, size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glEndConditionalRender()
-{
-    d_3_0_Core->f.EndConditionalRender();
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glBeginConditionalRender(GLuint id, GLenum mode)
-{
-    d_3_0_Core->f.BeginConditionalRender(id, mode);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glClampColor(GLenum target, GLenum clamp)
-{
-    d_3_0_Core->f.ClampColor(target, clamp);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
-{
-    d_3_0_Core->f.GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode)
-{
-    d_3_0_Core->f.TransformFeedbackVaryings(program, count, varyings, bufferMode);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
-{
-    d_3_0_Core->f.BindBufferBase(target, index, buffer);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
-{
-    d_3_0_Core->f.BindBufferRange(target, index, buffer, offset, size);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glEndTransformFeedback()
-{
-    d_3_0_Core->f.EndTransformFeedback();
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glBeginTransformFeedback(GLenum primitiveMode)
-{
-    d_3_0_Core->f.BeginTransformFeedback(primitiveMode);
-}
-
-inline GLboolean QOpenGLFunctions_4_2_Compatibility::glIsEnabledi(GLenum target, GLuint index)
-{
-    return d_3_0_Core->f.IsEnabledi(target, index);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glDisablei(GLenum target, GLuint index)
-{
-    d_3_0_Core->f.Disablei(target, index);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glEnablei(GLenum target, GLuint index)
-{
-    d_3_0_Core->f.Enablei(target, index);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetIntegeri_v(GLenum target, GLuint index, GLint *data)
-{
-    d_3_0_Core->f.GetIntegeri_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetBooleani_v(GLenum target, GLuint index, GLboolean *data)
-{
-    d_3_0_Core->f.GetBooleani_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
-{
-    d_3_0_Core->f.ColorMaski(index, r, g, b, a);
-}
-
-
-// OpenGL 3.1 core functions
-inline void QOpenGLFunctions_4_2_Compatibility::glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
-{
-    d_3_1_Core->f.CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
-{
-    d_3_1_Core->f.UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
-{
-    d_3_1_Core->f.GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params)
-{
-    d_3_1_Core->f.GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
-}
-
-inline GLuint QOpenGLFunctions_4_2_Compatibility::glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName)
-{
-    return d_3_1_Core->f.GetUniformBlockIndex(program, uniformBlockName);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName)
-{
-    d_3_1_Core->f.GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params)
-{
-    d_3_1_Core->f.GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const *uniformNames, GLuint *uniformIndices)
-{
-    d_3_1_Core->f.GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glPrimitiveRestartIndex(GLuint index)
-{
-    d_3_1_Core->f.PrimitiveRestartIndex(index);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer)
-{
-    d_3_1_Core->f.TexBuffer(target, internalformat, buffer);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount)
-{
-    d_3_1_Core->f.DrawElementsInstanced(mode, count, type, indices, instancecount);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount)
-{
-    d_3_1_Core->f.DrawArraysInstanced(mode, first, count, instancecount);
-}
-
-
-// OpenGL 3.2 core functions
-inline void QOpenGLFunctions_4_2_Compatibility::glSampleMaski(GLuint index, GLbitfield mask)
-{
-    d_3_2_Core->f.SampleMaski(index, mask);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val)
-{
-    d_3_2_Core->f.GetMultisamplefv(pname, index, val);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexImage3DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
-{
-    d_3_2_Core->f.TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexImage2DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
-{
-    d_3_2_Core->f.TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values)
-{
-    d_3_2_Core->f.GetSynciv(sync, pname, bufSize, length, values);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetInteger64v(GLenum pname, GLint64 *params)
-{
-    d_3_2_Core->f.GetInteger64v(pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
-{
-    d_3_2_Core->f.WaitSync(sync, flags, timeout);
-}
-
-inline GLenum QOpenGLFunctions_4_2_Compatibility::glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
-{
-    return d_3_2_Core->f.ClientWaitSync(sync, flags, timeout);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glDeleteSync(GLsync sync)
-{
-    d_3_2_Core->f.DeleteSync(sync);
-}
-
-inline GLboolean QOpenGLFunctions_4_2_Compatibility::glIsSync(GLsync sync)
-{
-    return d_3_2_Core->f.IsSync(sync);
-}
-
-inline GLsync QOpenGLFunctions_4_2_Compatibility::glFenceSync(GLenum condition, GLbitfield flags)
-{
-    return d_3_2_Core->f.FenceSync(condition, flags);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProvokingVertex(GLenum mode)
-{
-    d_3_2_Core->f.ProvokingVertex(mode);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount, const GLint *basevertex)
-{
-    d_3_2_Core->f.MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount, GLint basevertex)
-{
-    d_3_2_Core->f.DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)
-{
-    d_3_2_Core->f.DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)
-{
-    d_3_2_Core->f.DrawElementsBaseVertex(mode, count, type, indices, basevertex);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level)
-{
-    d_3_2_Core->f.FramebufferTexture(target, attachment, texture, level);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params)
-{
-    d_3_2_Core->f.GetBufferParameteri64v(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data)
-{
-    d_3_2_Core->f.GetInteger64i_v(target, index, data);
-}
-
-
-// OpenGL 3.3 core functions
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribP4uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP4uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP4ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribP3uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP3uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP3ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribP2uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP2uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP2ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribP1uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP1uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP1ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glSecondaryColorP3uiv(GLenum type, const GLuint *color)
-{
-    d_3_3_Deprecated->f.SecondaryColorP3uiv(type, color);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glSecondaryColorP3ui(GLenum type, GLuint color)
-{
-    d_3_3_Deprecated->f.SecondaryColorP3ui(type, color);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glColorP4uiv(GLenum type, const GLuint *color)
-{
-    d_3_3_Deprecated->f.ColorP4uiv(type, color);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glColorP4ui(GLenum type, GLuint color)
-{
-    d_3_3_Deprecated->f.ColorP4ui(type, color);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glColorP3uiv(GLenum type, const GLuint *color)
-{
-    d_3_3_Deprecated->f.ColorP3uiv(type, color);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glColorP3ui(GLenum type, GLuint color)
-{
-    d_3_3_Deprecated->f.ColorP3ui(type, color);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glNormalP3uiv(GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.NormalP3uiv(type, coords);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glNormalP3ui(GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.NormalP3ui(type, coords);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP4uiv(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP4ui(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP3uiv(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP3ui(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP2uiv(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP2ui(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP1uiv(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP1ui(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexCoordP4uiv(GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.TexCoordP4uiv(type, coords);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexCoordP4ui(GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.TexCoordP4ui(type, coords);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexCoordP3uiv(GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.TexCoordP3uiv(type, coords);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexCoordP3ui(GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.TexCoordP3ui(type, coords);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexCoordP2uiv(GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.TexCoordP2uiv(type, coords);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexCoordP2ui(GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.TexCoordP2ui(type, coords);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexCoordP1uiv(GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.TexCoordP1uiv(type, coords);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexCoordP1ui(GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.TexCoordP1ui(type, coords);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexP4uiv(GLenum type, const GLuint *value)
-{
-    d_3_3_Deprecated->f.VertexP4uiv(type, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexP4ui(GLenum type, GLuint value)
-{
-    d_3_3_Deprecated->f.VertexP4ui(type, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexP3uiv(GLenum type, const GLuint *value)
-{
-    d_3_3_Deprecated->f.VertexP3uiv(type, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexP3ui(GLenum type, GLuint value)
-{
-    d_3_3_Deprecated->f.VertexP3ui(type, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexP2uiv(GLenum type, const GLuint *value)
-{
-    d_3_3_Deprecated->f.VertexP2uiv(type, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexP2ui(GLenum type, GLuint value)
-{
-    d_3_3_Deprecated->f.VertexP2ui(type, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params)
-{
-    d_3_3_Core->f.GetQueryObjectui64v(id, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params)
-{
-    d_3_3_Core->f.GetQueryObjecti64v(id, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glQueryCounter(GLuint id, GLenum target)
-{
-    d_3_3_Core->f.QueryCounter(id, target);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params)
-{
-    d_3_3_Core->f.GetSamplerParameterIuiv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params)
-{
-    d_3_3_Core->f.GetSamplerParameterfv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params)
-{
-    d_3_3_Core->f.GetSamplerParameterIiv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params)
-{
-    d_3_3_Core->f.GetSamplerParameteriv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param)
-{
-    d_3_3_Core->f.SamplerParameterIuiv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param)
-{
-    d_3_3_Core->f.SamplerParameterIiv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param)
-{
-    d_3_3_Core->f.SamplerParameterfv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
-{
-    d_3_3_Core->f.SamplerParameterf(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param)
-{
-    d_3_3_Core->f.SamplerParameteriv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glSamplerParameteri(GLuint sampler, GLenum pname, GLint param)
-{
-    d_3_3_Core->f.SamplerParameteri(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glBindSampler(GLuint unit, GLuint sampler)
-{
-    d_3_3_Core->f.BindSampler(unit, sampler);
-}
-
-inline GLboolean QOpenGLFunctions_4_2_Compatibility::glIsSampler(GLuint sampler)
-{
-    return d_3_3_Core->f.IsSampler(sampler);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glDeleteSamplers(GLsizei count, const GLuint *samplers)
-{
-    d_3_3_Core->f.DeleteSamplers(count, samplers);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGenSamplers(GLsizei count, GLuint *samplers)
-{
-    d_3_3_Core->f.GenSamplers(count, samplers);
-}
-
-inline GLint QOpenGLFunctions_4_2_Compatibility::glGetFragDataIndex(GLuint program, const GLchar *name)
-{
-    return d_3_3_Core->f.GetFragDataIndex(program, name);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glBindFragDataLocationIndexed(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name)
-{
-    d_3_3_Core->f.BindFragDataLocationIndexed(program, colorNumber, index, name);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribDivisor(GLuint index, GLuint divisor)
-{
-    d_3_3_Core->f.VertexAttribDivisor(index, divisor);
-}
-
-
-// OpenGL 4.0 core functions
-inline void QOpenGLFunctions_4_2_Compatibility::glGetQueryIndexediv(GLenum target, GLuint index, GLenum pname, GLint *params)
-{
-    d_4_0_Core->f.GetQueryIndexediv(target, index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glEndQueryIndexed(GLenum target, GLuint index)
-{
-    d_4_0_Core->f.EndQueryIndexed(target, index);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glBeginQueryIndexed(GLenum target, GLuint index, GLuint id)
-{
-    d_4_0_Core->f.BeginQueryIndexed(target, index, id);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glDrawTransformFeedbackStream(GLenum mode, GLuint id, GLuint stream)
-{
-    d_4_0_Core->f.DrawTransformFeedbackStream(mode, id, stream);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glDrawTransformFeedback(GLenum mode, GLuint id)
-{
-    d_4_0_Core->f.DrawTransformFeedback(mode, id);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glResumeTransformFeedback()
-{
-    d_4_0_Core->f.ResumeTransformFeedback();
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glPauseTransformFeedback()
-{
-    d_4_0_Core->f.PauseTransformFeedback();
-}
-
-inline GLboolean QOpenGLFunctions_4_2_Compatibility::glIsTransformFeedback(GLuint id)
-{
-    return d_4_0_Core->f.IsTransformFeedback(id);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGenTransformFeedbacks(GLsizei n, GLuint *ids)
-{
-    d_4_0_Core->f.GenTransformFeedbacks(n, ids);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids)
-{
-    d_4_0_Core->f.DeleteTransformFeedbacks(n, ids);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glBindTransformFeedback(GLenum target, GLuint id)
-{
-    d_4_0_Core->f.BindTransformFeedback(target, id);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glPatchParameterfv(GLenum pname, const GLfloat *values)
-{
-    d_4_0_Core->f.PatchParameterfv(pname, values);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glPatchParameteri(GLenum pname, GLint value)
-{
-    d_4_0_Core->f.PatchParameteri(pname, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetProgramStageiv(GLuint program, GLenum shadertype, GLenum pname, GLint *values)
-{
-    d_4_0_Core->f.GetProgramStageiv(program, shadertype, pname, values);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetUniformSubroutineuiv(GLenum shadertype, GLint location, GLuint *params)
-{
-    d_4_0_Core->f.GetUniformSubroutineuiv(shadertype, location, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUniformSubroutinesuiv(GLenum shadertype, GLsizei count, const GLuint *indices)
-{
-    d_4_0_Core->f.UniformSubroutinesuiv(shadertype, count, indices);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetActiveSubroutineName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
-{
-    d_4_0_Core->f.GetActiveSubroutineName(program, shadertype, index, bufsize, length, name);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetActiveSubroutineUniformName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
-{
-    d_4_0_Core->f.GetActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetActiveSubroutineUniformiv(GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values)
-{
-    d_4_0_Core->f.GetActiveSubroutineUniformiv(program, shadertype, index, pname, values);
-}
-
-inline GLuint QOpenGLFunctions_4_2_Compatibility::glGetSubroutineIndex(GLuint program, GLenum shadertype, const GLchar *name)
-{
-    return d_4_0_Core->f.GetSubroutineIndex(program, shadertype, name);
-}
-
-inline GLint QOpenGLFunctions_4_2_Compatibility::glGetSubroutineUniformLocation(GLuint program, GLenum shadertype, const GLchar *name)
-{
-    return d_4_0_Core->f.GetSubroutineUniformLocation(program, shadertype, name);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetUniformdv(GLuint program, GLint location, GLdouble *params)
-{
-    d_4_0_Core->f.GetUniformdv(program, location, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUniformMatrix4x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix4x3dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUniformMatrix4x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix4x2dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUniformMatrix3x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix3x4dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUniformMatrix3x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix3x2dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUniformMatrix2x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix2x4dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUniformMatrix2x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix2x3dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix4dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUniformMatrix3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix3dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUniformMatrix2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix2dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUniform4dv(GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_0_Core->f.Uniform4dv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUniform3dv(GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_0_Core->f.Uniform3dv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUniform2dv(GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_0_Core->f.Uniform2dv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUniform1dv(GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_0_Core->f.Uniform1dv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUniform4d(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_4_0_Core->f.Uniform4d(location, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUniform3d(GLint location, GLdouble x, GLdouble y, GLdouble z)
-{
-    d_4_0_Core->f.Uniform3d(location, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUniform2d(GLint location, GLdouble x, GLdouble y)
-{
-    d_4_0_Core->f.Uniform2d(location, x, y);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUniform1d(GLint location, GLdouble x)
-{
-    d_4_0_Core->f.Uniform1d(location, x);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glDrawElementsIndirect(GLenum mode, GLenum type, const GLvoid *indirect)
-{
-    d_4_0_Core->f.DrawElementsIndirect(mode, type, indirect);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glDrawArraysIndirect(GLenum mode, const GLvoid *indirect)
-{
-    d_4_0_Core->f.DrawArraysIndirect(mode, indirect);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glBlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
-{
-    d_4_0_Core->f.BlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glBlendFunci(GLuint buf, GLenum src, GLenum dst)
-{
-    d_4_0_Core->f.BlendFunci(buf, src, dst);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glBlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha)
-{
-    d_4_0_Core->f.BlendEquationSeparatei(buf, modeRGB, modeAlpha);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glBlendEquationi(GLuint buf, GLenum mode)
-{
-    d_4_0_Core->f.BlendEquationi(buf, mode);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMinSampleShading(GLfloat value)
-{
-    d_4_0_Core->f.MinSampleShading(value);
-}
-
-
-// OpenGL 4.1 core functions
-inline void QOpenGLFunctions_4_2_Compatibility::glGetDoublei_v(GLenum target, GLuint index, GLdouble *data)
-{
-    d_4_1_Core->f.GetDoublei_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetFloati_v(GLenum target, GLuint index, GLfloat *data)
-{
-    d_4_1_Core->f.GetFloati_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glDepthRangeIndexed(GLuint index, GLdouble n, GLdouble f)
-{
-    d_4_1_Core->f.DepthRangeIndexed(index, n, f);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glDepthRangeArrayv(GLuint first, GLsizei count, const GLdouble *v)
-{
-    d_4_1_Core->f.DepthRangeArrayv(first, count, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glScissorIndexedv(GLuint index, const GLint *v)
-{
-    d_4_1_Core->f.ScissorIndexedv(index, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glScissorIndexed(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height)
-{
-    d_4_1_Core->f.ScissorIndexed(index, left, bottom, width, height);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glScissorArrayv(GLuint first, GLsizei count, const GLint *v)
-{
-    d_4_1_Core->f.ScissorArrayv(first, count, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glViewportIndexedfv(GLuint index, const GLfloat *v)
-{
-    d_4_1_Core->f.ViewportIndexedfv(index, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glViewportIndexedf(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h)
-{
-    d_4_1_Core->f.ViewportIndexedf(index, x, y, w, h);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glViewportArrayv(GLuint first, GLsizei count, const GLfloat *v)
-{
-    d_4_1_Core->f.ViewportArrayv(first, count, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetVertexAttribLdv(GLuint index, GLenum pname, GLdouble *params)
-{
-    d_4_1_Core->f.GetVertexAttribLdv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribLPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_4_1_Core->f.VertexAttribLPointer(index, size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribL4dv(GLuint index, const GLdouble *v)
-{
-    d_4_1_Core->f.VertexAttribL4dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribL3dv(GLuint index, const GLdouble *v)
-{
-    d_4_1_Core->f.VertexAttribL3dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribL2dv(GLuint index, const GLdouble *v)
-{
-    d_4_1_Core->f.VertexAttribL2dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribL1dv(GLuint index, const GLdouble *v)
-{
-    d_4_1_Core->f.VertexAttribL1dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribL4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_4_1_Core->f.VertexAttribL4d(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribL3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
-{
-    d_4_1_Core->f.VertexAttribL3d(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribL2d(GLuint index, GLdouble x, GLdouble y)
-{
-    d_4_1_Core->f.VertexAttribL2d(index, x, y);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribL1d(GLuint index, GLdouble x)
-{
-    d_4_1_Core->f.VertexAttribL1d(index, x);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-{
-    d_4_1_Core->f.GetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glValidateProgramPipeline(GLuint pipeline)
-{
-    d_4_1_Core->f.ValidateProgramPipeline(pipeline);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniformMatrix4x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4x3dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniformMatrix3x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3x4dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniformMatrix4x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4x2dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniformMatrix2x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2x4dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniformMatrix3x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3x2dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniformMatrix2x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2x3dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniformMatrix4x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4x3fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniformMatrix3x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3x4fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniformMatrix4x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4x2fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniformMatrix2x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2x4fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniformMatrix3x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3x2fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniformMatrix2x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2x3fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniformMatrix4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniformMatrix3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniformMatrix2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniformMatrix4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniformMatrix3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniformMatrix2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform4uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
-{
-    d_4_1_Core->f.ProgramUniform4uiv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
-{
-    d_4_1_Core->f.ProgramUniform4ui(program, location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform4dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniform4dv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform4d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3)
-{
-    d_4_1_Core->f.ProgramUniform4d(program, location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform4fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniform4fv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
-{
-    d_4_1_Core->f.ProgramUniform4f(program, location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform4iv(GLuint program, GLint location, GLsizei count, const GLint *value)
-{
-    d_4_1_Core->f.ProgramUniform4iv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
-{
-    d_4_1_Core->f.ProgramUniform4i(program, location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform3uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
-{
-    d_4_1_Core->f.ProgramUniform3uiv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2)
-{
-    d_4_1_Core->f.ProgramUniform3ui(program, location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform3dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniform3dv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform3d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2)
-{
-    d_4_1_Core->f.ProgramUniform3d(program, location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform3fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniform3fv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
-{
-    d_4_1_Core->f.ProgramUniform3f(program, location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform3iv(GLuint program, GLint location, GLsizei count, const GLint *value)
-{
-    d_4_1_Core->f.ProgramUniform3iv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2)
-{
-    d_4_1_Core->f.ProgramUniform3i(program, location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform2uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
-{
-    d_4_1_Core->f.ProgramUniform2uiv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1)
-{
-    d_4_1_Core->f.ProgramUniform2ui(program, location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform2dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniform2dv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform2d(GLuint program, GLint location, GLdouble v0, GLdouble v1)
-{
-    d_4_1_Core->f.ProgramUniform2d(program, location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform2fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniform2fv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1)
-{
-    d_4_1_Core->f.ProgramUniform2f(program, location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform2iv(GLuint program, GLint location, GLsizei count, const GLint *value)
-{
-    d_4_1_Core->f.ProgramUniform2iv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1)
-{
-    d_4_1_Core->f.ProgramUniform2i(program, location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform1uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
-{
-    d_4_1_Core->f.ProgramUniform1uiv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform1ui(GLuint program, GLint location, GLuint v0)
-{
-    d_4_1_Core->f.ProgramUniform1ui(program, location, v0);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform1dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniform1dv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform1d(GLuint program, GLint location, GLdouble v0)
-{
-    d_4_1_Core->f.ProgramUniform1d(program, location, v0);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform1fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniform1fv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform1f(GLuint program, GLint location, GLfloat v0)
-{
-    d_4_1_Core->f.ProgramUniform1f(program, location, v0);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform1iv(GLuint program, GLint location, GLsizei count, const GLint *value)
-{
-    d_4_1_Core->f.ProgramUniform1iv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform1i(GLuint program, GLint location, GLint v0)
-{
-    d_4_1_Core->f.ProgramUniform1i(program, location, v0);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params)
-{
-    d_4_1_Core->f.GetProgramPipelineiv(pipeline, pname, params);
-}
-
-inline GLboolean QOpenGLFunctions_4_2_Compatibility::glIsProgramPipeline(GLuint pipeline)
-{
-    return d_4_1_Core->f.IsProgramPipeline(pipeline);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGenProgramPipelines(GLsizei n, GLuint *pipelines)
-{
-    d_4_1_Core->f.GenProgramPipelines(n, pipelines);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glDeleteProgramPipelines(GLsizei n, const GLuint *pipelines)
-{
-    d_4_1_Core->f.DeleteProgramPipelines(n, pipelines);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glBindProgramPipeline(GLuint pipeline)
-{
-    d_4_1_Core->f.BindProgramPipeline(pipeline);
-}
-
-inline GLuint QOpenGLFunctions_4_2_Compatibility::glCreateShaderProgramv(GLenum type, GLsizei count, const GLchar* const *strings)
-{
-    return d_4_1_Core->f.CreateShaderProgramv(type, count, strings);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glActiveShaderProgram(GLuint pipeline, GLuint program)
-{
-    d_4_1_Core->f.ActiveShaderProgram(pipeline, program);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program)
-{
-    d_4_1_Core->f.UseProgramStages(pipeline, stages, program);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProgramParameteri(GLuint program, GLenum pname, GLint value)
-{
-    d_4_1_Core->f.ProgramParameteri(program, pname, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid *binary, GLsizei length)
-{
-    d_4_1_Core->f.ProgramBinary(program, binaryFormat, binary, length);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, GLvoid *binary)
-{
-    d_4_1_Core->f.GetProgramBinary(program, bufSize, length, binaryFormat, binary);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glClearDepthf(GLfloat dd)
-{
-    d_4_1_Core->f.ClearDepthf(dd);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glDepthRangef(GLfloat n, GLfloat f)
-{
-    d_4_1_Core->f.DepthRangef(n, f);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision)
-{
-    d_4_1_Core->f.GetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glShaderBinary(GLsizei count, const GLuint *shaders, GLenum binaryformat, const GLvoid *binary, GLsizei length)
-{
-    d_4_1_Core->f.ShaderBinary(count, shaders, binaryformat, binary, length);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glReleaseShaderCompiler()
-{
-    d_4_1_Core->f.ReleaseShaderCompiler();
-}
-
-
-// OpenGL 4.2 core functions
-inline void QOpenGLFunctions_4_2_Compatibility::glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
-{
-    d_4_2_Core->f.TexStorage3D(target, levels, internalformat, width, height, depth);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    d_4_2_Core->f.TexStorage2D(target, levels, internalformat, width, height);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexStorage1D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width)
-{
-    d_4_2_Core->f.TexStorage1D(target, levels, internalformat, width);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMemoryBarrier(GLbitfield barriers)
-{
-    d_4_2_Core->f.MemoryBarrier(barriers);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glBindImageTexture(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format)
-{
-    d_4_2_Core->f.BindImageTexture(unit, texture, level, layered, layer, access, format);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetActiveAtomicCounterBufferiv(GLuint program, GLuint bufferIndex, GLenum pname, GLint *params)
-{
-    d_4_2_Core->f.GetActiveAtomicCounterBufferiv(program, bufferIndex, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params)
-{
-    d_4_2_Core->f.GetInternalformativ(target, internalformat, pname, bufSize, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glDrawTransformFeedbackStreamInstanced(GLenum mode, GLuint id, GLuint stream, GLsizei instancecount)
-{
-    d_4_2_Core->f.DrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glDrawTransformFeedbackInstanced(GLenum mode, GLuint id, GLsizei instancecount)
-{
-    d_4_2_Core->f.DrawTransformFeedbackInstanced(mode, id, instancecount);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glDrawElementsInstancedBaseVertexBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance)
-{
-    d_4_2_Core->f.DrawElementsInstancedBaseVertexBaseInstance(mode, count, type, indices, instancecount, basevertex, baseinstance);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glDrawElementsInstancedBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLuint baseinstance)
-{
-    d_4_2_Core->f.DrawElementsInstancedBaseInstance(mode, count, type, indices, instancecount, baseinstance);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glDrawArraysInstancedBaseInstance(GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance)
-{
-    d_4_2_Core->f.DrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);
-}
-
-
-// OpenGL 1.0 deprecated functions
-inline void QOpenGLFunctions_4_2_Compatibility::glTranslatef(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Translatef(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTranslated(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Translated(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glScalef(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Scalef(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glScaled(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Scaled(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Rotatef(angle, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Rotated(angle, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glPushMatrix()
-{
-    d_1_0_Deprecated->f.PushMatrix();
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glPopMatrix()
-{
-    d_1_0_Deprecated->f.PopMatrix();
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
-{
-    d_1_0_Deprecated->f.Ortho(left, right, bottom, top, zNear, zFar);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMultMatrixd(const GLdouble *m)
-{
-    d_1_0_Deprecated->f.MultMatrixd(m);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMultMatrixf(const GLfloat *m)
-{
-    d_1_0_Deprecated->f.MultMatrixf(m);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMatrixMode(GLenum mode)
-{
-    d_1_0_Deprecated->f.MatrixMode(mode);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glLoadMatrixd(const GLdouble *m)
-{
-    d_1_0_Deprecated->f.LoadMatrixd(m);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glLoadMatrixf(const GLfloat *m)
-{
-    d_1_0_Deprecated->f.LoadMatrixf(m);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glLoadIdentity()
-{
-    d_1_0_Deprecated->f.LoadIdentity();
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
-{
-    d_1_0_Deprecated->f.Frustum(left, right, bottom, top, zNear, zFar);
-}
-
-inline GLboolean QOpenGLFunctions_4_2_Compatibility::glIsList(GLuint list)
-{
-    return d_1_0_Deprecated->f.IsList(list);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetTexGeniv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetTexGenfv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
-{
-    d_1_0_Deprecated->f.GetTexGendv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetTexEnviv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetTexEnviv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetTexEnvfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetPolygonStipple(GLubyte *mask)
-{
-    d_1_0_Deprecated->f.GetPolygonStipple(mask);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetPixelMapusv(GLenum map, GLushort *values)
-{
-    d_1_0_Deprecated->f.GetPixelMapusv(map, values);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetPixelMapuiv(GLenum map, GLuint *values)
-{
-    d_1_0_Deprecated->f.GetPixelMapuiv(map, values);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetPixelMapfv(GLenum map, GLfloat *values)
-{
-    d_1_0_Deprecated->f.GetPixelMapfv(map, values);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetMaterialiv(GLenum face, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetMaterialiv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetMaterialfv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetMapiv(GLenum target, GLenum query, GLint *v)
-{
-    d_1_0_Deprecated->f.GetMapiv(target, query, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetMapfv(GLenum target, GLenum query, GLfloat *v)
-{
-    d_1_0_Deprecated->f.GetMapfv(target, query, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetMapdv(GLenum target, GLenum query, GLdouble *v)
-{
-    d_1_0_Deprecated->f.GetMapdv(target, query, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetLightiv(GLenum light, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetLightiv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetLightfv(GLenum light, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetLightfv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetClipPlane(GLenum plane, GLdouble *equation)
-{
-    d_1_0_Deprecated->f.GetClipPlane(plane, equation);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Deprecated->f.DrawPixels(width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
-{
-    d_1_0_Deprecated->f.CopyPixels(x, y, width, height, type);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values)
-{
-    d_1_0_Deprecated->f.PixelMapusv(map, mapsize, values);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values)
-{
-    d_1_0_Deprecated->f.PixelMapuiv(map, mapsize, values);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values)
-{
-    d_1_0_Deprecated->f.PixelMapfv(map, mapsize, values);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glPixelTransferi(GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.PixelTransferi(pname, param);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glPixelTransferf(GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.PixelTransferf(pname, param);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glPixelZoom(GLfloat xfactor, GLfloat yfactor)
-{
-    d_1_0_Deprecated->f.PixelZoom(xfactor, yfactor);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glAlphaFunc(GLenum func, GLfloat ref)
-{
-    d_1_0_Deprecated->f.AlphaFunc(func, ref);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glEvalPoint2(GLint i, GLint j)
-{
-    d_1_0_Deprecated->f.EvalPoint2(i, j);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
-{
-    d_1_0_Deprecated->f.EvalMesh2(mode, i1, i2, j1, j2);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glEvalPoint1(GLint i)
-{
-    d_1_0_Deprecated->f.EvalPoint1(i);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glEvalMesh1(GLenum mode, GLint i1, GLint i2)
-{
-    d_1_0_Deprecated->f.EvalMesh1(mode, i1, i2);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glEvalCoord2fv(const GLfloat *u)
-{
-    d_1_0_Deprecated->f.EvalCoord2fv(u);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glEvalCoord2f(GLfloat u, GLfloat v)
-{
-    d_1_0_Deprecated->f.EvalCoord2f(u, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glEvalCoord2dv(const GLdouble *u)
-{
-    d_1_0_Deprecated->f.EvalCoord2dv(u);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glEvalCoord2d(GLdouble u, GLdouble v)
-{
-    d_1_0_Deprecated->f.EvalCoord2d(u, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glEvalCoord1fv(const GLfloat *u)
-{
-    d_1_0_Deprecated->f.EvalCoord1fv(u);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glEvalCoord1f(GLfloat u)
-{
-    d_1_0_Deprecated->f.EvalCoord1f(u);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glEvalCoord1dv(const GLdouble *u)
-{
-    d_1_0_Deprecated->f.EvalCoord1dv(u);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glEvalCoord1d(GLdouble u)
-{
-    d_1_0_Deprecated->f.EvalCoord1d(u);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
-{
-    d_1_0_Deprecated->f.MapGrid2f(un, u1, u2, vn, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
-{
-    d_1_0_Deprecated->f.MapGrid2d(un, u1, u2, vn, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
-{
-    d_1_0_Deprecated->f.MapGrid1f(un, u1, u2);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
-{
-    d_1_0_Deprecated->f.MapGrid1d(un, u1, u2);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
-{
-    d_1_0_Deprecated->f.Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
-{
-    d_1_0_Deprecated->f.Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
-{
-    d_1_0_Deprecated->f.Map1f(target, u1, u2, stride, order, points);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
-{
-    d_1_0_Deprecated->f.Map1d(target, u1, u2, stride, order, points);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glPushAttrib(GLbitfield mask)
-{
-    d_1_0_Deprecated->f.PushAttrib(mask);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glPopAttrib()
-{
-    d_1_0_Deprecated->f.PopAttrib();
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glAccum(GLenum op, GLfloat value)
-{
-    d_1_0_Deprecated->f.Accum(op, value);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glIndexMask(GLuint mask)
-{
-    d_1_0_Deprecated->f.IndexMask(mask);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glClearIndex(GLfloat c)
-{
-    d_1_0_Deprecated->f.ClearIndex(c);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Deprecated->f.ClearAccum(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glPushName(GLuint name)
-{
-    d_1_0_Deprecated->f.PushName(name);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glPopName()
-{
-    d_1_0_Deprecated->f.PopName();
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glPassThrough(GLfloat token)
-{
-    d_1_0_Deprecated->f.PassThrough(token);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glLoadName(GLuint name)
-{
-    d_1_0_Deprecated->f.LoadName(name);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glInitNames()
-{
-    d_1_0_Deprecated->f.InitNames();
-}
-
-inline GLint QOpenGLFunctions_4_2_Compatibility::glRenderMode(GLenum mode)
-{
-    return d_1_0_Deprecated->f.RenderMode(mode);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glSelectBuffer(GLsizei size, GLuint *buffer)
-{
-    d_1_0_Deprecated->f.SelectBuffer(size, buffer);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
-{
-    d_1_0_Deprecated->f.FeedbackBuffer(size, type, buffer);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexGeniv(GLenum coord, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.TexGeniv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexGeni(GLenum coord, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.TexGeni(coord, pname, param);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.TexGenfv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexGenf(GLenum coord, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.TexGenf(coord, pname, param);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
-{
-    d_1_0_Deprecated->f.TexGendv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexGend(GLenum coord, GLenum pname, GLdouble param)
-{
-    d_1_0_Deprecated->f.TexGend(coord, pname, param);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexEnviv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.TexEnviv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexEnvi(GLenum target, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.TexEnvi(target, pname, param);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.TexEnvfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexEnvf(GLenum target, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.TexEnvf(target, pname, param);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glShadeModel(GLenum mode)
-{
-    d_1_0_Deprecated->f.ShadeModel(mode);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glPolygonStipple(const GLubyte *mask)
-{
-    d_1_0_Deprecated->f.PolygonStipple(mask);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMaterialiv(GLenum face, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.Materialiv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMateriali(GLenum face, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.Materiali(face, pname, param);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.Materialfv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMaterialf(GLenum face, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.Materialf(face, pname, param);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glLineStipple(GLint factor, GLushort pattern)
-{
-    d_1_0_Deprecated->f.LineStipple(factor, pattern);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glLightModeliv(GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.LightModeliv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glLightModeli(GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.LightModeli(pname, param);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glLightModelfv(GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.LightModelfv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glLightModelf(GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.LightModelf(pname, param);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glLightiv(GLenum light, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.Lightiv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glLighti(GLenum light, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.Lighti(light, pname, param);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glLightfv(GLenum light, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.Lightfv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glLightf(GLenum light, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.Lightf(light, pname, param);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glFogiv(GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.Fogiv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glFogi(GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.Fogi(pname, param);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glFogfv(GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.Fogfv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glFogf(GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.Fogf(pname, param);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glColorMaterial(GLenum face, GLenum mode)
-{
-    d_1_0_Deprecated->f.ColorMaterial(face, mode);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glClipPlane(GLenum plane, const GLdouble *equation)
-{
-    d_1_0_Deprecated->f.ClipPlane(plane, equation);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertex4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Vertex4sv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
-{
-    d_1_0_Deprecated->f.Vertex4s(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertex4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Vertex4iv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertex4i(GLint x, GLint y, GLint z, GLint w)
-{
-    d_1_0_Deprecated->f.Vertex4i(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertex4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Vertex4fv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    d_1_0_Deprecated->f.Vertex4f(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertex4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Vertex4dv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_1_0_Deprecated->f.Vertex4d(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertex3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Vertex3sv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertex3s(GLshort x, GLshort y, GLshort z)
-{
-    d_1_0_Deprecated->f.Vertex3s(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertex3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Vertex3iv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertex3i(GLint x, GLint y, GLint z)
-{
-    d_1_0_Deprecated->f.Vertex3i(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertex3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Vertex3fv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertex3f(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Vertex3f(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertex3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Vertex3dv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertex3d(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Vertex3d(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertex2sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Vertex2sv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertex2s(GLshort x, GLshort y)
-{
-    d_1_0_Deprecated->f.Vertex2s(x, y);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertex2iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Vertex2iv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertex2i(GLint x, GLint y)
-{
-    d_1_0_Deprecated->f.Vertex2i(x, y);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertex2fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Vertex2fv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertex2f(GLfloat x, GLfloat y)
-{
-    d_1_0_Deprecated->f.Vertex2f(x, y);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertex2dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Vertex2dv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertex2d(GLdouble x, GLdouble y)
-{
-    d_1_0_Deprecated->f.Vertex2d(x, y);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord4sv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
-{
-    d_1_0_Deprecated->f.TexCoord4s(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord4iv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
-{
-    d_1_0_Deprecated->f.TexCoord4i(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord4fv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
-{
-    d_1_0_Deprecated->f.TexCoord4f(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord4dv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
-{
-    d_1_0_Deprecated->f.TexCoord4d(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord3sv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord3s(GLshort s, GLshort t, GLshort r)
-{
-    d_1_0_Deprecated->f.TexCoord3s(s, t, r);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord3iv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord3i(GLint s, GLint t, GLint r)
-{
-    d_1_0_Deprecated->f.TexCoord3i(s, t, r);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord3fv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
-{
-    d_1_0_Deprecated->f.TexCoord3f(s, t, r);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord3dv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
-{
-    d_1_0_Deprecated->f.TexCoord3d(s, t, r);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord2sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord2sv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord2s(GLshort s, GLshort t)
-{
-    d_1_0_Deprecated->f.TexCoord2s(s, t);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord2iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord2iv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord2i(GLint s, GLint t)
-{
-    d_1_0_Deprecated->f.TexCoord2i(s, t);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord2fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord2fv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord2f(GLfloat s, GLfloat t)
-{
-    d_1_0_Deprecated->f.TexCoord2f(s, t);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord2dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord2dv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord2d(GLdouble s, GLdouble t)
-{
-    d_1_0_Deprecated->f.TexCoord2d(s, t);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord1sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord1sv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord1s(GLshort s)
-{
-    d_1_0_Deprecated->f.TexCoord1s(s);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord1iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord1iv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord1i(GLint s)
-{
-    d_1_0_Deprecated->f.TexCoord1i(s);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord1fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord1fv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord1f(GLfloat s)
-{
-    d_1_0_Deprecated->f.TexCoord1f(s);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord1dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord1dv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord1d(GLdouble s)
-{
-    d_1_0_Deprecated->f.TexCoord1d(s);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glRectsv(const GLshort *v1, const GLshort *v2)
-{
-    d_1_0_Deprecated->f.Rectsv(v1, v2);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
-{
-    d_1_0_Deprecated->f.Rects(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glRectiv(const GLint *v1, const GLint *v2)
-{
-    d_1_0_Deprecated->f.Rectiv(v1, v2);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
-{
-    d_1_0_Deprecated->f.Recti(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glRectfv(const GLfloat *v1, const GLfloat *v2)
-{
-    d_1_0_Deprecated->f.Rectfv(v1, v2);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
-{
-    d_1_0_Deprecated->f.Rectf(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glRectdv(const GLdouble *v1, const GLdouble *v2)
-{
-    d_1_0_Deprecated->f.Rectdv(v1, v2);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
-{
-    d_1_0_Deprecated->f.Rectd(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glRasterPos4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.RasterPos4sv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
-{
-    d_1_0_Deprecated->f.RasterPos4s(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glRasterPos4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.RasterPos4iv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
-{
-    d_1_0_Deprecated->f.RasterPos4i(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glRasterPos4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.RasterPos4fv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    d_1_0_Deprecated->f.RasterPos4f(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glRasterPos4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.RasterPos4dv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_1_0_Deprecated->f.RasterPos4d(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glRasterPos3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.RasterPos3sv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glRasterPos3s(GLshort x, GLshort y, GLshort z)
-{
-    d_1_0_Deprecated->f.RasterPos3s(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glRasterPos3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.RasterPos3iv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glRasterPos3i(GLint x, GLint y, GLint z)
-{
-    d_1_0_Deprecated->f.RasterPos3i(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glRasterPos3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.RasterPos3fv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.RasterPos3f(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glRasterPos3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.RasterPos3dv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.RasterPos3d(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glRasterPos2sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.RasterPos2sv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glRasterPos2s(GLshort x, GLshort y)
-{
-    d_1_0_Deprecated->f.RasterPos2s(x, y);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glRasterPos2iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.RasterPos2iv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glRasterPos2i(GLint x, GLint y)
-{
-    d_1_0_Deprecated->f.RasterPos2i(x, y);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glRasterPos2fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.RasterPos2fv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glRasterPos2f(GLfloat x, GLfloat y)
-{
-    d_1_0_Deprecated->f.RasterPos2f(x, y);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glRasterPos2dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.RasterPos2dv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glRasterPos2d(GLdouble x, GLdouble y)
-{
-    d_1_0_Deprecated->f.RasterPos2d(x, y);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glNormal3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Normal3sv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glNormal3s(GLshort nx, GLshort ny, GLshort nz)
-{
-    d_1_0_Deprecated->f.Normal3s(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glNormal3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Normal3iv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glNormal3i(GLint nx, GLint ny, GLint nz)
-{
-    d_1_0_Deprecated->f.Normal3i(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glNormal3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Normal3fv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
-{
-    d_1_0_Deprecated->f.Normal3f(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glNormal3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Normal3dv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
-{
-    d_1_0_Deprecated->f.Normal3d(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glNormal3bv(const GLbyte *v)
-{
-    d_1_0_Deprecated->f.Normal3bv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
-{
-    d_1_0_Deprecated->f.Normal3b(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glIndexsv(const GLshort *c)
-{
-    d_1_0_Deprecated->f.Indexsv(c);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glIndexs(GLshort c)
-{
-    d_1_0_Deprecated->f.Indexs(c);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glIndexiv(const GLint *c)
-{
-    d_1_0_Deprecated->f.Indexiv(c);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glIndexi(GLint c)
-{
-    d_1_0_Deprecated->f.Indexi(c);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glIndexfv(const GLfloat *c)
-{
-    d_1_0_Deprecated->f.Indexfv(c);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glIndexf(GLfloat c)
-{
-    d_1_0_Deprecated->f.Indexf(c);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glIndexdv(const GLdouble *c)
-{
-    d_1_0_Deprecated->f.Indexdv(c);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glIndexd(GLdouble c)
-{
-    d_1_0_Deprecated->f.Indexd(c);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glEnd()
-{
-    d_1_0_Deprecated->f.End();
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glEdgeFlagv(const GLboolean *flag)
-{
-    d_1_0_Deprecated->f.EdgeFlagv(flag);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glEdgeFlag(GLboolean flag)
-{
-    d_1_0_Deprecated->f.EdgeFlag(flag);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glColor4usv(const GLushort *v)
-{
-    d_1_0_Deprecated->f.Color4usv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
-{
-    d_1_0_Deprecated->f.Color4us(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glColor4uiv(const GLuint *v)
-{
-    d_1_0_Deprecated->f.Color4uiv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
-{
-    d_1_0_Deprecated->f.Color4ui(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glColor4ubv(const GLubyte *v)
-{
-    d_1_0_Deprecated->f.Color4ubv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
-{
-    d_1_0_Deprecated->f.Color4ub(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glColor4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Color4sv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
-{
-    d_1_0_Deprecated->f.Color4s(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glColor4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Color4iv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
-{
-    d_1_0_Deprecated->f.Color4i(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glColor4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Color4fv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Deprecated->f.Color4f(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glColor4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Color4dv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
-{
-    d_1_0_Deprecated->f.Color4d(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glColor4bv(const GLbyte *v)
-{
-    d_1_0_Deprecated->f.Color4bv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
-{
-    d_1_0_Deprecated->f.Color4b(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glColor3usv(const GLushort *v)
-{
-    d_1_0_Deprecated->f.Color3usv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glColor3us(GLushort red, GLushort green, GLushort blue)
-{
-    d_1_0_Deprecated->f.Color3us(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glColor3uiv(const GLuint *v)
-{
-    d_1_0_Deprecated->f.Color3uiv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glColor3ui(GLuint red, GLuint green, GLuint blue)
-{
-    d_1_0_Deprecated->f.Color3ui(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glColor3ubv(const GLubyte *v)
-{
-    d_1_0_Deprecated->f.Color3ubv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
-{
-    d_1_0_Deprecated->f.Color3ub(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glColor3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Color3sv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glColor3s(GLshort red, GLshort green, GLshort blue)
-{
-    d_1_0_Deprecated->f.Color3s(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glColor3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Color3iv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glColor3i(GLint red, GLint green, GLint blue)
-{
-    d_1_0_Deprecated->f.Color3i(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glColor3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Color3fv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glColor3f(GLfloat red, GLfloat green, GLfloat blue)
-{
-    d_1_0_Deprecated->f.Color3f(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glColor3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Color3dv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glColor3d(GLdouble red, GLdouble green, GLdouble blue)
-{
-    d_1_0_Deprecated->f.Color3d(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glColor3bv(const GLbyte *v)
-{
-    d_1_0_Deprecated->f.Color3bv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glColor3b(GLbyte red, GLbyte green, GLbyte blue)
-{
-    d_1_0_Deprecated->f.Color3b(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
-{
-    d_1_0_Deprecated->f.Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glBegin(GLenum mode)
-{
-    d_1_0_Deprecated->f.Begin(mode);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glListBase(GLuint base)
-{
-    d_1_0_Deprecated->f.ListBase(base);
-}
-
-inline GLuint QOpenGLFunctions_4_2_Compatibility::glGenLists(GLsizei range)
-{
-    return d_1_0_Deprecated->f.GenLists(range);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glDeleteLists(GLuint list, GLsizei range)
-{
-    d_1_0_Deprecated->f.DeleteLists(list, range);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glCallLists(GLsizei n, GLenum type, const GLvoid *lists)
-{
-    d_1_0_Deprecated->f.CallLists(n, type, lists);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glCallList(GLuint list)
-{
-    d_1_0_Deprecated->f.CallList(list);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glEndList()
-{
-    d_1_0_Deprecated->f.EndList();
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glNewList(GLuint list, GLenum mode)
-{
-    d_1_0_Deprecated->f.NewList(list, mode);
-}
-
-
-// OpenGL 1.1 deprecated functions
-inline void QOpenGLFunctions_4_2_Compatibility::glPushClientAttrib(GLbitfield mask)
-{
-    d_1_1_Deprecated->f.PushClientAttrib(mask);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glPopClientAttrib()
-{
-    d_1_1_Deprecated->f.PopClientAttrib();
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities)
-{
-    d_1_1_Deprecated->f.PrioritizeTextures(n, textures, priorities);
-}
-
-inline GLboolean QOpenGLFunctions_4_2_Compatibility::glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
-{
-    return d_1_1_Deprecated->f.AreTexturesResident(n, textures, residences);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.VertexPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.TexCoordPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.NormalPointer(type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.InterleavedArrays(format, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.IndexPointer(type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glEnableClientState(GLenum array)
-{
-    d_1_1_Deprecated->f.EnableClientState(array);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.EdgeFlagPointer(stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glDisableClientState(GLenum array)
-{
-    d_1_1_Deprecated->f.DisableClientState(array);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.ColorPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glArrayElement(GLint i)
-{
-    d_1_1_Deprecated->f.ArrayElement(i);
-}
-
-
-// OpenGL 1.2 deprecated functions
-inline void QOpenGLFunctions_4_2_Compatibility::glResetMinmax(GLenum target)
-{
-    d_1_2_Deprecated->f.ResetMinmax(target);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glResetHistogram(GLenum target)
-{
-    d_1_2_Deprecated->f.ResetHistogram(target);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMinmax(GLenum target, GLenum internalformat, GLboolean sink)
-{
-    d_1_2_Deprecated->f.Minmax(target, internalformat, sink);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
-{
-    d_1_2_Deprecated->f.Histogram(target, width, internalformat, sink);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetMinmaxParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetMinmaxParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
-{
-    d_1_2_Deprecated->f.GetMinmax(target, reset, format, type, values);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetHistogramParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetHistogramParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
-{
-    d_1_2_Deprecated->f.GetHistogram(target, reset, format, type, values);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column)
-{
-    d_1_2_Deprecated->f.SeparableFilter2D(target, internalformat, width, height, format, type, row, column);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span)
-{
-    d_1_2_Deprecated->f.GetSeparableFilter(target, format, type, row, column, span);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetConvolutionParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetConvolutionParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image)
-{
-    d_1_2_Deprecated->f.GetConvolutionFilter(target, format, type, image);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_2_Deprecated->f.CopyConvolutionFilter2D(target, internalformat, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
-{
-    d_1_2_Deprecated->f.CopyConvolutionFilter1D(target, internalformat, x, y, width);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glConvolutionParameteri(GLenum target, GLenum pname, GLint params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameteri(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameterf(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image)
-{
-    d_1_2_Deprecated->f.ConvolutionFilter2D(target, internalformat, width, height, format, type, image);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image)
-{
-    d_1_2_Deprecated->f.ConvolutionFilter1D(target, internalformat, width, format, type, image);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
-{
-    d_1_2_Deprecated->f.CopyColorSubTable(target, start, x, y, width);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data)
-{
-    d_1_2_Deprecated->f.ColorSubTable(target, start, count, format, type, data);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetColorTableParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetColorTableParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table)
-{
-    d_1_2_Deprecated->f.GetColorTable(target, format, type, table);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
-{
-    d_1_2_Deprecated->f.CopyColorTable(target, internalformat, x, y, width);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_2_Deprecated->f.ColorTableParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_2_Deprecated->f.ColorTableParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table)
-{
-    d_1_2_Deprecated->f.ColorTable(target, internalformat, width, format, type, table);
-}
-
-
-// OpenGL 1.3 deprecated functions
-inline void QOpenGLFunctions_4_2_Compatibility::glMultTransposeMatrixd(const GLdouble *m)
-{
-    d_1_3_Deprecated->f.MultTransposeMatrixd(m);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMultTransposeMatrixf(const GLfloat *m)
-{
-    d_1_3_Deprecated->f.MultTransposeMatrixf(m);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glLoadTransposeMatrixd(const GLdouble *m)
-{
-    d_1_3_Deprecated->f.LoadTransposeMatrixd(m);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glLoadTransposeMatrixf(const GLfloat *m)
-{
-    d_1_3_Deprecated->f.LoadTransposeMatrixf(m);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord4sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4sv(target, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4s(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord4iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4iv(target, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4i(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord4fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4fv(target, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4f(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord4dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4dv(target, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4d(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord3sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3sv(target, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3s(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord3iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3iv(target, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3i(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord3fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3fv(target, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3f(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord3dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3dv(target, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3d(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord2sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2sv(target, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord2s(GLenum target, GLshort s, GLshort t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2s(target, s, t);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord2iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2iv(target, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord2i(GLenum target, GLint s, GLint t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2i(target, s, t);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord2fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2fv(target, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2f(target, s, t);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord2dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2dv(target, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2d(target, s, t);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord1sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1sv(target, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord1s(GLenum target, GLshort s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1s(target, s);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord1iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1iv(target, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord1i(GLenum target, GLint s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1i(target, s);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord1fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1fv(target, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord1f(GLenum target, GLfloat s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1f(target, s);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord1dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1dv(target, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord1d(GLenum target, GLdouble s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1d(target, s);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glClientActiveTexture(GLenum texture)
-{
-    d_1_3_Deprecated->f.ClientActiveTexture(texture);
-}
-
-
-// OpenGL 1.4 deprecated functions
-inline void QOpenGLFunctions_4_2_Compatibility::glWindowPos3sv(const GLshort *v)
-{
-    d_1_4_Deprecated->f.WindowPos3sv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glWindowPos3s(GLshort x, GLshort y, GLshort z)
-{
-    d_1_4_Deprecated->f.WindowPos3s(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glWindowPos3iv(const GLint *v)
-{
-    d_1_4_Deprecated->f.WindowPos3iv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glWindowPos3i(GLint x, GLint y, GLint z)
-{
-    d_1_4_Deprecated->f.WindowPos3i(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glWindowPos3fv(const GLfloat *v)
-{
-    d_1_4_Deprecated->f.WindowPos3fv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glWindowPos3f(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_4_Deprecated->f.WindowPos3f(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glWindowPos3dv(const GLdouble *v)
-{
-    d_1_4_Deprecated->f.WindowPos3dv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glWindowPos3d(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_4_Deprecated->f.WindowPos3d(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glWindowPos2sv(const GLshort *v)
-{
-    d_1_4_Deprecated->f.WindowPos2sv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glWindowPos2s(GLshort x, GLshort y)
-{
-    d_1_4_Deprecated->f.WindowPos2s(x, y);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glWindowPos2iv(const GLint *v)
-{
-    d_1_4_Deprecated->f.WindowPos2iv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glWindowPos2i(GLint x, GLint y)
-{
-    d_1_4_Deprecated->f.WindowPos2i(x, y);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glWindowPos2fv(const GLfloat *v)
-{
-    d_1_4_Deprecated->f.WindowPos2fv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glWindowPos2f(GLfloat x, GLfloat y)
-{
-    d_1_4_Deprecated->f.WindowPos2f(x, y);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glWindowPos2dv(const GLdouble *v)
-{
-    d_1_4_Deprecated->f.WindowPos2dv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glWindowPos2d(GLdouble x, GLdouble y)
-{
-    d_1_4_Deprecated->f.WindowPos2d(x, y);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_4_Deprecated->f.SecondaryColorPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glSecondaryColor3usv(const GLushort *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3usv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glSecondaryColor3us(GLushort red, GLushort green, GLushort blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3us(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glSecondaryColor3uiv(const GLuint *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3uiv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3ui(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glSecondaryColor3ubv(const GLubyte *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3ubv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3ub(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glSecondaryColor3sv(const GLshort *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3sv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glSecondaryColor3s(GLshort red, GLshort green, GLshort blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3s(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glSecondaryColor3iv(const GLint *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3iv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glSecondaryColor3i(GLint red, GLint green, GLint blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3i(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glSecondaryColor3fv(const GLfloat *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3fv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3f(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glSecondaryColor3dv(const GLdouble *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3dv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3d(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glSecondaryColor3bv(const GLbyte *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3bv(v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3b(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glFogCoordPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_4_Deprecated->f.FogCoordPointer(type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glFogCoorddv(const GLdouble *coord)
-{
-    d_1_4_Deprecated->f.FogCoorddv(coord);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glFogCoordd(GLdouble coord)
-{
-    d_1_4_Deprecated->f.FogCoordd(coord);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glFogCoordfv(const GLfloat *coord)
-{
-    d_1_4_Deprecated->f.FogCoordfv(coord);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glFogCoordf(GLfloat coord)
-{
-    d_1_4_Deprecated->f.FogCoordf(coord);
-}
-
-
-// OpenGL 1.5 deprecated functions
-
-// OpenGL 2.0 deprecated functions
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4usv(GLuint index, const GLushort *v)
-{
-    d_2_0_Core->f.VertexAttrib4usv(index, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4uiv(GLuint index, const GLuint *v)
-{
-    d_2_0_Core->f.VertexAttrib4uiv(index, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4ubv(GLuint index, const GLubyte *v)
-{
-    d_2_0_Core->f.VertexAttrib4ubv(index, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4sv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib4sv(index, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
-{
-    d_2_0_Core->f.VertexAttrib4s(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4iv(GLuint index, const GLint *v)
-{
-    d_2_0_Core->f.VertexAttrib4iv(index, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4fv(GLuint index, const GLfloat *v)
-{
-    d_2_0_Core->f.VertexAttrib4fv(index, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    d_2_0_Core->f.VertexAttrib4f(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4dv(GLuint index, const GLdouble *v)
-{
-    d_2_0_Core->f.VertexAttrib4dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_2_0_Core->f.VertexAttrib4d(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4bv(GLuint index, const GLbyte *v)
-{
-    d_2_0_Core->f.VertexAttrib4bv(index, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4Nusv(GLuint index, const GLushort *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nusv(index, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4Nuiv(GLuint index, const GLuint *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nuiv(index, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4Nubv(GLuint index, const GLubyte *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nubv(index, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
-{
-    d_2_0_Core->f.VertexAttrib4Nub(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4Nsv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nsv(index, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4Niv(GLuint index, const GLint *v)
-{
-    d_2_0_Core->f.VertexAttrib4Niv(index, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4Nbv(GLuint index, const GLbyte *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nbv(index, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib3sv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib3sv(index, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
-{
-    d_2_0_Core->f.VertexAttrib3s(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib3fv(GLuint index, const GLfloat *v)
-{
-    d_2_0_Core->f.VertexAttrib3fv(index, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
-{
-    d_2_0_Core->f.VertexAttrib3f(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib3dv(GLuint index, const GLdouble *v)
-{
-    d_2_0_Core->f.VertexAttrib3dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
-{
-    d_2_0_Core->f.VertexAttrib3d(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib2sv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib2sv(index, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib2s(GLuint index, GLshort x, GLshort y)
-{
-    d_2_0_Core->f.VertexAttrib2s(index, x, y);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib2fv(GLuint index, const GLfloat *v)
-{
-    d_2_0_Core->f.VertexAttrib2fv(index, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
-{
-    d_2_0_Core->f.VertexAttrib2f(index, x, y);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib2dv(GLuint index, const GLdouble *v)
-{
-    d_2_0_Core->f.VertexAttrib2dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
-{
-    d_2_0_Core->f.VertexAttrib2d(index, x, y);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib1sv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib1sv(index, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib1s(GLuint index, GLshort x)
-{
-    d_2_0_Core->f.VertexAttrib1s(index, x);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib1fv(GLuint index, const GLfloat *v)
-{
-    d_2_0_Core->f.VertexAttrib1fv(index, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib1f(GLuint index, GLfloat x)
-{
-    d_2_0_Core->f.VertexAttrib1f(index, x);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib1dv(GLuint index, const GLdouble *v)
-{
-    d_2_0_Core->f.VertexAttrib1dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib1d(GLuint index, GLdouble x)
-{
-    d_2_0_Core->f.VertexAttrib1d(index, x);
-}
-
-
-// OpenGL 2.1 deprecated functions
-
-// OpenGL 3.0 deprecated functions
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI4usv(GLuint index, const GLushort *v)
-{
-    d_3_0_Core->f.VertexAttribI4usv(index, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI4ubv(GLuint index, const GLubyte *v)
-{
-    d_3_0_Core->f.VertexAttribI4ubv(index, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI4sv(GLuint index, const GLshort *v)
-{
-    d_3_0_Core->f.VertexAttribI4sv(index, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI4bv(GLuint index, const GLbyte *v)
-{
-    d_3_0_Core->f.VertexAttribI4bv(index, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI4uiv(GLuint index, const GLuint *v)
-{
-    d_3_0_Core->f.VertexAttribI4uiv(index, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI3uiv(GLuint index, const GLuint *v)
-{
-    d_3_0_Core->f.VertexAttribI3uiv(index, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI2uiv(GLuint index, const GLuint *v)
-{
-    d_3_0_Core->f.VertexAttribI2uiv(index, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI1uiv(GLuint index, const GLuint *v)
-{
-    d_3_0_Core->f.VertexAttribI1uiv(index, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI4iv(GLuint index, const GLint *v)
-{
-    d_3_0_Core->f.VertexAttribI4iv(index, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI3iv(GLuint index, const GLint *v)
-{
-    d_3_0_Core->f.VertexAttribI3iv(index, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI2iv(GLuint index, const GLint *v)
-{
-    d_3_0_Core->f.VertexAttribI2iv(index, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI1iv(GLuint index, const GLint *v)
-{
-    d_3_0_Core->f.VertexAttribI1iv(index, v);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
-{
-    d_3_0_Core->f.VertexAttribI4ui(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z)
-{
-    d_3_0_Core->f.VertexAttribI3ui(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI2ui(GLuint index, GLuint x, GLuint y)
-{
-    d_3_0_Core->f.VertexAttribI2ui(index, x, y);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI1ui(GLuint index, GLuint x)
-{
-    d_3_0_Core->f.VertexAttribI1ui(index, x);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
-{
-    d_3_0_Core->f.VertexAttribI4i(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI3i(GLuint index, GLint x, GLint y, GLint z)
-{
-    d_3_0_Core->f.VertexAttribI3i(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI2i(GLuint index, GLint x, GLint y)
-{
-    d_3_0_Core->f.VertexAttribI2i(index, x, y);
-}
-
-inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI1i(GLuint index, GLint x)
-{
-    d_3_0_Core->f.VertexAttribI1i(index, x);
-}
-
-
-// OpenGL 3.1 deprecated functions
-
-// OpenGL 3.2 deprecated functions
-
-// OpenGL 3.3 deprecated functions
-
-// OpenGL 4.0 deprecated functions
-
-// OpenGL 4.1 deprecated functions
-
-// OpenGL 4.2 deprecated functions
-
-
-QT_END_NAMESPACE
-
-#ifdef Q_OS_WIN
-#pragma pop_macro("MemoryBarrier")
-#endif
-
-#endif // QT_NO_OPENGL && !QT_OPENGL_ES_2
-
-#endif
diff --git a/src/gui/opengl/qopenglfunctions_4_2_core.cpp b/src/gui/opengl/qopenglfunctions_4_2_core.cpp
deleted file mode 100644
index 38dbe1b596..0000000000
--- a/src/gui/opengl/qopenglfunctions_4_2_core.cpp
+++ /dev/null
@@ -1,251 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#include "qopenglfunctions_4_2_core.h"
-#include "qopenglcontext.h"
-
-QT_BEGIN_NAMESPACE
-
-/*!
-    \class QOpenGLFunctions_4_2_Core
-    \inmodule QtGui
-    \since 5.1
-    \wrapper
-    \brief The QOpenGLFunctions_4_2_Core class provides all functions for OpenGL 4.2 core profile.
-
-    This class is a wrapper for functions from OpenGL 4.2 core profile.
-    See reference pages on \l {http://www.opengl.org/sdk/docs/}{opengl.org}
-    for function documentation.
-
-    \sa QAbstractOpenGLFunctions
-*/
-
-QOpenGLFunctions_4_2_Core::QOpenGLFunctions_4_2_Core()
- : QAbstractOpenGLFunctions()
- , d_1_0_Core(nullptr)
- , d_1_1_Core(nullptr)
- , d_1_2_Core(nullptr)
- , d_1_3_Core(nullptr)
- , d_1_4_Core(nullptr)
- , d_1_5_Core(nullptr)
- , d_2_0_Core(nullptr)
- , d_2_1_Core(nullptr)
- , d_3_0_Core(nullptr)
- , d_3_1_Core(nullptr)
- , d_3_2_Core(nullptr)
- , d_3_3_Core(nullptr)
- , d_4_0_Core(nullptr)
- , d_4_1_Core(nullptr)
- , d_4_2_Core(nullptr)
-{
-}
-
-QOpenGLFunctions_4_2_Core::~QOpenGLFunctions_4_2_Core()
-{
-    if (d_1_0_Core) {
-        d_1_0_Core->refs.deref();
-        Q_ASSERT(d_1_0_Core->refs.loadRelaxed());
-    }
-    if (d_1_1_Core) {
-        d_1_1_Core->refs.deref();
-        Q_ASSERT(d_1_1_Core->refs.loadRelaxed());
-    }
-    if (d_1_2_Core) {
-        d_1_2_Core->refs.deref();
-        Q_ASSERT(d_1_2_Core->refs.loadRelaxed());
-    }
-    if (d_1_3_Core) {
-        d_1_3_Core->refs.deref();
-        Q_ASSERT(d_1_3_Core->refs.loadRelaxed());
-    }
-    if (d_1_4_Core) {
-        d_1_4_Core->refs.deref();
-        Q_ASSERT(d_1_4_Core->refs.loadRelaxed());
-    }
-    if (d_1_5_Core) {
-        d_1_5_Core->refs.deref();
-        Q_ASSERT(d_1_5_Core->refs.loadRelaxed());
-    }
-    if (d_2_0_Core) {
-        d_2_0_Core->refs.deref();
-        Q_ASSERT(d_2_0_Core->refs.loadRelaxed());
-    }
-    if (d_2_1_Core) {
-        d_2_1_Core->refs.deref();
-        Q_ASSERT(d_2_1_Core->refs.loadRelaxed());
-    }
-    if (d_3_0_Core) {
-        d_3_0_Core->refs.deref();
-        Q_ASSERT(d_3_0_Core->refs.loadRelaxed());
-    }
-    if (d_3_1_Core) {
-        d_3_1_Core->refs.deref();
-        Q_ASSERT(d_3_1_Core->refs.loadRelaxed());
-    }
-    if (d_3_2_Core) {
-        d_3_2_Core->refs.deref();
-        Q_ASSERT(d_3_2_Core->refs.loadRelaxed());
-    }
-    if (d_3_3_Core) {
-        d_3_3_Core->refs.deref();
-        Q_ASSERT(d_3_3_Core->refs.loadRelaxed());
-    }
-    if (d_4_0_Core) {
-        d_4_0_Core->refs.deref();
-        Q_ASSERT(d_4_0_Core->refs.loadRelaxed());
-    }
-    if (d_4_1_Core) {
-        d_4_1_Core->refs.deref();
-        Q_ASSERT(d_4_1_Core->refs.loadRelaxed());
-    }
-    if (d_4_2_Core) {
-        d_4_2_Core->refs.deref();
-        Q_ASSERT(d_4_2_Core->refs.loadRelaxed());
-    }
-}
-
-bool QOpenGLFunctions_4_2_Core::initializeOpenGLFunctions()
-{
-    if ( isInitialized() )
-        return true;
-
-    QOpenGLContext* context = QOpenGLContext::currentContext();
-
-    // If owned by a context object make sure it is current.
-    // Also check that current context is capable of resolving all needed functions
-    if (((owningContext() && owningContext() == context) || !owningContext())
-        && QOpenGLFunctions_4_2_Core::isContextCompatible(context))
-    {
-        // Associate with private implementation, creating if necessary
-        // Function pointers in the backends are resolved at creation time
-        QOpenGLVersionFunctionsBackend* d = nullptr;
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        d_1_3_Core = static_cast<QOpenGLFunctions_1_3_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        d_1_4_Core = static_cast<QOpenGLFunctions_1_4_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        d_1_5_Core = static_cast<QOpenGLFunctions_1_5_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        d_2_0_Core = static_cast<QOpenGLFunctions_2_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        d_2_1_Core = static_cast<QOpenGLFunctions_2_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        d_3_0_Core = static_cast<QOpenGLFunctions_3_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
-        d_3_1_Core = static_cast<QOpenGLFunctions_3_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
-        d_3_2_Core = static_cast<QOpenGLFunctions_3_2_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_CoreBackend::versionStatus());
-        d_3_3_Core = static_cast<QOpenGLFunctions_3_3_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_0_CoreBackend::versionStatus());
-        d_4_0_Core = static_cast<QOpenGLFunctions_4_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_1_CoreBackend::versionStatus());
-        d_4_1_Core = static_cast<QOpenGLFunctions_4_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_2_CoreBackend::versionStatus());
-        d_4_2_Core = static_cast<QOpenGLFunctions_4_2_CoreBackend*>(d);
-        d->refs.ref();
-
-        QAbstractOpenGLFunctions::initializeOpenGLFunctions();
-    }
-    return isInitialized();
-}
-
-bool QOpenGLFunctions_4_2_Core::isContextCompatible(QOpenGLContext *context)
-{
-    Q_ASSERT(context);
-    QSurfaceFormat f = context->format();
-    const QPair<int, int> v = qMakePair(f.majorVersion(), f.minorVersion());
-    if (v < qMakePair(4, 2))
-        return false;
-
-    return true;
-}
-
-QOpenGLVersionProfile QOpenGLFunctions_4_2_Core::versionProfile()
-{
-    QOpenGLVersionProfile v;
-    v.setVersion(4, 2);
-    v.setProfile(QSurfaceFormat::CoreProfile);
-    return v;
-}
-
-QT_END_NAMESPACE
diff --git a/src/gui/opengl/qopenglfunctions_4_2_core.h b/src/gui/opengl/qopenglfunctions_4_2_core.h
deleted file mode 100644
index 5ca98e9808..0000000000
--- a/src/gui/opengl/qopenglfunctions_4_2_core.h
+++ /dev/null
@@ -1,3042 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#ifndef QOPENGLVERSIONFUNCTIONS_4_2_CORE_H
-#define QOPENGLVERSIONFUNCTIONS_4_2_CORE_H
-
-#include <QtGui/qtguiglobal.h>
-
-#if !defined(QT_NO_OPENGL) && !defined(QT_OPENGL_ES_2)
-
-#include <QtGui/QOpenGLVersionFunctions>
-#include <QtGui/qopenglcontext.h>
-
-// MemoryBarrier is a macro on some architectures on Windows
-#ifdef Q_OS_WIN
-#pragma push_macro("MemoryBarrier")
-#undef MemoryBarrier
-#endif
-
-QT_BEGIN_NAMESPACE
-
-class Q_GUI_EXPORT QOpenGLFunctions_4_2_Core : public QAbstractOpenGLFunctions
-{
-public:
-    QOpenGLFunctions_4_2_Core();
-    ~QOpenGLFunctions_4_2_Core();
-
-    bool initializeOpenGLFunctions() override;
-
-    // OpenGL 1.0 core functions
-    void glViewport(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glDepthRange(GLdouble nearVal, GLdouble farVal);
-    GLboolean glIsEnabled(GLenum cap);
-    void glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params);
-    void glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params);
-    void glGetTexParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
-    const GLubyte * glGetString(GLenum name);
-    void glGetIntegerv(GLenum pname, GLint *params);
-    void glGetFloatv(GLenum pname, GLfloat *params);
-    GLenum glGetError();
-    void glGetDoublev(GLenum pname, GLdouble *params);
-    void glGetBooleanv(GLenum pname, GLboolean *params);
-    void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
-    void glReadBuffer(GLenum mode);
-    void glPixelStorei(GLenum pname, GLint param);
-    void glPixelStoref(GLenum pname, GLfloat param);
-    void glDepthFunc(GLenum func);
-    void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass);
-    void glStencilFunc(GLenum func, GLint ref, GLuint mask);
-    void glLogicOp(GLenum opcode);
-    void glBlendFunc(GLenum sfactor, GLenum dfactor);
-    void glFlush();
-    void glFinish();
-    void glEnable(GLenum cap);
-    void glDisable(GLenum cap);
-    void glDepthMask(GLboolean flag);
-    void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
-    void glStencilMask(GLuint mask);
-    void glClearDepth(GLdouble depth);
-    void glClearStencil(GLint s);
-    void glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glClear(GLbitfield mask);
-    void glDrawBuffer(GLenum mode);
-    void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glTexParameteri(GLenum target, GLenum pname, GLint param);
-    void glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glTexParameterf(GLenum target, GLenum pname, GLfloat param);
-    void glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glPolygonMode(GLenum face, GLenum mode);
-    void glPointSize(GLfloat size);
-    void glLineWidth(GLfloat width);
-    void glHint(GLenum target, GLenum mode);
-    void glFrontFace(GLenum mode);
-    void glCullFace(GLenum mode);
-
-    // OpenGL 1.1 core functions
-    void glIndexubv(const GLubyte *c);
-    void glIndexub(GLubyte c);
-    GLboolean glIsTexture(GLuint texture);
-    void glGenTextures(GLsizei n, GLuint *textures);
-    void glDeleteTextures(GLsizei n, const GLuint *textures);
-    void glBindTexture(GLenum target, GLuint texture);
-    void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
-    void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
-    void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
-    void glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
-    void glPolygonOffset(GLfloat factor, GLfloat units);
-    void glGetPointerv(GLenum pname, GLvoid* *params);
-    void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
-    void glDrawArrays(GLenum mode, GLint first, GLsizei count);
-
-    // OpenGL 1.2 core functions
-    void glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices);
-    void glBlendEquation(GLenum mode);
-    void glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-
-    // OpenGL 1.3 core functions
-    void glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img);
-    void glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glSampleCoverage(GLfloat value, GLboolean invert);
-    void glActiveTexture(GLenum texture);
-
-    // OpenGL 1.4 core functions
-    void glPointParameteriv(GLenum pname, const GLint *params);
-    void glPointParameteri(GLenum pname, GLint param);
-    void glPointParameterfv(GLenum pname, const GLfloat *params);
-    void glPointParameterf(GLenum pname, GLfloat param);
-    void glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount);
-    void glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount);
-    void glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
-
-    // OpenGL 1.5 core functions
-    void glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params);
-    void glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params);
-    GLboolean glUnmapBuffer(GLenum target);
-    GLvoid* glMapBuffer(GLenum target, GLenum access);
-    void glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data);
-    void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data);
-    void glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage);
-    GLboolean glIsBuffer(GLuint buffer);
-    void glGenBuffers(GLsizei n, GLuint *buffers);
-    void glDeleteBuffers(GLsizei n, const GLuint *buffers);
-    void glBindBuffer(GLenum target, GLuint buffer);
-    void glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params);
-    void glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params);
-    void glGetQueryiv(GLenum target, GLenum pname, GLint *params);
-    void glEndQuery(GLenum target);
-    void glBeginQuery(GLenum target, GLuint id);
-    GLboolean glIsQuery(GLuint id);
-    void glDeleteQueries(GLsizei n, const GLuint *ids);
-    void glGenQueries(GLsizei n, GLuint *ids);
-
-    // OpenGL 2.0 core functions
-    void glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer);
-    void glValidateProgram(GLuint program);
-    void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniform4iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform3iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform2iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform1iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform4fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform3fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform2fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform1fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
-    void glUniform3i(GLint location, GLint v0, GLint v1, GLint v2);
-    void glUniform2i(GLint location, GLint v0, GLint v1);
-    void glUniform1i(GLint location, GLint v0);
-    void glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
-    void glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
-    void glUniform2f(GLint location, GLfloat v0, GLfloat v1);
-    void glUniform1f(GLint location, GLfloat v0);
-    void glUseProgram(GLuint program);
-    void glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length);
-    void glLinkProgram(GLuint program);
-    GLboolean glIsShader(GLuint shader);
-    GLboolean glIsProgram(GLuint program);
-    void glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer);
-    void glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params);
-    void glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params);
-    void glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params);
-    void glGetUniformiv(GLuint program, GLint location, GLint *params);
-    void glGetUniformfv(GLuint program, GLint location, GLfloat *params);
-    GLint glGetUniformLocation(GLuint program, const GLchar *name);
-    void glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source);
-    void glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void glGetShaderiv(GLuint shader, GLenum pname, GLint *params);
-    void glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void glGetProgramiv(GLuint program, GLenum pname, GLint *params);
-    GLint glGetAttribLocation(GLuint program, const GLchar *name);
-    void glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj);
-    void glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
-    void glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
-    void glEnableVertexAttribArray(GLuint index);
-    void glDisableVertexAttribArray(GLuint index);
-    void glDetachShader(GLuint program, GLuint shader);
-    void glDeleteShader(GLuint shader);
-    void glDeleteProgram(GLuint program);
-    GLuint glCreateShader(GLenum type);
-    GLuint glCreateProgram();
-    void glCompileShader(GLuint shader);
-    void glBindAttribLocation(GLuint program, GLuint index, const GLchar *name);
-    void glAttachShader(GLuint program, GLuint shader);
-    void glStencilMaskSeparate(GLenum face, GLuint mask);
-    void glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask);
-    void glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);
-    void glDrawBuffers(GLsizei n, const GLenum *bufs);
-    void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha);
-
-    // OpenGL 2.1 core functions
-    void glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-
-    // OpenGL 3.0 core functions
-    GLboolean glIsVertexArray(GLuint array);
-    void glGenVertexArrays(GLsizei n, GLuint *arrays);
-    void glDeleteVertexArrays(GLsizei n, const GLuint *arrays);
-    void glBindVertexArray(GLuint array);
-    void glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length);
-    GLvoid* glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
-    void glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
-    void glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
-    void glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
-    void glGenerateMipmap(GLenum target);
-    void glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params);
-    void glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
-    void glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset);
-    void glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
-    void glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
-    GLenum glCheckFramebufferStatus(GLenum target);
-    void glGenFramebuffers(GLsizei n, GLuint *framebuffers);
-    void glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers);
-    void glBindFramebuffer(GLenum target, GLuint framebuffer);
-    GLboolean glIsFramebuffer(GLuint framebuffer);
-    void glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
-    void glGenRenderbuffers(GLsizei n, GLuint *renderbuffers);
-    void glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers);
-    void glBindRenderbuffer(GLenum target, GLuint renderbuffer);
-    GLboolean glIsRenderbuffer(GLuint renderbuffer);
-    const GLubyte * glGetStringi(GLenum name, GLuint index);
-    void glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
-    void glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value);
-    void glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value);
-    void glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value);
-    void glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params);
-    void glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params);
-    void glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params);
-    void glTexParameterIiv(GLenum target, GLenum pname, const GLint *params);
-    void glUniform4uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform3uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform2uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform1uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
-    void glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2);
-    void glUniform2ui(GLint location, GLuint v0, GLuint v1);
-    void glUniform1ui(GLint location, GLuint v0);
-    GLint glGetFragDataLocation(GLuint program, const GLchar *name);
-    void glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name);
-    void glGetUniformuiv(GLuint program, GLint location, GLuint *params);
-    void glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params);
-    void glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params);
-    void glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glEndConditionalRender();
-    void glBeginConditionalRender(GLuint id, GLenum mode);
-    void glClampColor(GLenum target, GLenum clamp);
-    void glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name);
-    void glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode);
-    void glBindBufferBase(GLenum target, GLuint index, GLuint buffer);
-    void glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
-    void glEndTransformFeedback();
-    void glBeginTransformFeedback(GLenum primitiveMode);
-    GLboolean glIsEnabledi(GLenum target, GLuint index);
-    void glDisablei(GLenum target, GLuint index);
-    void glEnablei(GLenum target, GLuint index);
-    void glGetIntegeri_v(GLenum target, GLuint index, GLint *data);
-    void glGetBooleani_v(GLenum target, GLuint index, GLboolean *data);
-    void glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a);
-
-    // OpenGL 3.1 core functions
-    void glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
-    void glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);
-    void glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName);
-    void glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params);
-    GLuint glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName);
-    void glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName);
-    void glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params);
-    void glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const *uniformNames, GLuint *uniformIndices);
-    void glPrimitiveRestartIndex(GLuint index);
-    void glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer);
-    void glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount);
-    void glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount);
-
-    // OpenGL 3.2 core functions
-    void glSampleMaski(GLuint index, GLbitfield mask);
-    void glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val);
-    void glTexImage3DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
-    void glTexImage2DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
-    void glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values);
-    void glGetInteger64v(GLenum pname, GLint64 *params);
-    void glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout);
-    GLenum glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout);
-    void glDeleteSync(GLsync sync);
-    GLboolean glIsSync(GLsync sync);
-    GLsync glFenceSync(GLenum condition, GLbitfield flags);
-    void glProvokingVertex(GLenum mode);
-    void glMultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount, const GLint *basevertex);
-    void glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount, GLint basevertex);
-    void glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex);
-    void glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex);
-    void glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level);
-    void glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params);
-    void glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data);
-
-    // OpenGL 3.3 core functions
-    void glVertexAttribP4uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glVertexAttribP3uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glVertexAttribP2uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glVertexAttribP1uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glSecondaryColorP3uiv(GLenum type, const GLuint *color);
-    void glSecondaryColorP3ui(GLenum type, GLuint color);
-    void glColorP4uiv(GLenum type, const GLuint *color);
-    void glColorP4ui(GLenum type, GLuint color);
-    void glColorP3uiv(GLenum type, const GLuint *color);
-    void glColorP3ui(GLenum type, GLuint color);
-    void glNormalP3uiv(GLenum type, const GLuint *coords);
-    void glNormalP3ui(GLenum type, GLuint coords);
-    void glMultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint *coords);
-    void glMultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords);
-    void glMultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint *coords);
-    void glMultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords);
-    void glMultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint *coords);
-    void glMultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords);
-    void glMultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint *coords);
-    void glMultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords);
-    void glTexCoordP4uiv(GLenum type, const GLuint *coords);
-    void glTexCoordP4ui(GLenum type, GLuint coords);
-    void glTexCoordP3uiv(GLenum type, const GLuint *coords);
-    void glTexCoordP3ui(GLenum type, GLuint coords);
-    void glTexCoordP2uiv(GLenum type, const GLuint *coords);
-    void glTexCoordP2ui(GLenum type, GLuint coords);
-    void glTexCoordP1uiv(GLenum type, const GLuint *coords);
-    void glTexCoordP1ui(GLenum type, GLuint coords);
-    void glVertexP4uiv(GLenum type, const GLuint *value);
-    void glVertexP4ui(GLenum type, GLuint value);
-    void glVertexP3uiv(GLenum type, const GLuint *value);
-    void glVertexP3ui(GLenum type, GLuint value);
-    void glVertexP2uiv(GLenum type, const GLuint *value);
-    void glVertexP2ui(GLenum type, GLuint value);
-    void glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params);
-    void glGetQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params);
-    void glQueryCounter(GLuint id, GLenum target);
-    void glGetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params);
-    void glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params);
-    void glGetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params);
-    void glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params);
-    void glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param);
-    void glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param);
-    void glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param);
-    void glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param);
-    void glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param);
-    void glSamplerParameteri(GLuint sampler, GLenum pname, GLint param);
-    void glBindSampler(GLuint unit, GLuint sampler);
-    GLboolean glIsSampler(GLuint sampler);
-    void glDeleteSamplers(GLsizei count, const GLuint *samplers);
-    void glGenSamplers(GLsizei count, GLuint *samplers);
-    GLint glGetFragDataIndex(GLuint program, const GLchar *name);
-    void glBindFragDataLocationIndexed(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name);
-    void glVertexAttribDivisor(GLuint index, GLuint divisor);
-
-    // OpenGL 4.0 core functions
-    void glGetQueryIndexediv(GLenum target, GLuint index, GLenum pname, GLint *params);
-    void glEndQueryIndexed(GLenum target, GLuint index);
-    void glBeginQueryIndexed(GLenum target, GLuint index, GLuint id);
-    void glDrawTransformFeedbackStream(GLenum mode, GLuint id, GLuint stream);
-    void glDrawTransformFeedback(GLenum mode, GLuint id);
-    void glResumeTransformFeedback();
-    void glPauseTransformFeedback();
-    GLboolean glIsTransformFeedback(GLuint id);
-    void glGenTransformFeedbacks(GLsizei n, GLuint *ids);
-    void glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids);
-    void glBindTransformFeedback(GLenum target, GLuint id);
-    void glPatchParameterfv(GLenum pname, const GLfloat *values);
-    void glPatchParameteri(GLenum pname, GLint value);
-    void glGetProgramStageiv(GLuint program, GLenum shadertype, GLenum pname, GLint *values);
-    void glGetUniformSubroutineuiv(GLenum shadertype, GLint location, GLuint *params);
-    void glUniformSubroutinesuiv(GLenum shadertype, GLsizei count, const GLuint *indices);
-    void glGetActiveSubroutineName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name);
-    void glGetActiveSubroutineUniformName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name);
-    void glGetActiveSubroutineUniformiv(GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values);
-    GLuint glGetSubroutineIndex(GLuint program, GLenum shadertype, const GLchar *name);
-    GLint glGetSubroutineUniformLocation(GLuint program, GLenum shadertype, const GLchar *name);
-    void glGetUniformdv(GLuint program, GLint location, GLdouble *params);
-    void glUniformMatrix4x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix4x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix3x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix3x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix2x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix2x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniform4dv(GLint location, GLsizei count, const GLdouble *value);
-    void glUniform3dv(GLint location, GLsizei count, const GLdouble *value);
-    void glUniform2dv(GLint location, GLsizei count, const GLdouble *value);
-    void glUniform1dv(GLint location, GLsizei count, const GLdouble *value);
-    void glUniform4d(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glUniform3d(GLint location, GLdouble x, GLdouble y, GLdouble z);
-    void glUniform2d(GLint location, GLdouble x, GLdouble y);
-    void glUniform1d(GLint location, GLdouble x);
-    void glDrawElementsIndirect(GLenum mode, GLenum type, const GLvoid *indirect);
-    void glDrawArraysIndirect(GLenum mode, const GLvoid *indirect);
-    void glBlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
-    void glBlendFunci(GLuint buf, GLenum src, GLenum dst);
-    void glBlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha);
-    void glBlendEquationi(GLuint buf, GLenum mode);
-    void glMinSampleShading(GLfloat value);
-
-    // OpenGL 4.1 core functions
-    void glGetDoublei_v(GLenum target, GLuint index, GLdouble *data);
-    void glGetFloati_v(GLenum target, GLuint index, GLfloat *data);
-    void glDepthRangeIndexed(GLuint index, GLdouble n, GLdouble f);
-    void glDepthRangeArrayv(GLuint first, GLsizei count, const GLdouble *v);
-    void glScissorIndexedv(GLuint index, const GLint *v);
-    void glScissorIndexed(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height);
-    void glScissorArrayv(GLuint first, GLsizei count, const GLint *v);
-    void glViewportIndexedfv(GLuint index, const GLfloat *v);
-    void glViewportIndexedf(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h);
-    void glViewportArrayv(GLuint first, GLsizei count, const GLfloat *v);
-    void glGetVertexAttribLdv(GLuint index, GLenum pname, GLdouble *params);
-    void glVertexAttribLPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glVertexAttribL4dv(GLuint index, const GLdouble *v);
-    void glVertexAttribL3dv(GLuint index, const GLdouble *v);
-    void glVertexAttribL2dv(GLuint index, const GLdouble *v);
-    void glVertexAttribL1dv(GLuint index, const GLdouble *v);
-    void glVertexAttribL4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glVertexAttribL3d(GLuint index, GLdouble x, GLdouble y, GLdouble z);
-    void glVertexAttribL2d(GLuint index, GLdouble x, GLdouble y);
-    void glVertexAttribL1d(GLuint index, GLdouble x);
-    void glGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void glValidateProgramPipeline(GLuint pipeline);
-    void glProgramUniformMatrix4x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix3x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix4x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix2x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix3x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix2x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix4x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix3x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix4x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix2x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix3x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix2x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniform4uiv(GLuint program, GLint location, GLsizei count, const GLuint *value);
-    void glProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
-    void glProgramUniform4dv(GLuint program, GLint location, GLsizei count, const GLdouble *value);
-    void glProgramUniform4d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3);
-    void glProgramUniform4fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-    void glProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
-    void glProgramUniform4iv(GLuint program, GLint location, GLsizei count, const GLint *value);
-    void glProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
-    void glProgramUniform3uiv(GLuint program, GLint location, GLsizei count, const GLuint *value);
-    void glProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2);
-    void glProgramUniform3dv(GLuint program, GLint location, GLsizei count, const GLdouble *value);
-    void glProgramUniform3d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2);
-    void glProgramUniform3fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-    void glProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
-    void glProgramUniform3iv(GLuint program, GLint location, GLsizei count, const GLint *value);
-    void glProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2);
-    void glProgramUniform2uiv(GLuint program, GLint location, GLsizei count, const GLuint *value);
-    void glProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1);
-    void glProgramUniform2dv(GLuint program, GLint location, GLsizei count, const GLdouble *value);
-    void glProgramUniform2d(GLuint program, GLint location, GLdouble v0, GLdouble v1);
-    void glProgramUniform2fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-    void glProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1);
-    void glProgramUniform2iv(GLuint program, GLint location, GLsizei count, const GLint *value);
-    void glProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1);
-    void glProgramUniform1uiv(GLuint program, GLint location, GLsizei count, const GLuint *value);
-    void glProgramUniform1ui(GLuint program, GLint location, GLuint v0);
-    void glProgramUniform1dv(GLuint program, GLint location, GLsizei count, const GLdouble *value);
-    void glProgramUniform1d(GLuint program, GLint location, GLdouble v0);
-    void glProgramUniform1fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-    void glProgramUniform1f(GLuint program, GLint location, GLfloat v0);
-    void glProgramUniform1iv(GLuint program, GLint location, GLsizei count, const GLint *value);
-    void glProgramUniform1i(GLuint program, GLint location, GLint v0);
-    void glGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params);
-    GLboolean glIsProgramPipeline(GLuint pipeline);
-    void glGenProgramPipelines(GLsizei n, GLuint *pipelines);
-    void glDeleteProgramPipelines(GLsizei n, const GLuint *pipelines);
-    void glBindProgramPipeline(GLuint pipeline);
-    GLuint glCreateShaderProgramv(GLenum type, GLsizei count, const GLchar* const *strings);
-    void glActiveShaderProgram(GLuint pipeline, GLuint program);
-    void glUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program);
-    void glProgramParameteri(GLuint program, GLenum pname, GLint value);
-    void glProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid *binary, GLsizei length);
-    void glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, GLvoid *binary);
-    void glClearDepthf(GLfloat dd);
-    void glDepthRangef(GLfloat n, GLfloat f);
-    void glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision);
-    void glShaderBinary(GLsizei count, const GLuint *shaders, GLenum binaryformat, const GLvoid *binary, GLsizei length);
-    void glReleaseShaderCompiler();
-
-    // OpenGL 4.2 core functions
-    void glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
-    void glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);
-    void glTexStorage1D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width);
-    void glMemoryBarrier(GLbitfield barriers);
-    void glBindImageTexture(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format);
-    void glGetActiveAtomicCounterBufferiv(GLuint program, GLuint bufferIndex, GLenum pname, GLint *params);
-    void glGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params);
-    void glDrawTransformFeedbackStreamInstanced(GLenum mode, GLuint id, GLuint stream, GLsizei instancecount);
-    void glDrawTransformFeedbackInstanced(GLenum mode, GLuint id, GLsizei instancecount);
-    void glDrawElementsInstancedBaseVertexBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance);
-    void glDrawElementsInstancedBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLuint baseinstance);
-    void glDrawArraysInstancedBaseInstance(GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance);
-
-private:
-    friend class QOpenGLContext;
-
-    static bool isContextCompatible(QOpenGLContext *context);
-    static QOpenGLVersionProfile versionProfile();
-
-    QOpenGLFunctions_1_0_CoreBackend* d_1_0_Core;
-    QOpenGLFunctions_1_1_CoreBackend* d_1_1_Core;
-    QOpenGLFunctions_1_2_CoreBackend* d_1_2_Core;
-    QOpenGLFunctions_1_3_CoreBackend* d_1_3_Core;
-    QOpenGLFunctions_1_4_CoreBackend* d_1_4_Core;
-    QOpenGLFunctions_1_5_CoreBackend* d_1_5_Core;
-    QOpenGLFunctions_2_0_CoreBackend* d_2_0_Core;
-    QOpenGLFunctions_2_1_CoreBackend* d_2_1_Core;
-    QOpenGLFunctions_3_0_CoreBackend* d_3_0_Core;
-    QOpenGLFunctions_3_1_CoreBackend* d_3_1_Core;
-    QOpenGLFunctions_3_2_CoreBackend* d_3_2_Core;
-    QOpenGLFunctions_3_3_CoreBackend* d_3_3_Core;
-    QOpenGLFunctions_4_0_CoreBackend* d_4_0_Core;
-    QOpenGLFunctions_4_1_CoreBackend* d_4_1_Core;
-    QOpenGLFunctions_4_2_CoreBackend* d_4_2_Core;
-};
-
-// OpenGL 1.0 core functions
-inline void QOpenGLFunctions_4_2_Core::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_0_Core->f.Viewport(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glDepthRange(GLdouble nearVal, GLdouble farVal)
-{
-    d_1_0_Core->f.DepthRange(nearVal, farVal);
-}
-
-inline GLboolean QOpenGLFunctions_4_2_Core::glIsEnabled(GLenum cap)
-{
-    return d_1_0_Core->f.IsEnabled(cap);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetTexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetTexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
-{
-    d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
-}
-
-inline const GLubyte * QOpenGLFunctions_4_2_Core::glGetString(GLenum name)
-{
-    return d_1_0_Core->f.GetString(name);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetIntegerv(GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetIntegerv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetFloatv(GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetFloatv(pname, params);
-}
-
-inline GLenum QOpenGLFunctions_4_2_Core::glGetError()
-{
-    return d_1_0_Core->f.GetError();
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetDoublev(GLenum pname, GLdouble *params)
-{
-    d_1_0_Core->f.GetDoublev(pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetBooleanv(GLenum pname, GLboolean *params)
-{
-    d_1_0_Core->f.GetBooleanv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
-{
-    d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glReadBuffer(GLenum mode)
-{
-    d_1_0_Core->f.ReadBuffer(mode);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glPixelStorei(GLenum pname, GLint param)
-{
-    d_1_0_Core->f.PixelStorei(pname, param);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glPixelStoref(GLenum pname, GLfloat param)
-{
-    d_1_0_Core->f.PixelStoref(pname, param);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glDepthFunc(GLenum func)
-{
-    d_1_0_Core->f.DepthFunc(func);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
-{
-    d_1_0_Core->f.StencilOp(fail, zfail, zpass);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glStencilFunc(GLenum func, GLint ref, GLuint mask)
-{
-    d_1_0_Core->f.StencilFunc(func, ref, mask);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glLogicOp(GLenum opcode)
-{
-    d_1_0_Core->f.LogicOp(opcode);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glBlendFunc(GLenum sfactor, GLenum dfactor)
-{
-    d_1_0_Core->f.BlendFunc(sfactor, dfactor);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glFlush()
-{
-    d_1_0_Core->f.Flush();
-}
-
-inline void QOpenGLFunctions_4_2_Core::glFinish()
-{
-    d_1_0_Core->f.Finish();
-}
-
-inline void QOpenGLFunctions_4_2_Core::glEnable(GLenum cap)
-{
-    d_1_0_Core->f.Enable(cap);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glDisable(GLenum cap)
-{
-    d_1_0_Core->f.Disable(cap);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glDepthMask(GLboolean flag)
-{
-    d_1_0_Core->f.DepthMask(flag);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
-{
-    d_1_0_Core->f.ColorMask(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glStencilMask(GLuint mask)
-{
-    d_1_0_Core->f.StencilMask(mask);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glClearDepth(GLdouble depth)
-{
-    d_1_0_Core->f.ClearDepth(depth);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glClearStencil(GLint s)
-{
-    d_1_0_Core->f.ClearStencil(s);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Core->f.ClearColor(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glClear(GLbitfield mask)
-{
-    d_1_0_Core->f.Clear(mask);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glDrawBuffer(GLenum mode)
-{
-    d_1_0_Core->f.DrawBuffer(mode);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Core->f.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Core->f.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_0_Core->f.TexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glTexParameteri(GLenum target, GLenum pname, GLint param)
-{
-    d_1_0_Core->f.TexParameteri(target, pname, param);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Core->f.TexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
-{
-    d_1_0_Core->f.TexParameterf(target, pname, param);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_0_Core->f.Scissor(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glPolygonMode(GLenum face, GLenum mode)
-{
-    d_1_0_Core->f.PolygonMode(face, mode);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glPointSize(GLfloat size)
-{
-    d_1_0_Core->f.PointSize(size);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glLineWidth(GLfloat width)
-{
-    d_1_0_Core->f.LineWidth(width);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glHint(GLenum target, GLenum mode)
-{
-    d_1_0_Core->f.Hint(target, mode);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glFrontFace(GLenum mode)
-{
-    d_1_0_Core->f.FrontFace(mode);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glCullFace(GLenum mode)
-{
-    d_1_0_Core->f.CullFace(mode);
-}
-
-
-// OpenGL 1.1 core functions
-inline void QOpenGLFunctions_4_2_Core::glIndexubv(const GLubyte *c)
-{
-    Q_UNUSED(c);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_2_Core::glIndexub(GLubyte c)
-{
-    Q_UNUSED(c);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline GLboolean QOpenGLFunctions_4_2_Core::glIsTexture(GLuint texture)
-{
-    return d_1_1_Core->f.IsTexture(texture);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGenTextures(GLsizei n, GLuint *textures)
-{
-    d_1_1_Core->f.GenTextures(n, textures);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glDeleteTextures(GLsizei n, const GLuint *textures)
-{
-    d_1_1_Core->f.DeleteTextures(n, textures);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glBindTexture(GLenum target, GLuint texture)
-{
-    d_1_1_Core->f.BindTexture(target, texture);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_1_Core->f.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_1_Core->f.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_1_Core->f.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
-{
-    d_1_1_Core->f.CopyTexSubImage1D(target, level, xoffset, x, y, width);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
-{
-    d_1_1_Core->f.CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
-{
-    d_1_1_Core->f.CopyTexImage1D(target, level, internalformat, x, y, width, border);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glPolygonOffset(GLfloat factor, GLfloat units)
-{
-    d_1_1_Core->f.PolygonOffset(factor, units);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetPointerv(GLenum pname, GLvoid* *params)
-{
-    Q_UNUSED(pname);
-    Q_UNUSED(params);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_2_Core::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
-{
-    d_1_1_Core->f.DrawElements(mode, count, type, indices);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glDrawArrays(GLenum mode, GLint first, GLsizei count)
-{
-    d_1_1_Core->f.DrawArrays(mode, first, count);
-}
-
-
-// OpenGL 1.2 core functions
-inline void QOpenGLFunctions_4_2_Core::glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_2_Core->f.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_2_Core->f.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_2_Core->f.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
-{
-    d_1_2_Core->f.DrawRangeElements(mode, start, end, count, type, indices);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glBlendEquation(GLenum mode)
-{
-    d_1_2_Core->f.BlendEquation(mode);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_2_Core->f.BlendColor(red, green, blue, alpha);
-}
-
-
-// OpenGL 1.3 core functions
-inline void QOpenGLFunctions_4_2_Core::glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img)
-{
-    d_1_3_Core->f.GetCompressedTexImage(target, level, img);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glSampleCoverage(GLfloat value, GLboolean invert)
-{
-    d_1_3_Core->f.SampleCoverage(value, invert);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glActiveTexture(GLenum texture)
-{
-    d_1_3_Core->f.ActiveTexture(texture);
-}
-
-
-// OpenGL 1.4 core functions
-inline void QOpenGLFunctions_4_2_Core::glPointParameteriv(GLenum pname, const GLint *params)
-{
-    d_1_4_Core->f.PointParameteriv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glPointParameteri(GLenum pname, GLint param)
-{
-    d_1_4_Core->f.PointParameteri(pname, param);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glPointParameterfv(GLenum pname, const GLfloat *params)
-{
-    d_1_4_Core->f.PointParameterfv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glPointParameterf(GLenum pname, GLfloat param)
-{
-    d_1_4_Core->f.PointParameterf(pname, param);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount)
-{
-    d_1_4_Core->f.MultiDrawElements(mode, count, type, indices, drawcount);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
-{
-    d_1_4_Core->f.MultiDrawArrays(mode, first, count, drawcount);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
-{
-    d_1_4_Core->f.BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
-}
-
-
-// OpenGL 1.5 core functions
-inline void QOpenGLFunctions_4_2_Core::glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params)
-{
-    d_1_5_Core->f.GetBufferPointerv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetBufferParameteriv(target, pname, params);
-}
-
-inline GLboolean QOpenGLFunctions_4_2_Core::glUnmapBuffer(GLenum target)
-{
-    return d_1_5_Core->f.UnmapBuffer(target);
-}
-
-inline GLvoid* QOpenGLFunctions_4_2_Core::glMapBuffer(GLenum target, GLenum access)
-{
-    return d_1_5_Core->f.MapBuffer(target, access);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data)
-{
-    d_1_5_Core->f.GetBufferSubData(target, offset, size, data);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data)
-{
-    d_1_5_Core->f.BufferSubData(target, offset, size, data);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)
-{
-    d_1_5_Core->f.BufferData(target, size, data, usage);
-}
-
-inline GLboolean QOpenGLFunctions_4_2_Core::glIsBuffer(GLuint buffer)
-{
-    return d_1_5_Core->f.IsBuffer(buffer);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGenBuffers(GLsizei n, GLuint *buffers)
-{
-    d_1_5_Core->f.GenBuffers(n, buffers);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glDeleteBuffers(GLsizei n, const GLuint *buffers)
-{
-    d_1_5_Core->f.DeleteBuffers(n, buffers);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glBindBuffer(GLenum target, GLuint buffer)
-{
-    d_1_5_Core->f.BindBuffer(target, buffer);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
-{
-    d_1_5_Core->f.GetQueryObjectuiv(id, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetQueryObjectiv(id, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetQueryiv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetQueryiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glEndQuery(GLenum target)
-{
-    d_1_5_Core->f.EndQuery(target);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glBeginQuery(GLenum target, GLuint id)
-{
-    d_1_5_Core->f.BeginQuery(target, id);
-}
-
-inline GLboolean QOpenGLFunctions_4_2_Core::glIsQuery(GLuint id)
-{
-    return d_1_5_Core->f.IsQuery(id);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glDeleteQueries(GLsizei n, const GLuint *ids)
-{
-    d_1_5_Core->f.DeleteQueries(n, ids);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGenQueries(GLsizei n, GLuint *ids)
-{
-    d_1_5_Core->f.GenQueries(n, ids);
-}
-
-
-// OpenGL 2.0 core functions
-inline void QOpenGLFunctions_4_2_Core::glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer)
-{
-    d_2_0_Core->f.VertexAttribPointer(index, size, type, normalized, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glValidateProgram(GLuint program)
-{
-    d_2_0_Core->f.ValidateProgram(program);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix3fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUniform4iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform4iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUniform3iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform3iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUniform2iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform2iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUniform1iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform1iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUniform4fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform4fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUniform3fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform3fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUniform2fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform2fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUniform1fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform1fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
-{
-    d_2_0_Core->f.Uniform4i(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUniform3i(GLint location, GLint v0, GLint v1, GLint v2)
-{
-    d_2_0_Core->f.Uniform3i(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUniform2i(GLint location, GLint v0, GLint v1)
-{
-    d_2_0_Core->f.Uniform2i(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUniform1i(GLint location, GLint v0)
-{
-    d_2_0_Core->f.Uniform1i(location, v0);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
-{
-    d_2_0_Core->f.Uniform4f(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
-{
-    d_2_0_Core->f.Uniform3f(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUniform2f(GLint location, GLfloat v0, GLfloat v1)
-{
-    d_2_0_Core->f.Uniform2f(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUniform1f(GLint location, GLfloat v0)
-{
-    d_2_0_Core->f.Uniform1f(location, v0);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUseProgram(GLuint program)
-{
-    d_2_0_Core->f.UseProgram(program);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length)
-{
-    d_2_0_Core->f.ShaderSource(shader, count, string, length);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glLinkProgram(GLuint program)
-{
-    d_2_0_Core->f.LinkProgram(program);
-}
-
-inline GLboolean QOpenGLFunctions_4_2_Core::glIsShader(GLuint shader)
-{
-    return d_2_0_Core->f.IsShader(shader);
-}
-
-inline GLboolean QOpenGLFunctions_4_2_Core::glIsProgram(GLuint program)
-{
-    return d_2_0_Core->f.IsProgram(program);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer)
-{
-    d_2_0_Core->f.GetVertexAttribPointerv(index, pname, pointer);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetVertexAttribiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
-{
-    d_2_0_Core->f.GetVertexAttribfv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
-{
-    d_2_0_Core->f.GetVertexAttribdv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetUniformiv(GLuint program, GLint location, GLint *params)
-{
-    d_2_0_Core->f.GetUniformiv(program, location, params);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetUniformfv(GLuint program, GLint location, GLfloat *params)
-{
-    d_2_0_Core->f.GetUniformfv(program, location, params);
-}
-
-inline GLint QOpenGLFunctions_4_2_Core::glGetUniformLocation(GLuint program, const GLchar *name)
-{
-    return d_2_0_Core->f.GetUniformLocation(program, name);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
-{
-    d_2_0_Core->f.GetShaderSource(shader, bufSize, length, source);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-{
-    d_2_0_Core->f.GetShaderInfoLog(shader, bufSize, length, infoLog);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetShaderiv(GLuint shader, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetShaderiv(shader, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-{
-    d_2_0_Core->f.GetProgramInfoLog(program, bufSize, length, infoLog);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetProgramiv(GLuint program, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetProgramiv(program, pname, params);
-}
-
-inline GLint QOpenGLFunctions_4_2_Core::glGetAttribLocation(GLuint program, const GLchar *name)
-{
-    return d_2_0_Core->f.GetAttribLocation(program, name);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj)
-{
-    d_2_0_Core->f.GetAttachedShaders(program, maxCount, count, obj);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
-{
-    d_2_0_Core->f.GetActiveUniform(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
-{
-    d_2_0_Core->f.GetActiveAttrib(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glEnableVertexAttribArray(GLuint index)
-{
-    d_2_0_Core->f.EnableVertexAttribArray(index);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glDisableVertexAttribArray(GLuint index)
-{
-    d_2_0_Core->f.DisableVertexAttribArray(index);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glDetachShader(GLuint program, GLuint shader)
-{
-    d_2_0_Core->f.DetachShader(program, shader);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glDeleteShader(GLuint shader)
-{
-    d_2_0_Core->f.DeleteShader(shader);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glDeleteProgram(GLuint program)
-{
-    d_2_0_Core->f.DeleteProgram(program);
-}
-
-inline GLuint QOpenGLFunctions_4_2_Core::glCreateShader(GLenum type)
-{
-    return d_2_0_Core->f.CreateShader(type);
-}
-
-inline GLuint QOpenGLFunctions_4_2_Core::glCreateProgram()
-{
-    return d_2_0_Core->f.CreateProgram();
-}
-
-inline void QOpenGLFunctions_4_2_Core::glCompileShader(GLuint shader)
-{
-    d_2_0_Core->f.CompileShader(shader);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glBindAttribLocation(GLuint program, GLuint index, const GLchar *name)
-{
-    d_2_0_Core->f.BindAttribLocation(program, index, name);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glAttachShader(GLuint program, GLuint shader)
-{
-    d_2_0_Core->f.AttachShader(program, shader);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glStencilMaskSeparate(GLenum face, GLuint mask)
-{
-    d_2_0_Core->f.StencilMaskSeparate(face, mask);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
-{
-    d_2_0_Core->f.StencilFuncSeparate(face, func, ref, mask);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
-{
-    d_2_0_Core->f.StencilOpSeparate(face, sfail, dpfail, dppass);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glDrawBuffers(GLsizei n, const GLenum *bufs)
-{
-    d_2_0_Core->f.DrawBuffers(n, bufs);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
-{
-    d_2_0_Core->f.BlendEquationSeparate(modeRGB, modeAlpha);
-}
-
-
-// OpenGL 2.1 core functions
-inline void QOpenGLFunctions_4_2_Core::glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix4x3fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix3x4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix4x2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix2x4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix3x2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix2x3fv(location, count, transpose, value);
-}
-
-
-// OpenGL 3.0 core functions
-inline GLboolean QOpenGLFunctions_4_2_Core::glIsVertexArray(GLuint array)
-{
-    return d_3_0_Core->f.IsVertexArray(array);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGenVertexArrays(GLsizei n, GLuint *arrays)
-{
-    d_3_0_Core->f.GenVertexArrays(n, arrays);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glDeleteVertexArrays(GLsizei n, const GLuint *arrays)
-{
-    d_3_0_Core->f.DeleteVertexArrays(n, arrays);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glBindVertexArray(GLuint array)
-{
-    d_3_0_Core->f.BindVertexArray(array);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
-{
-    d_3_0_Core->f.FlushMappedBufferRange(target, offset, length);
-}
-
-inline GLvoid* QOpenGLFunctions_4_2_Core::glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
-{
-    return d_3_0_Core->f.MapBufferRange(target, offset, length, access);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
-{
-    d_3_0_Core->f.FramebufferTextureLayer(target, attachment, texture, level, layer);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    d_3_0_Core->f.RenderbufferStorageMultisample(target, samples, internalformat, width, height);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
-{
-    d_3_0_Core->f.BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGenerateMipmap(GLenum target)
-{
-    d_3_0_Core->f.GenerateMipmap(target);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
-{
-    d_3_0_Core->f.FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
-{
-    d_3_0_Core->f.FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
-{
-    d_3_0_Core->f.FramebufferTexture2D(target, attachment, textarget, texture, level);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
-{
-    d_3_0_Core->f.FramebufferTexture1D(target, attachment, textarget, texture, level);
-}
-
-inline GLenum QOpenGLFunctions_4_2_Core::glCheckFramebufferStatus(GLenum target)
-{
-    return d_3_0_Core->f.CheckFramebufferStatus(target);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGenFramebuffers(GLsizei n, GLuint *framebuffers)
-{
-    d_3_0_Core->f.GenFramebuffers(n, framebuffers);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
-{
-    d_3_0_Core->f.DeleteFramebuffers(n, framebuffers);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glBindFramebuffer(GLenum target, GLuint framebuffer)
-{
-    d_3_0_Core->f.BindFramebuffer(target, framebuffer);
-}
-
-inline GLboolean QOpenGLFunctions_4_2_Core::glIsFramebuffer(GLuint framebuffer)
-{
-    return d_3_0_Core->f.IsFramebuffer(framebuffer);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetRenderbufferParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    d_3_0_Core->f.RenderbufferStorage(target, internalformat, width, height);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGenRenderbuffers(GLsizei n, GLuint *renderbuffers)
-{
-    d_3_0_Core->f.GenRenderbuffers(n, renderbuffers);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
-{
-    d_3_0_Core->f.DeleteRenderbuffers(n, renderbuffers);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glBindRenderbuffer(GLenum target, GLuint renderbuffer)
-{
-    d_3_0_Core->f.BindRenderbuffer(target, renderbuffer);
-}
-
-inline GLboolean QOpenGLFunctions_4_2_Core::glIsRenderbuffer(GLuint renderbuffer)
-{
-    return d_3_0_Core->f.IsRenderbuffer(renderbuffer);
-}
-
-inline const GLubyte * QOpenGLFunctions_4_2_Core::glGetStringi(GLenum name, GLuint index)
-{
-    return d_3_0_Core->f.GetStringi(name, index);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
-{
-    d_3_0_Core->f.ClearBufferfi(buffer, drawbuffer, depth, stencil);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
-{
-    d_3_0_Core->f.ClearBufferfv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
-{
-    d_3_0_Core->f.ClearBufferuiv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
-{
-    d_3_0_Core->f.ClearBufferiv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params)
-{
-    d_3_0_Core->f.GetTexParameterIuiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetTexParameterIiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params)
-{
-    d_3_0_Core->f.TexParameterIuiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glTexParameterIiv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_3_0_Core->f.TexParameterIiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUniform4uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform4uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUniform3uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform3uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUniform2uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform2uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUniform1uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform1uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
-{
-    d_3_0_Core->f.Uniform4ui(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
-{
-    d_3_0_Core->f.Uniform3ui(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUniform2ui(GLint location, GLuint v0, GLuint v1)
-{
-    d_3_0_Core->f.Uniform2ui(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUniform1ui(GLint location, GLuint v0)
-{
-    d_3_0_Core->f.Uniform1ui(location, v0);
-}
-
-inline GLint QOpenGLFunctions_4_2_Core::glGetFragDataLocation(GLuint program, const GLchar *name)
-{
-    return d_3_0_Core->f.GetFragDataLocation(program, name);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name)
-{
-    d_3_0_Core->f.BindFragDataLocation(program, color, name);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetUniformuiv(GLuint program, GLint location, GLuint *params)
-{
-    d_3_0_Core->f.GetUniformuiv(program, location, params);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
-{
-    d_3_0_Core->f.GetVertexAttribIuiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetVertexAttribIiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_3_0_Core->f.VertexAttribIPointer(index, size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glEndConditionalRender()
-{
-    d_3_0_Core->f.EndConditionalRender();
-}
-
-inline void QOpenGLFunctions_4_2_Core::glBeginConditionalRender(GLuint id, GLenum mode)
-{
-    d_3_0_Core->f.BeginConditionalRender(id, mode);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glClampColor(GLenum target, GLenum clamp)
-{
-    d_3_0_Core->f.ClampColor(target, clamp);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
-{
-    d_3_0_Core->f.GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode)
-{
-    d_3_0_Core->f.TransformFeedbackVaryings(program, count, varyings, bufferMode);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
-{
-    d_3_0_Core->f.BindBufferBase(target, index, buffer);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
-{
-    d_3_0_Core->f.BindBufferRange(target, index, buffer, offset, size);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glEndTransformFeedback()
-{
-    d_3_0_Core->f.EndTransformFeedback();
-}
-
-inline void QOpenGLFunctions_4_2_Core::glBeginTransformFeedback(GLenum primitiveMode)
-{
-    d_3_0_Core->f.BeginTransformFeedback(primitiveMode);
-}
-
-inline GLboolean QOpenGLFunctions_4_2_Core::glIsEnabledi(GLenum target, GLuint index)
-{
-    return d_3_0_Core->f.IsEnabledi(target, index);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glDisablei(GLenum target, GLuint index)
-{
-    d_3_0_Core->f.Disablei(target, index);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glEnablei(GLenum target, GLuint index)
-{
-    d_3_0_Core->f.Enablei(target, index);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetIntegeri_v(GLenum target, GLuint index, GLint *data)
-{
-    d_3_0_Core->f.GetIntegeri_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetBooleani_v(GLenum target, GLuint index, GLboolean *data)
-{
-    d_3_0_Core->f.GetBooleani_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
-{
-    d_3_0_Core->f.ColorMaski(index, r, g, b, a);
-}
-
-
-// OpenGL 3.1 core functions
-inline void QOpenGLFunctions_4_2_Core::glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
-{
-    d_3_1_Core->f.CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
-{
-    d_3_1_Core->f.UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
-{
-    d_3_1_Core->f.GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params)
-{
-    d_3_1_Core->f.GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
-}
-
-inline GLuint QOpenGLFunctions_4_2_Core::glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName)
-{
-    return d_3_1_Core->f.GetUniformBlockIndex(program, uniformBlockName);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName)
-{
-    d_3_1_Core->f.GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params)
-{
-    d_3_1_Core->f.GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const *uniformNames, GLuint *uniformIndices)
-{
-    d_3_1_Core->f.GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glPrimitiveRestartIndex(GLuint index)
-{
-    d_3_1_Core->f.PrimitiveRestartIndex(index);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer)
-{
-    d_3_1_Core->f.TexBuffer(target, internalformat, buffer);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount)
-{
-    d_3_1_Core->f.DrawElementsInstanced(mode, count, type, indices, instancecount);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount)
-{
-    d_3_1_Core->f.DrawArraysInstanced(mode, first, count, instancecount);
-}
-
-
-// OpenGL 3.2 core functions
-inline void QOpenGLFunctions_4_2_Core::glSampleMaski(GLuint index, GLbitfield mask)
-{
-    d_3_2_Core->f.SampleMaski(index, mask);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val)
-{
-    d_3_2_Core->f.GetMultisamplefv(pname, index, val);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glTexImage3DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
-{
-    d_3_2_Core->f.TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glTexImage2DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
-{
-    d_3_2_Core->f.TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values)
-{
-    d_3_2_Core->f.GetSynciv(sync, pname, bufSize, length, values);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetInteger64v(GLenum pname, GLint64 *params)
-{
-    d_3_2_Core->f.GetInteger64v(pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
-{
-    d_3_2_Core->f.WaitSync(sync, flags, timeout);
-}
-
-inline GLenum QOpenGLFunctions_4_2_Core::glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
-{
-    return d_3_2_Core->f.ClientWaitSync(sync, flags, timeout);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glDeleteSync(GLsync sync)
-{
-    d_3_2_Core->f.DeleteSync(sync);
-}
-
-inline GLboolean QOpenGLFunctions_4_2_Core::glIsSync(GLsync sync)
-{
-    return d_3_2_Core->f.IsSync(sync);
-}
-
-inline GLsync QOpenGLFunctions_4_2_Core::glFenceSync(GLenum condition, GLbitfield flags)
-{
-    return d_3_2_Core->f.FenceSync(condition, flags);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProvokingVertex(GLenum mode)
-{
-    d_3_2_Core->f.ProvokingVertex(mode);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glMultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount, const GLint *basevertex)
-{
-    d_3_2_Core->f.MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount, GLint basevertex)
-{
-    d_3_2_Core->f.DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)
-{
-    d_3_2_Core->f.DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)
-{
-    d_3_2_Core->f.DrawElementsBaseVertex(mode, count, type, indices, basevertex);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level)
-{
-    d_3_2_Core->f.FramebufferTexture(target, attachment, texture, level);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params)
-{
-    d_3_2_Core->f.GetBufferParameteri64v(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data)
-{
-    d_3_2_Core->f.GetInteger64i_v(target, index, data);
-}
-
-
-// OpenGL 3.3 core functions
-inline void QOpenGLFunctions_4_2_Core::glVertexAttribP4uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP4uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glVertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP4ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glVertexAttribP3uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP3uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glVertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP3ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glVertexAttribP2uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP2uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glVertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP2ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glVertexAttribP1uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP1uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glVertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP1ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glSecondaryColorP3uiv(GLenum type, const GLuint *color)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(color);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_2_Core::glSecondaryColorP3ui(GLenum type, GLuint color)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(color);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_2_Core::glColorP4uiv(GLenum type, const GLuint *color)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(color);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_2_Core::glColorP4ui(GLenum type, GLuint color)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(color);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_2_Core::glColorP3uiv(GLenum type, const GLuint *color)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(color);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_2_Core::glColorP3ui(GLenum type, GLuint color)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(color);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_2_Core::glNormalP3uiv(GLenum type, const GLuint *coords)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_2_Core::glNormalP3ui(GLenum type, GLuint coords)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_2_Core::glMultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint *coords)
-{
-    Q_UNUSED(texture);
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_2_Core::glMultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords)
-{
-    Q_UNUSED(texture);
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_2_Core::glMultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint *coords)
-{
-    Q_UNUSED(texture);
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_2_Core::glMultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords)
-{
-    Q_UNUSED(texture);
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_2_Core::glMultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint *coords)
-{
-    Q_UNUSED(texture);
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_2_Core::glMultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords)
-{
-    Q_UNUSED(texture);
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_2_Core::glMultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint *coords)
-{
-    Q_UNUSED(texture);
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_2_Core::glMultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords)
-{
-    Q_UNUSED(texture);
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_2_Core::glTexCoordP4uiv(GLenum type, const GLuint *coords)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_2_Core::glTexCoordP4ui(GLenum type, GLuint coords)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_2_Core::glTexCoordP3uiv(GLenum type, const GLuint *coords)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_2_Core::glTexCoordP3ui(GLenum type, GLuint coords)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_2_Core::glTexCoordP2uiv(GLenum type, const GLuint *coords)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_2_Core::glTexCoordP2ui(GLenum type, GLuint coords)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_2_Core::glTexCoordP1uiv(GLenum type, const GLuint *coords)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_2_Core::glTexCoordP1ui(GLenum type, GLuint coords)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_2_Core::glVertexP4uiv(GLenum type, const GLuint *value)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(value);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_2_Core::glVertexP4ui(GLenum type, GLuint value)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(value);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_2_Core::glVertexP3uiv(GLenum type, const GLuint *value)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(value);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_2_Core::glVertexP3ui(GLenum type, GLuint value)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(value);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_2_Core::glVertexP2uiv(GLenum type, const GLuint *value)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(value);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_2_Core::glVertexP2ui(GLenum type, GLuint value)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(value);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params)
-{
-    d_3_3_Core->f.GetQueryObjectui64v(id, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params)
-{
-    d_3_3_Core->f.GetQueryObjecti64v(id, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glQueryCounter(GLuint id, GLenum target)
-{
-    d_3_3_Core->f.QueryCounter(id, target);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params)
-{
-    d_3_3_Core->f.GetSamplerParameterIuiv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params)
-{
-    d_3_3_Core->f.GetSamplerParameterfv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params)
-{
-    d_3_3_Core->f.GetSamplerParameterIiv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params)
-{
-    d_3_3_Core->f.GetSamplerParameteriv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param)
-{
-    d_3_3_Core->f.SamplerParameterIuiv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param)
-{
-    d_3_3_Core->f.SamplerParameterIiv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param)
-{
-    d_3_3_Core->f.SamplerParameterfv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
-{
-    d_3_3_Core->f.SamplerParameterf(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param)
-{
-    d_3_3_Core->f.SamplerParameteriv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glSamplerParameteri(GLuint sampler, GLenum pname, GLint param)
-{
-    d_3_3_Core->f.SamplerParameteri(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glBindSampler(GLuint unit, GLuint sampler)
-{
-    d_3_3_Core->f.BindSampler(unit, sampler);
-}
-
-inline GLboolean QOpenGLFunctions_4_2_Core::glIsSampler(GLuint sampler)
-{
-    return d_3_3_Core->f.IsSampler(sampler);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glDeleteSamplers(GLsizei count, const GLuint *samplers)
-{
-    d_3_3_Core->f.DeleteSamplers(count, samplers);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGenSamplers(GLsizei count, GLuint *samplers)
-{
-    d_3_3_Core->f.GenSamplers(count, samplers);
-}
-
-inline GLint QOpenGLFunctions_4_2_Core::glGetFragDataIndex(GLuint program, const GLchar *name)
-{
-    return d_3_3_Core->f.GetFragDataIndex(program, name);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glBindFragDataLocationIndexed(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name)
-{
-    d_3_3_Core->f.BindFragDataLocationIndexed(program, colorNumber, index, name);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glVertexAttribDivisor(GLuint index, GLuint divisor)
-{
-    d_3_3_Core->f.VertexAttribDivisor(index, divisor);
-}
-
-
-// OpenGL 4.0 core functions
-inline void QOpenGLFunctions_4_2_Core::glGetQueryIndexediv(GLenum target, GLuint index, GLenum pname, GLint *params)
-{
-    d_4_0_Core->f.GetQueryIndexediv(target, index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glEndQueryIndexed(GLenum target, GLuint index)
-{
-    d_4_0_Core->f.EndQueryIndexed(target, index);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glBeginQueryIndexed(GLenum target, GLuint index, GLuint id)
-{
-    d_4_0_Core->f.BeginQueryIndexed(target, index, id);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glDrawTransformFeedbackStream(GLenum mode, GLuint id, GLuint stream)
-{
-    d_4_0_Core->f.DrawTransformFeedbackStream(mode, id, stream);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glDrawTransformFeedback(GLenum mode, GLuint id)
-{
-    d_4_0_Core->f.DrawTransformFeedback(mode, id);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glResumeTransformFeedback()
-{
-    d_4_0_Core->f.ResumeTransformFeedback();
-}
-
-inline void QOpenGLFunctions_4_2_Core::glPauseTransformFeedback()
-{
-    d_4_0_Core->f.PauseTransformFeedback();
-}
-
-inline GLboolean QOpenGLFunctions_4_2_Core::glIsTransformFeedback(GLuint id)
-{
-    return d_4_0_Core->f.IsTransformFeedback(id);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGenTransformFeedbacks(GLsizei n, GLuint *ids)
-{
-    d_4_0_Core->f.GenTransformFeedbacks(n, ids);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids)
-{
-    d_4_0_Core->f.DeleteTransformFeedbacks(n, ids);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glBindTransformFeedback(GLenum target, GLuint id)
-{
-    d_4_0_Core->f.BindTransformFeedback(target, id);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glPatchParameterfv(GLenum pname, const GLfloat *values)
-{
-    d_4_0_Core->f.PatchParameterfv(pname, values);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glPatchParameteri(GLenum pname, GLint value)
-{
-    d_4_0_Core->f.PatchParameteri(pname, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetProgramStageiv(GLuint program, GLenum shadertype, GLenum pname, GLint *values)
-{
-    d_4_0_Core->f.GetProgramStageiv(program, shadertype, pname, values);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetUniformSubroutineuiv(GLenum shadertype, GLint location, GLuint *params)
-{
-    d_4_0_Core->f.GetUniformSubroutineuiv(shadertype, location, params);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUniformSubroutinesuiv(GLenum shadertype, GLsizei count, const GLuint *indices)
-{
-    d_4_0_Core->f.UniformSubroutinesuiv(shadertype, count, indices);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetActiveSubroutineName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
-{
-    d_4_0_Core->f.GetActiveSubroutineName(program, shadertype, index, bufsize, length, name);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetActiveSubroutineUniformName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
-{
-    d_4_0_Core->f.GetActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetActiveSubroutineUniformiv(GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values)
-{
-    d_4_0_Core->f.GetActiveSubroutineUniformiv(program, shadertype, index, pname, values);
-}
-
-inline GLuint QOpenGLFunctions_4_2_Core::glGetSubroutineIndex(GLuint program, GLenum shadertype, const GLchar *name)
-{
-    return d_4_0_Core->f.GetSubroutineIndex(program, shadertype, name);
-}
-
-inline GLint QOpenGLFunctions_4_2_Core::glGetSubroutineUniformLocation(GLuint program, GLenum shadertype, const GLchar *name)
-{
-    return d_4_0_Core->f.GetSubroutineUniformLocation(program, shadertype, name);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetUniformdv(GLuint program, GLint location, GLdouble *params)
-{
-    d_4_0_Core->f.GetUniformdv(program, location, params);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUniformMatrix4x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix4x3dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUniformMatrix4x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix4x2dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUniformMatrix3x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix3x4dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUniformMatrix3x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix3x2dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUniformMatrix2x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix2x4dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUniformMatrix2x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix2x3dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix4dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUniformMatrix3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix3dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUniformMatrix2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix2dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUniform4dv(GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_0_Core->f.Uniform4dv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUniform3dv(GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_0_Core->f.Uniform3dv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUniform2dv(GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_0_Core->f.Uniform2dv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUniform1dv(GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_0_Core->f.Uniform1dv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUniform4d(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_4_0_Core->f.Uniform4d(location, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUniform3d(GLint location, GLdouble x, GLdouble y, GLdouble z)
-{
-    d_4_0_Core->f.Uniform3d(location, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUniform2d(GLint location, GLdouble x, GLdouble y)
-{
-    d_4_0_Core->f.Uniform2d(location, x, y);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUniform1d(GLint location, GLdouble x)
-{
-    d_4_0_Core->f.Uniform1d(location, x);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glDrawElementsIndirect(GLenum mode, GLenum type, const GLvoid *indirect)
-{
-    d_4_0_Core->f.DrawElementsIndirect(mode, type, indirect);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glDrawArraysIndirect(GLenum mode, const GLvoid *indirect)
-{
-    d_4_0_Core->f.DrawArraysIndirect(mode, indirect);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glBlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
-{
-    d_4_0_Core->f.BlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glBlendFunci(GLuint buf, GLenum src, GLenum dst)
-{
-    d_4_0_Core->f.BlendFunci(buf, src, dst);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glBlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha)
-{
-    d_4_0_Core->f.BlendEquationSeparatei(buf, modeRGB, modeAlpha);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glBlendEquationi(GLuint buf, GLenum mode)
-{
-    d_4_0_Core->f.BlendEquationi(buf, mode);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glMinSampleShading(GLfloat value)
-{
-    d_4_0_Core->f.MinSampleShading(value);
-}
-
-
-// OpenGL 4.1 core functions
-inline void QOpenGLFunctions_4_2_Core::glGetDoublei_v(GLenum target, GLuint index, GLdouble *data)
-{
-    d_4_1_Core->f.GetDoublei_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetFloati_v(GLenum target, GLuint index, GLfloat *data)
-{
-    d_4_1_Core->f.GetFloati_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glDepthRangeIndexed(GLuint index, GLdouble n, GLdouble f)
-{
-    d_4_1_Core->f.DepthRangeIndexed(index, n, f);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glDepthRangeArrayv(GLuint first, GLsizei count, const GLdouble *v)
-{
-    d_4_1_Core->f.DepthRangeArrayv(first, count, v);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glScissorIndexedv(GLuint index, const GLint *v)
-{
-    d_4_1_Core->f.ScissorIndexedv(index, v);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glScissorIndexed(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height)
-{
-    d_4_1_Core->f.ScissorIndexed(index, left, bottom, width, height);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glScissorArrayv(GLuint first, GLsizei count, const GLint *v)
-{
-    d_4_1_Core->f.ScissorArrayv(first, count, v);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glViewportIndexedfv(GLuint index, const GLfloat *v)
-{
-    d_4_1_Core->f.ViewportIndexedfv(index, v);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glViewportIndexedf(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h)
-{
-    d_4_1_Core->f.ViewportIndexedf(index, x, y, w, h);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glViewportArrayv(GLuint first, GLsizei count, const GLfloat *v)
-{
-    d_4_1_Core->f.ViewportArrayv(first, count, v);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetVertexAttribLdv(GLuint index, GLenum pname, GLdouble *params)
-{
-    d_4_1_Core->f.GetVertexAttribLdv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glVertexAttribLPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_4_1_Core->f.VertexAttribLPointer(index, size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glVertexAttribL4dv(GLuint index, const GLdouble *v)
-{
-    d_4_1_Core->f.VertexAttribL4dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glVertexAttribL3dv(GLuint index, const GLdouble *v)
-{
-    d_4_1_Core->f.VertexAttribL3dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glVertexAttribL2dv(GLuint index, const GLdouble *v)
-{
-    d_4_1_Core->f.VertexAttribL2dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glVertexAttribL1dv(GLuint index, const GLdouble *v)
-{
-    d_4_1_Core->f.VertexAttribL1dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glVertexAttribL4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_4_1_Core->f.VertexAttribL4d(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glVertexAttribL3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
-{
-    d_4_1_Core->f.VertexAttribL3d(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glVertexAttribL2d(GLuint index, GLdouble x, GLdouble y)
-{
-    d_4_1_Core->f.VertexAttribL2d(index, x, y);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glVertexAttribL1d(GLuint index, GLdouble x)
-{
-    d_4_1_Core->f.VertexAttribL1d(index, x);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-{
-    d_4_1_Core->f.GetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glValidateProgramPipeline(GLuint pipeline)
-{
-    d_4_1_Core->f.ValidateProgramPipeline(pipeline);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProgramUniformMatrix4x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4x3dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProgramUniformMatrix3x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3x4dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProgramUniformMatrix4x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4x2dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProgramUniformMatrix2x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2x4dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProgramUniformMatrix3x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3x2dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProgramUniformMatrix2x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2x3dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProgramUniformMatrix4x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4x3fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProgramUniformMatrix3x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3x4fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProgramUniformMatrix4x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4x2fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProgramUniformMatrix2x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2x4fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProgramUniformMatrix3x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3x2fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProgramUniformMatrix2x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2x3fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProgramUniformMatrix4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProgramUniformMatrix3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProgramUniformMatrix2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProgramUniformMatrix4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProgramUniformMatrix3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProgramUniformMatrix2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProgramUniform4uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
-{
-    d_4_1_Core->f.ProgramUniform4uiv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
-{
-    d_4_1_Core->f.ProgramUniform4ui(program, location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProgramUniform4dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniform4dv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProgramUniform4d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3)
-{
-    d_4_1_Core->f.ProgramUniform4d(program, location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProgramUniform4fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniform4fv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
-{
-    d_4_1_Core->f.ProgramUniform4f(program, location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProgramUniform4iv(GLuint program, GLint location, GLsizei count, const GLint *value)
-{
-    d_4_1_Core->f.ProgramUniform4iv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
-{
-    d_4_1_Core->f.ProgramUniform4i(program, location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProgramUniform3uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
-{
-    d_4_1_Core->f.ProgramUniform3uiv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2)
-{
-    d_4_1_Core->f.ProgramUniform3ui(program, location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProgramUniform3dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniform3dv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProgramUniform3d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2)
-{
-    d_4_1_Core->f.ProgramUniform3d(program, location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProgramUniform3fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniform3fv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
-{
-    d_4_1_Core->f.ProgramUniform3f(program, location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProgramUniform3iv(GLuint program, GLint location, GLsizei count, const GLint *value)
-{
-    d_4_1_Core->f.ProgramUniform3iv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2)
-{
-    d_4_1_Core->f.ProgramUniform3i(program, location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProgramUniform2uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
-{
-    d_4_1_Core->f.ProgramUniform2uiv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1)
-{
-    d_4_1_Core->f.ProgramUniform2ui(program, location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProgramUniform2dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniform2dv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProgramUniform2d(GLuint program, GLint location, GLdouble v0, GLdouble v1)
-{
-    d_4_1_Core->f.ProgramUniform2d(program, location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProgramUniform2fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniform2fv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1)
-{
-    d_4_1_Core->f.ProgramUniform2f(program, location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProgramUniform2iv(GLuint program, GLint location, GLsizei count, const GLint *value)
-{
-    d_4_1_Core->f.ProgramUniform2iv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1)
-{
-    d_4_1_Core->f.ProgramUniform2i(program, location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProgramUniform1uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
-{
-    d_4_1_Core->f.ProgramUniform1uiv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProgramUniform1ui(GLuint program, GLint location, GLuint v0)
-{
-    d_4_1_Core->f.ProgramUniform1ui(program, location, v0);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProgramUniform1dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniform1dv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProgramUniform1d(GLuint program, GLint location, GLdouble v0)
-{
-    d_4_1_Core->f.ProgramUniform1d(program, location, v0);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProgramUniform1fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniform1fv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProgramUniform1f(GLuint program, GLint location, GLfloat v0)
-{
-    d_4_1_Core->f.ProgramUniform1f(program, location, v0);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProgramUniform1iv(GLuint program, GLint location, GLsizei count, const GLint *value)
-{
-    d_4_1_Core->f.ProgramUniform1iv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProgramUniform1i(GLuint program, GLint location, GLint v0)
-{
-    d_4_1_Core->f.ProgramUniform1i(program, location, v0);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params)
-{
-    d_4_1_Core->f.GetProgramPipelineiv(pipeline, pname, params);
-}
-
-inline GLboolean QOpenGLFunctions_4_2_Core::glIsProgramPipeline(GLuint pipeline)
-{
-    return d_4_1_Core->f.IsProgramPipeline(pipeline);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGenProgramPipelines(GLsizei n, GLuint *pipelines)
-{
-    d_4_1_Core->f.GenProgramPipelines(n, pipelines);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glDeleteProgramPipelines(GLsizei n, const GLuint *pipelines)
-{
-    d_4_1_Core->f.DeleteProgramPipelines(n, pipelines);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glBindProgramPipeline(GLuint pipeline)
-{
-    d_4_1_Core->f.BindProgramPipeline(pipeline);
-}
-
-inline GLuint QOpenGLFunctions_4_2_Core::glCreateShaderProgramv(GLenum type, GLsizei count, const GLchar* const *strings)
-{
-    return d_4_1_Core->f.CreateShaderProgramv(type, count, strings);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glActiveShaderProgram(GLuint pipeline, GLuint program)
-{
-    d_4_1_Core->f.ActiveShaderProgram(pipeline, program);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program)
-{
-    d_4_1_Core->f.UseProgramStages(pipeline, stages, program);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProgramParameteri(GLuint program, GLenum pname, GLint value)
-{
-    d_4_1_Core->f.ProgramParameteri(program, pname, value);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid *binary, GLsizei length)
-{
-    d_4_1_Core->f.ProgramBinary(program, binaryFormat, binary, length);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, GLvoid *binary)
-{
-    d_4_1_Core->f.GetProgramBinary(program, bufSize, length, binaryFormat, binary);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glClearDepthf(GLfloat dd)
-{
-    d_4_1_Core->f.ClearDepthf(dd);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glDepthRangef(GLfloat n, GLfloat f)
-{
-    d_4_1_Core->f.DepthRangef(n, f);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision)
-{
-    d_4_1_Core->f.GetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glShaderBinary(GLsizei count, const GLuint *shaders, GLenum binaryformat, const GLvoid *binary, GLsizei length)
-{
-    d_4_1_Core->f.ShaderBinary(count, shaders, binaryformat, binary, length);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glReleaseShaderCompiler()
-{
-    d_4_1_Core->f.ReleaseShaderCompiler();
-}
-
-
-// OpenGL 4.2 core functions
-inline void QOpenGLFunctions_4_2_Core::glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
-{
-    d_4_2_Core->f.TexStorage3D(target, levels, internalformat, width, height, depth);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    d_4_2_Core->f.TexStorage2D(target, levels, internalformat, width, height);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glTexStorage1D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width)
-{
-    d_4_2_Core->f.TexStorage1D(target, levels, internalformat, width);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glMemoryBarrier(GLbitfield barriers)
-{
-    d_4_2_Core->f.MemoryBarrier(barriers);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glBindImageTexture(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format)
-{
-    d_4_2_Core->f.BindImageTexture(unit, texture, level, layered, layer, access, format);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetActiveAtomicCounterBufferiv(GLuint program, GLuint bufferIndex, GLenum pname, GLint *params)
-{
-    d_4_2_Core->f.GetActiveAtomicCounterBufferiv(program, bufferIndex, pname, params);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params)
-{
-    d_4_2_Core->f.GetInternalformativ(target, internalformat, pname, bufSize, params);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glDrawTransformFeedbackStreamInstanced(GLenum mode, GLuint id, GLuint stream, GLsizei instancecount)
-{
-    d_4_2_Core->f.DrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glDrawTransformFeedbackInstanced(GLenum mode, GLuint id, GLsizei instancecount)
-{
-    d_4_2_Core->f.DrawTransformFeedbackInstanced(mode, id, instancecount);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glDrawElementsInstancedBaseVertexBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance)
-{
-    d_4_2_Core->f.DrawElementsInstancedBaseVertexBaseInstance(mode, count, type, indices, instancecount, basevertex, baseinstance);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glDrawElementsInstancedBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLuint baseinstance)
-{
-    d_4_2_Core->f.DrawElementsInstancedBaseInstance(mode, count, type, indices, instancecount, baseinstance);
-}
-
-inline void QOpenGLFunctions_4_2_Core::glDrawArraysInstancedBaseInstance(GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance)
-{
-    d_4_2_Core->f.DrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);
-}
-
-
-
-QT_END_NAMESPACE
-
-#ifdef Q_OS_WIN
-#pragma pop_macro("MemoryBarrier")
-#endif
-
-#endif // QT_NO_OPENGL && !QT_OPENGL_ES_2
-
-#endif
diff --git a/src/gui/opengl/qopenglfunctions_4_3_compatibility.cpp b/src/gui/opengl/qopenglfunctions_4_3_compatibility.cpp
deleted file mode 100644
index 1b23d08ee2..0000000000
--- a/src/gui/opengl/qopenglfunctions_4_3_compatibility.cpp
+++ /dev/null
@@ -1,318 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#include "qopenglfunctions_4_3_compatibility.h"
-#include "qopenglcontext.h"
-
-QT_BEGIN_NAMESPACE
-
-/*!
-    \class QOpenGLFunctions_4_3_Compatibility
-    \inmodule QtGui
-    \since 5.1
-    \wrapper
-    \brief The QOpenGLFunctions_4_3_Compatibility class provides all functions for OpenGL 4.3 compatibility profile.
-
-    This class is a wrapper for functions from OpenGL 4.3 compatibility profile.
-    See reference pages on \l {http://www.opengl.org/sdk/docs/}{opengl.org}
-    for function documentation.
-
-    \sa QAbstractOpenGLFunctions
-*/
-
-QOpenGLFunctions_4_3_Compatibility::QOpenGLFunctions_4_3_Compatibility()
- : QAbstractOpenGLFunctions()
- , d_1_0_Core(nullptr)
- , d_1_1_Core(nullptr)
- , d_1_2_Core(nullptr)
- , d_1_3_Core(nullptr)
- , d_1_4_Core(nullptr)
- , d_1_5_Core(nullptr)
- , d_2_0_Core(nullptr)
- , d_2_1_Core(nullptr)
- , d_3_0_Core(nullptr)
- , d_3_1_Core(nullptr)
- , d_3_2_Core(nullptr)
- , d_3_3_Core(nullptr)
- , d_4_0_Core(nullptr)
- , d_4_1_Core(nullptr)
- , d_4_2_Core(nullptr)
- , d_4_3_Core(nullptr)
- , d_1_0_Deprecated(nullptr)
- , d_1_1_Deprecated(nullptr)
- , d_1_2_Deprecated(nullptr)
- , d_1_3_Deprecated(nullptr)
- , d_1_4_Deprecated(nullptr)
- , m_reserved_2_0_Deprecated(nullptr)
- , d_3_3_Deprecated(nullptr)
-{
-}
-
-QOpenGLFunctions_4_3_Compatibility::~QOpenGLFunctions_4_3_Compatibility()
-{
-    if (d_1_0_Core) {
-        d_1_0_Core->refs.deref();
-        Q_ASSERT(d_1_0_Core->refs.loadRelaxed());
-    }
-    if (d_1_1_Core) {
-        d_1_1_Core->refs.deref();
-        Q_ASSERT(d_1_1_Core->refs.loadRelaxed());
-    }
-    if (d_1_2_Core) {
-        d_1_2_Core->refs.deref();
-        Q_ASSERT(d_1_2_Core->refs.loadRelaxed());
-    }
-    if (d_1_3_Core) {
-        d_1_3_Core->refs.deref();
-        Q_ASSERT(d_1_3_Core->refs.loadRelaxed());
-    }
-    if (d_1_4_Core) {
-        d_1_4_Core->refs.deref();
-        Q_ASSERT(d_1_4_Core->refs.loadRelaxed());
-    }
-    if (d_1_5_Core) {
-        d_1_5_Core->refs.deref();
-        Q_ASSERT(d_1_5_Core->refs.loadRelaxed());
-    }
-    if (d_2_0_Core) {
-        d_2_0_Core->refs.deref();
-        Q_ASSERT(d_2_0_Core->refs.loadRelaxed());
-    }
-    if (d_2_1_Core) {
-        d_2_1_Core->refs.deref();
-        Q_ASSERT(d_2_1_Core->refs.loadRelaxed());
-    }
-    if (d_3_0_Core) {
-        d_3_0_Core->refs.deref();
-        Q_ASSERT(d_3_0_Core->refs.loadRelaxed());
-    }
-    if (d_3_1_Core) {
-        d_3_1_Core->refs.deref();
-        Q_ASSERT(d_3_1_Core->refs.loadRelaxed());
-    }
-    if (d_3_2_Core) {
-        d_3_2_Core->refs.deref();
-        Q_ASSERT(d_3_2_Core->refs.loadRelaxed());
-    }
-    if (d_3_3_Core) {
-        d_3_3_Core->refs.deref();
-        Q_ASSERT(d_3_3_Core->refs.loadRelaxed());
-    }
-    if (d_4_0_Core) {
-        d_4_0_Core->refs.deref();
-        Q_ASSERT(d_4_0_Core->refs.loadRelaxed());
-    }
-    if (d_4_1_Core) {
-        d_4_1_Core->refs.deref();
-        Q_ASSERT(d_4_1_Core->refs.loadRelaxed());
-    }
-    if (d_4_2_Core) {
-        d_4_2_Core->refs.deref();
-        Q_ASSERT(d_4_2_Core->refs.loadRelaxed());
-    }
-    if (d_4_3_Core) {
-        d_4_3_Core->refs.deref();
-        Q_ASSERT(d_4_3_Core->refs.loadRelaxed());
-    }
-    if (d_1_0_Deprecated) {
-        d_1_0_Deprecated->refs.deref();
-        Q_ASSERT(d_1_0_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_1_Deprecated) {
-        d_1_1_Deprecated->refs.deref();
-        Q_ASSERT(d_1_1_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_2_Deprecated) {
-        d_1_2_Deprecated->refs.deref();
-        Q_ASSERT(d_1_2_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_3_Deprecated) {
-        d_1_3_Deprecated->refs.deref();
-        Q_ASSERT(d_1_3_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_4_Deprecated) {
-        d_1_4_Deprecated->refs.deref();
-        Q_ASSERT(d_1_4_Deprecated->refs.loadRelaxed());
-    }
-    if (d_3_3_Deprecated) {
-        d_3_3_Deprecated->refs.deref();
-        Q_ASSERT(d_3_3_Deprecated->refs.loadRelaxed());
-    }
-}
-
-bool QOpenGLFunctions_4_3_Compatibility::initializeOpenGLFunctions()
-{
-    if ( isInitialized() )
-        return true;
-
-    QOpenGLContext* context = QOpenGLContext::currentContext();
-
-    // If owned by a context object make sure it is current.
-    // Also check that current context is capable of resolving all needed functions
-    if (((owningContext() && owningContext() == context) || !owningContext())
-        && QOpenGLFunctions_4_3_Compatibility::isContextCompatible(context))
-    {
-        // Associate with private implementation, creating if necessary
-        // Function pointers in the backends are resolved at creation time
-        QOpenGLVersionFunctionsBackend* d = nullptr;
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        d_1_3_Core = static_cast<QOpenGLFunctions_1_3_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        d_1_4_Core = static_cast<QOpenGLFunctions_1_4_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        d_1_5_Core = static_cast<QOpenGLFunctions_1_5_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        d_2_0_Core = static_cast<QOpenGLFunctions_2_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        d_2_1_Core = static_cast<QOpenGLFunctions_2_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        d_3_0_Core = static_cast<QOpenGLFunctions_3_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
-        d_3_1_Core = static_cast<QOpenGLFunctions_3_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
-        d_3_2_Core = static_cast<QOpenGLFunctions_3_2_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_CoreBackend::versionStatus());
-        d_3_3_Core = static_cast<QOpenGLFunctions_3_3_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_0_CoreBackend::versionStatus());
-        d_4_0_Core = static_cast<QOpenGLFunctions_4_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_1_CoreBackend::versionStatus());
-        d_4_1_Core = static_cast<QOpenGLFunctions_4_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_2_CoreBackend::versionStatus());
-        d_4_2_Core = static_cast<QOpenGLFunctions_4_2_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_3_CoreBackend::versionStatus());
-        d_4_3_Core = static_cast<QOpenGLFunctions_4_3_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
-        d_1_0_Deprecated = static_cast<QOpenGLFunctions_1_0_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
-        d_1_1_Deprecated = static_cast<QOpenGLFunctions_1_1_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus());
-        d_1_2_Deprecated = static_cast<QOpenGLFunctions_1_2_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus());
-        d_1_3_Deprecated = static_cast<QOpenGLFunctions_1_3_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
-        d_1_4_Deprecated = static_cast<QOpenGLFunctions_1_4_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_DeprecatedBackend::versionStatus());
-        d_3_3_Deprecated = static_cast<QOpenGLFunctions_3_3_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        QAbstractOpenGLFunctions::initializeOpenGLFunctions();
-    }
-    return isInitialized();
-}
-
-bool QOpenGLFunctions_4_3_Compatibility::isContextCompatible(QOpenGLContext *context)
-{
-    Q_ASSERT(context);
-    QSurfaceFormat f = context->format();
-    const QPair<int, int> v = qMakePair(f.majorVersion(), f.minorVersion());
-    if (v < qMakePair(4, 3))
-        return false;
-
-    if (f.profile() == QSurfaceFormat::CoreProfile)
-        return false;
-
-    return true;
-}
-
-QOpenGLVersionProfile QOpenGLFunctions_4_3_Compatibility::versionProfile()
-{
-    QOpenGLVersionProfile v;
-    v.setVersion(4, 3);
-    v.setProfile(QSurfaceFormat::CompatibilityProfile);
-    return v;
-}
-
-QT_END_NAMESPACE
diff --git a/src/gui/opengl/qopenglfunctions_4_3_compatibility.h b/src/gui/opengl/qopenglfunctions_4_3_compatibility.h
deleted file mode 100644
index d969f5b3b4..0000000000
--- a/src/gui/opengl/qopenglfunctions_4_3_compatibility.h
+++ /dev/null
@@ -1,5854 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#ifndef QOPENGLVERSIONFUNCTIONS_4_3_COMPATIBILITY_H
-#define QOPENGLVERSIONFUNCTIONS_4_3_COMPATIBILITY_H
-
-#include <QtGui/qtguiglobal.h>
-
-#if !defined(QT_NO_OPENGL) && !defined(QT_OPENGL_ES_2)
-
-#include <QtGui/QOpenGLVersionFunctions>
-#include <QtGui/qopenglcontext.h>
-
-// MemoryBarrier is a macro on some architectures on Windows
-#ifdef Q_OS_WIN
-#pragma push_macro("MemoryBarrier")
-#undef MemoryBarrier
-#endif
-
-QT_BEGIN_NAMESPACE
-
-class Q_GUI_EXPORT QOpenGLFunctions_4_3_Compatibility : public QAbstractOpenGLFunctions
-{
-public:
-    QOpenGLFunctions_4_3_Compatibility();
-    ~QOpenGLFunctions_4_3_Compatibility();
-
-    bool initializeOpenGLFunctions() override;
-
-    // OpenGL 1.0 core functions
-    void glViewport(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glDepthRange(GLdouble nearVal, GLdouble farVal);
-    GLboolean glIsEnabled(GLenum cap);
-    void glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params);
-    void glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params);
-    void glGetTexParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
-    const GLubyte * glGetString(GLenum name);
-    void glGetIntegerv(GLenum pname, GLint *params);
-    void glGetFloatv(GLenum pname, GLfloat *params);
-    GLenum glGetError();
-    void glGetDoublev(GLenum pname, GLdouble *params);
-    void glGetBooleanv(GLenum pname, GLboolean *params);
-    void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
-    void glReadBuffer(GLenum mode);
-    void glPixelStorei(GLenum pname, GLint param);
-    void glPixelStoref(GLenum pname, GLfloat param);
-    void glDepthFunc(GLenum func);
-    void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass);
-    void glStencilFunc(GLenum func, GLint ref, GLuint mask);
-    void glLogicOp(GLenum opcode);
-    void glBlendFunc(GLenum sfactor, GLenum dfactor);
-    void glFlush();
-    void glFinish();
-    void glEnable(GLenum cap);
-    void glDisable(GLenum cap);
-    void glDepthMask(GLboolean flag);
-    void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
-    void glStencilMask(GLuint mask);
-    void glClearDepth(GLdouble depth);
-    void glClearStencil(GLint s);
-    void glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glClear(GLbitfield mask);
-    void glDrawBuffer(GLenum mode);
-    void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glTexParameteri(GLenum target, GLenum pname, GLint param);
-    void glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glTexParameterf(GLenum target, GLenum pname, GLfloat param);
-    void glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glPolygonMode(GLenum face, GLenum mode);
-    void glPointSize(GLfloat size);
-    void glLineWidth(GLfloat width);
-    void glHint(GLenum target, GLenum mode);
-    void glFrontFace(GLenum mode);
-    void glCullFace(GLenum mode);
-
-    // OpenGL 1.1 core functions
-    void glIndexubv(const GLubyte *c);
-    void glIndexub(GLubyte c);
-    GLboolean glIsTexture(GLuint texture);
-    void glGenTextures(GLsizei n, GLuint *textures);
-    void glDeleteTextures(GLsizei n, const GLuint *textures);
-    void glBindTexture(GLenum target, GLuint texture);
-    void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
-    void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
-    void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
-    void glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
-    void glPolygonOffset(GLfloat factor, GLfloat units);
-    void glGetPointerv(GLenum pname, GLvoid* *params);
-    void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
-    void glDrawArrays(GLenum mode, GLint first, GLsizei count);
-
-    // OpenGL 1.2 core functions
-    void glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices);
-    void glBlendEquation(GLenum mode);
-    void glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-
-    // OpenGL 1.3 core functions
-    void glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img);
-    void glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glSampleCoverage(GLfloat value, GLboolean invert);
-    void glActiveTexture(GLenum texture);
-
-    // OpenGL 1.4 core functions
-    void glPointParameteriv(GLenum pname, const GLint *params);
-    void glPointParameteri(GLenum pname, GLint param);
-    void glPointParameterfv(GLenum pname, const GLfloat *params);
-    void glPointParameterf(GLenum pname, GLfloat param);
-    void glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount);
-    void glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount);
-    void glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
-
-    // OpenGL 1.5 core functions
-    void glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params);
-    void glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params);
-    GLboolean glUnmapBuffer(GLenum target);
-    GLvoid* glMapBuffer(GLenum target, GLenum access);
-    void glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data);
-    void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data);
-    void glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage);
-    GLboolean glIsBuffer(GLuint buffer);
-    void glGenBuffers(GLsizei n, GLuint *buffers);
-    void glDeleteBuffers(GLsizei n, const GLuint *buffers);
-    void glBindBuffer(GLenum target, GLuint buffer);
-    void glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params);
-    void glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params);
-    void glGetQueryiv(GLenum target, GLenum pname, GLint *params);
-    void glEndQuery(GLenum target);
-    void glBeginQuery(GLenum target, GLuint id);
-    GLboolean glIsQuery(GLuint id);
-    void glDeleteQueries(GLsizei n, const GLuint *ids);
-    void glGenQueries(GLsizei n, GLuint *ids);
-
-    // OpenGL 2.0 core functions
-    void glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer);
-    void glValidateProgram(GLuint program);
-    void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniform4iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform3iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform2iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform1iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform4fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform3fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform2fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform1fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
-    void glUniform3i(GLint location, GLint v0, GLint v1, GLint v2);
-    void glUniform2i(GLint location, GLint v0, GLint v1);
-    void glUniform1i(GLint location, GLint v0);
-    void glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
-    void glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
-    void glUniform2f(GLint location, GLfloat v0, GLfloat v1);
-    void glUniform1f(GLint location, GLfloat v0);
-    void glUseProgram(GLuint program);
-    void glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length);
-    void glLinkProgram(GLuint program);
-    GLboolean glIsShader(GLuint shader);
-    GLboolean glIsProgram(GLuint program);
-    void glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer);
-    void glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params);
-    void glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params);
-    void glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params);
-    void glGetUniformiv(GLuint program, GLint location, GLint *params);
-    void glGetUniformfv(GLuint program, GLint location, GLfloat *params);
-    GLint glGetUniformLocation(GLuint program, const GLchar *name);
-    void glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source);
-    void glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void glGetShaderiv(GLuint shader, GLenum pname, GLint *params);
-    void glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void glGetProgramiv(GLuint program, GLenum pname, GLint *params);
-    GLint glGetAttribLocation(GLuint program, const GLchar *name);
-    void glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj);
-    void glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
-    void glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
-    void glEnableVertexAttribArray(GLuint index);
-    void glDisableVertexAttribArray(GLuint index);
-    void glDetachShader(GLuint program, GLuint shader);
-    void glDeleteShader(GLuint shader);
-    void glDeleteProgram(GLuint program);
-    GLuint glCreateShader(GLenum type);
-    GLuint glCreateProgram();
-    void glCompileShader(GLuint shader);
-    void glBindAttribLocation(GLuint program, GLuint index, const GLchar *name);
-    void glAttachShader(GLuint program, GLuint shader);
-    void glStencilMaskSeparate(GLenum face, GLuint mask);
-    void glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask);
-    void glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);
-    void glDrawBuffers(GLsizei n, const GLenum *bufs);
-    void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha);
-
-    // OpenGL 2.1 core functions
-    void glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-
-    // OpenGL 3.0 core functions
-    GLboolean glIsVertexArray(GLuint array);
-    void glGenVertexArrays(GLsizei n, GLuint *arrays);
-    void glDeleteVertexArrays(GLsizei n, const GLuint *arrays);
-    void glBindVertexArray(GLuint array);
-    void glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length);
-    GLvoid* glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
-    void glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
-    void glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
-    void glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
-    void glGenerateMipmap(GLenum target);
-    void glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params);
-    void glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
-    void glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset);
-    void glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
-    void glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
-    GLenum glCheckFramebufferStatus(GLenum target);
-    void glGenFramebuffers(GLsizei n, GLuint *framebuffers);
-    void glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers);
-    void glBindFramebuffer(GLenum target, GLuint framebuffer);
-    GLboolean glIsFramebuffer(GLuint framebuffer);
-    void glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
-    void glGenRenderbuffers(GLsizei n, GLuint *renderbuffers);
-    void glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers);
-    void glBindRenderbuffer(GLenum target, GLuint renderbuffer);
-    GLboolean glIsRenderbuffer(GLuint renderbuffer);
-    const GLubyte * glGetStringi(GLenum name, GLuint index);
-    void glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
-    void glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value);
-    void glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value);
-    void glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value);
-    void glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params);
-    void glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params);
-    void glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params);
-    void glTexParameterIiv(GLenum target, GLenum pname, const GLint *params);
-    void glUniform4uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform3uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform2uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform1uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
-    void glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2);
-    void glUniform2ui(GLint location, GLuint v0, GLuint v1);
-    void glUniform1ui(GLint location, GLuint v0);
-    GLint glGetFragDataLocation(GLuint program, const GLchar *name);
-    void glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name);
-    void glGetUniformuiv(GLuint program, GLint location, GLuint *params);
-    void glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params);
-    void glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params);
-    void glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glEndConditionalRender();
-    void glBeginConditionalRender(GLuint id, GLenum mode);
-    void glClampColor(GLenum target, GLenum clamp);
-    void glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name);
-    void glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode);
-    void glBindBufferBase(GLenum target, GLuint index, GLuint buffer);
-    void glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
-    void glEndTransformFeedback();
-    void glBeginTransformFeedback(GLenum primitiveMode);
-    GLboolean glIsEnabledi(GLenum target, GLuint index);
-    void glDisablei(GLenum target, GLuint index);
-    void glEnablei(GLenum target, GLuint index);
-    void glGetIntegeri_v(GLenum target, GLuint index, GLint *data);
-    void glGetBooleani_v(GLenum target, GLuint index, GLboolean *data);
-    void glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a);
-
-    // OpenGL 3.1 core functions
-    void glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
-    void glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);
-    void glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName);
-    void glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params);
-    GLuint glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName);
-    void glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName);
-    void glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params);
-    void glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const *uniformNames, GLuint *uniformIndices);
-    void glPrimitiveRestartIndex(GLuint index);
-    void glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer);
-    void glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount);
-    void glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount);
-
-    // OpenGL 3.2 core functions
-    void glSampleMaski(GLuint index, GLbitfield mask);
-    void glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val);
-    void glTexImage3DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
-    void glTexImage2DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
-    void glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values);
-    void glGetInteger64v(GLenum pname, GLint64 *params);
-    void glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout);
-    GLenum glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout);
-    void glDeleteSync(GLsync sync);
-    GLboolean glIsSync(GLsync sync);
-    GLsync glFenceSync(GLenum condition, GLbitfield flags);
-    void glProvokingVertex(GLenum mode);
-    void glMultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount, const GLint *basevertex);
-    void glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount, GLint basevertex);
-    void glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex);
-    void glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex);
-    void glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level);
-    void glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params);
-    void glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data);
-
-    // OpenGL 3.3 core functions
-    void glVertexAttribP4uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glVertexAttribP3uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glVertexAttribP2uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glVertexAttribP1uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glSecondaryColorP3uiv(GLenum type, const GLuint *color);
-    void glSecondaryColorP3ui(GLenum type, GLuint color);
-    void glColorP4uiv(GLenum type, const GLuint *color);
-    void glColorP4ui(GLenum type, GLuint color);
-    void glColorP3uiv(GLenum type, const GLuint *color);
-    void glColorP3ui(GLenum type, GLuint color);
-    void glNormalP3uiv(GLenum type, const GLuint *coords);
-    void glNormalP3ui(GLenum type, GLuint coords);
-    void glMultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint *coords);
-    void glMultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords);
-    void glMultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint *coords);
-    void glMultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords);
-    void glMultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint *coords);
-    void glMultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords);
-    void glMultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint *coords);
-    void glMultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords);
-    void glTexCoordP4uiv(GLenum type, const GLuint *coords);
-    void glTexCoordP4ui(GLenum type, GLuint coords);
-    void glTexCoordP3uiv(GLenum type, const GLuint *coords);
-    void glTexCoordP3ui(GLenum type, GLuint coords);
-    void glTexCoordP2uiv(GLenum type, const GLuint *coords);
-    void glTexCoordP2ui(GLenum type, GLuint coords);
-    void glTexCoordP1uiv(GLenum type, const GLuint *coords);
-    void glTexCoordP1ui(GLenum type, GLuint coords);
-    void glVertexP4uiv(GLenum type, const GLuint *value);
-    void glVertexP4ui(GLenum type, GLuint value);
-    void glVertexP3uiv(GLenum type, const GLuint *value);
-    void glVertexP3ui(GLenum type, GLuint value);
-    void glVertexP2uiv(GLenum type, const GLuint *value);
-    void glVertexP2ui(GLenum type, GLuint value);
-    void glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params);
-    void glGetQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params);
-    void glQueryCounter(GLuint id, GLenum target);
-    void glGetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params);
-    void glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params);
-    void glGetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params);
-    void glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params);
-    void glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param);
-    void glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param);
-    void glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param);
-    void glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param);
-    void glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param);
-    void glSamplerParameteri(GLuint sampler, GLenum pname, GLint param);
-    void glBindSampler(GLuint unit, GLuint sampler);
-    GLboolean glIsSampler(GLuint sampler);
-    void glDeleteSamplers(GLsizei count, const GLuint *samplers);
-    void glGenSamplers(GLsizei count, GLuint *samplers);
-    GLint glGetFragDataIndex(GLuint program, const GLchar *name);
-    void glBindFragDataLocationIndexed(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name);
-    void glVertexAttribDivisor(GLuint index, GLuint divisor);
-
-    // OpenGL 4.0 core functions
-    void glGetQueryIndexediv(GLenum target, GLuint index, GLenum pname, GLint *params);
-    void glEndQueryIndexed(GLenum target, GLuint index);
-    void glBeginQueryIndexed(GLenum target, GLuint index, GLuint id);
-    void glDrawTransformFeedbackStream(GLenum mode, GLuint id, GLuint stream);
-    void glDrawTransformFeedback(GLenum mode, GLuint id);
-    void glResumeTransformFeedback();
-    void glPauseTransformFeedback();
-    GLboolean glIsTransformFeedback(GLuint id);
-    void glGenTransformFeedbacks(GLsizei n, GLuint *ids);
-    void glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids);
-    void glBindTransformFeedback(GLenum target, GLuint id);
-    void glPatchParameterfv(GLenum pname, const GLfloat *values);
-    void glPatchParameteri(GLenum pname, GLint value);
-    void glGetProgramStageiv(GLuint program, GLenum shadertype, GLenum pname, GLint *values);
-    void glGetUniformSubroutineuiv(GLenum shadertype, GLint location, GLuint *params);
-    void glUniformSubroutinesuiv(GLenum shadertype, GLsizei count, const GLuint *indices);
-    void glGetActiveSubroutineName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name);
-    void glGetActiveSubroutineUniformName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name);
-    void glGetActiveSubroutineUniformiv(GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values);
-    GLuint glGetSubroutineIndex(GLuint program, GLenum shadertype, const GLchar *name);
-    GLint glGetSubroutineUniformLocation(GLuint program, GLenum shadertype, const GLchar *name);
-    void glGetUniformdv(GLuint program, GLint location, GLdouble *params);
-    void glUniformMatrix4x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix4x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix3x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix3x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix2x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix2x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniform4dv(GLint location, GLsizei count, const GLdouble *value);
-    void glUniform3dv(GLint location, GLsizei count, const GLdouble *value);
-    void glUniform2dv(GLint location, GLsizei count, const GLdouble *value);
-    void glUniform1dv(GLint location, GLsizei count, const GLdouble *value);
-    void glUniform4d(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glUniform3d(GLint location, GLdouble x, GLdouble y, GLdouble z);
-    void glUniform2d(GLint location, GLdouble x, GLdouble y);
-    void glUniform1d(GLint location, GLdouble x);
-    void glDrawElementsIndirect(GLenum mode, GLenum type, const GLvoid *indirect);
-    void glDrawArraysIndirect(GLenum mode, const GLvoid *indirect);
-    void glBlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
-    void glBlendFunci(GLuint buf, GLenum src, GLenum dst);
-    void glBlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha);
-    void glBlendEquationi(GLuint buf, GLenum mode);
-    void glMinSampleShading(GLfloat value);
-
-    // OpenGL 4.1 core functions
-    void glGetDoublei_v(GLenum target, GLuint index, GLdouble *data);
-    void glGetFloati_v(GLenum target, GLuint index, GLfloat *data);
-    void glDepthRangeIndexed(GLuint index, GLdouble n, GLdouble f);
-    void glDepthRangeArrayv(GLuint first, GLsizei count, const GLdouble *v);
-    void glScissorIndexedv(GLuint index, const GLint *v);
-    void glScissorIndexed(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height);
-    void glScissorArrayv(GLuint first, GLsizei count, const GLint *v);
-    void glViewportIndexedfv(GLuint index, const GLfloat *v);
-    void glViewportIndexedf(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h);
-    void glViewportArrayv(GLuint first, GLsizei count, const GLfloat *v);
-    void glGetVertexAttribLdv(GLuint index, GLenum pname, GLdouble *params);
-    void glVertexAttribLPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glVertexAttribL4dv(GLuint index, const GLdouble *v);
-    void glVertexAttribL3dv(GLuint index, const GLdouble *v);
-    void glVertexAttribL2dv(GLuint index, const GLdouble *v);
-    void glVertexAttribL1dv(GLuint index, const GLdouble *v);
-    void glVertexAttribL4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glVertexAttribL3d(GLuint index, GLdouble x, GLdouble y, GLdouble z);
-    void glVertexAttribL2d(GLuint index, GLdouble x, GLdouble y);
-    void glVertexAttribL1d(GLuint index, GLdouble x);
-    void glGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void glValidateProgramPipeline(GLuint pipeline);
-    void glProgramUniformMatrix4x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix3x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix4x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix2x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix3x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix2x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix4x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix3x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix4x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix2x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix3x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix2x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniform4uiv(GLuint program, GLint location, GLsizei count, const GLuint *value);
-    void glProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
-    void glProgramUniform4dv(GLuint program, GLint location, GLsizei count, const GLdouble *value);
-    void glProgramUniform4d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3);
-    void glProgramUniform4fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-    void glProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
-    void glProgramUniform4iv(GLuint program, GLint location, GLsizei count, const GLint *value);
-    void glProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
-    void glProgramUniform3uiv(GLuint program, GLint location, GLsizei count, const GLuint *value);
-    void glProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2);
-    void glProgramUniform3dv(GLuint program, GLint location, GLsizei count, const GLdouble *value);
-    void glProgramUniform3d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2);
-    void glProgramUniform3fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-    void glProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
-    void glProgramUniform3iv(GLuint program, GLint location, GLsizei count, const GLint *value);
-    void glProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2);
-    void glProgramUniform2uiv(GLuint program, GLint location, GLsizei count, const GLuint *value);
-    void glProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1);
-    void glProgramUniform2dv(GLuint program, GLint location, GLsizei count, const GLdouble *value);
-    void glProgramUniform2d(GLuint program, GLint location, GLdouble v0, GLdouble v1);
-    void glProgramUniform2fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-    void glProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1);
-    void glProgramUniform2iv(GLuint program, GLint location, GLsizei count, const GLint *value);
-    void glProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1);
-    void glProgramUniform1uiv(GLuint program, GLint location, GLsizei count, const GLuint *value);
-    void glProgramUniform1ui(GLuint program, GLint location, GLuint v0);
-    void glProgramUniform1dv(GLuint program, GLint location, GLsizei count, const GLdouble *value);
-    void glProgramUniform1d(GLuint program, GLint location, GLdouble v0);
-    void glProgramUniform1fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-    void glProgramUniform1f(GLuint program, GLint location, GLfloat v0);
-    void glProgramUniform1iv(GLuint program, GLint location, GLsizei count, const GLint *value);
-    void glProgramUniform1i(GLuint program, GLint location, GLint v0);
-    void glGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params);
-    GLboolean glIsProgramPipeline(GLuint pipeline);
-    void glGenProgramPipelines(GLsizei n, GLuint *pipelines);
-    void glDeleteProgramPipelines(GLsizei n, const GLuint *pipelines);
-    void glBindProgramPipeline(GLuint pipeline);
-    GLuint glCreateShaderProgramv(GLenum type, GLsizei count, const GLchar* const *strings);
-    void glActiveShaderProgram(GLuint pipeline, GLuint program);
-    void glUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program);
-    void glProgramParameteri(GLuint program, GLenum pname, GLint value);
-    void glProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid *binary, GLsizei length);
-    void glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, GLvoid *binary);
-    void glClearDepthf(GLfloat dd);
-    void glDepthRangef(GLfloat n, GLfloat f);
-    void glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision);
-    void glShaderBinary(GLsizei count, const GLuint *shaders, GLenum binaryformat, const GLvoid *binary, GLsizei length);
-    void glReleaseShaderCompiler();
-
-    // OpenGL 4.2 core functions
-    void glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
-    void glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);
-    void glTexStorage1D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width);
-    void glMemoryBarrier(GLbitfield barriers);
-    void glBindImageTexture(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format);
-    void glGetActiveAtomicCounterBufferiv(GLuint program, GLuint bufferIndex, GLenum pname, GLint *params);
-    void glGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params);
-    void glDrawTransformFeedbackStreamInstanced(GLenum mode, GLuint id, GLuint stream, GLsizei instancecount);
-    void glDrawTransformFeedbackInstanced(GLenum mode, GLuint id, GLsizei instancecount);
-    void glDrawElementsInstancedBaseVertexBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance);
-    void glDrawElementsInstancedBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLuint baseinstance);
-    void glDrawArraysInstancedBaseInstance(GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance);
-
-    // OpenGL 4.3 core functions
-    void glTexStorage3DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
-    void glTexStorage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
-    void glTexBufferRange(GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size);
-    void glShaderStorageBlockBinding(GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding);
-    GLint glGetProgramResourceLocationIndex(GLuint program, GLenum programInterface, const GLchar *name);
-    GLint glGetProgramResourceLocation(GLuint program, GLenum programInterface, const GLchar *name);
-    void glGetProgramResourceiv(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params);
-    void glGetProgramResourceName(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name);
-    GLuint glGetProgramResourceIndex(GLuint program, GLenum programInterface, const GLchar *name);
-    void glGetProgramInterfaceiv(GLuint program, GLenum programInterface, GLenum pname, GLint *params);
-    void glMultiDrawElementsIndirect(GLenum mode, GLenum type, const void *indirect, GLsizei drawcount, GLsizei stride);
-    void glMultiDrawArraysIndirect(GLenum mode, const void *indirect, GLsizei drawcount, GLsizei stride);
-    void glInvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glInvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments);
-    void glInvalidateBufferData(GLuint buffer);
-    void glInvalidateBufferSubData(GLuint buffer, GLintptr offset, GLsizeiptr length);
-    void glInvalidateTexImage(GLuint texture, GLint level);
-    void glInvalidateTexSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth);
-    void glGetInternalformati64v(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint64 *params);
-    void glGetFramebufferParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glFramebufferParameteri(GLenum target, GLenum pname, GLint param);
-    void glVertexBindingDivisor(GLuint bindingindex, GLuint divisor);
-    void glVertexAttribBinding(GLuint attribindex, GLuint bindingindex);
-    void glVertexAttribLFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);
-    void glVertexAttribIFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);
-    void glVertexAttribFormat(GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset);
-    void glBindVertexBuffer(GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride);
-    void glTextureView(GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers);
-    void glCopyImageSubData(GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth);
-    void glDispatchComputeIndirect(GLintptr indirect);
-    void glDispatchCompute(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z);
-    void glClearBufferSubData(GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data);
-    void glClearBufferData(GLenum target, GLenum internalformat, GLenum format, GLenum type, const void *data);
-
-    // OpenGL 1.0 deprecated functions
-    void glTranslatef(GLfloat x, GLfloat y, GLfloat z);
-    void glTranslated(GLdouble x, GLdouble y, GLdouble z);
-    void glScalef(GLfloat x, GLfloat y, GLfloat z);
-    void glScaled(GLdouble x, GLdouble y, GLdouble z);
-    void glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
-    void glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
-    void glPushMatrix();
-    void glPopMatrix();
-    void glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
-    void glMultMatrixd(const GLdouble *m);
-    void glMultMatrixf(const GLfloat *m);
-    void glMatrixMode(GLenum mode);
-    void glLoadMatrixd(const GLdouble *m);
-    void glLoadMatrixf(const GLfloat *m);
-    void glLoadIdentity();
-    void glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
-    GLboolean glIsList(GLuint list);
-    void glGetTexGeniv(GLenum coord, GLenum pname, GLint *params);
-    void glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params);
-    void glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params);
-    void glGetTexEnviv(GLenum target, GLenum pname, GLint *params);
-    void glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetPolygonStipple(GLubyte *mask);
-    void glGetPixelMapusv(GLenum map, GLushort *values);
-    void glGetPixelMapuiv(GLenum map, GLuint *values);
-    void glGetPixelMapfv(GLenum map, GLfloat *values);
-    void glGetMaterialiv(GLenum face, GLenum pname, GLint *params);
-    void glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params);
-    void glGetMapiv(GLenum target, GLenum query, GLint *v);
-    void glGetMapfv(GLenum target, GLenum query, GLfloat *v);
-    void glGetMapdv(GLenum target, GLenum query, GLdouble *v);
-    void glGetLightiv(GLenum light, GLenum pname, GLint *params);
-    void glGetLightfv(GLenum light, GLenum pname, GLfloat *params);
-    void glGetClipPlane(GLenum plane, GLdouble *equation);
-    void glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
-    void glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
-    void glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values);
-    void glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values);
-    void glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values);
-    void glPixelTransferi(GLenum pname, GLint param);
-    void glPixelTransferf(GLenum pname, GLfloat param);
-    void glPixelZoom(GLfloat xfactor, GLfloat yfactor);
-    void glAlphaFunc(GLenum func, GLfloat ref);
-    void glEvalPoint2(GLint i, GLint j);
-    void glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
-    void glEvalPoint1(GLint i);
-    void glEvalMesh1(GLenum mode, GLint i1, GLint i2);
-    void glEvalCoord2fv(const GLfloat *u);
-    void glEvalCoord2f(GLfloat u, GLfloat v);
-    void glEvalCoord2dv(const GLdouble *u);
-    void glEvalCoord2d(GLdouble u, GLdouble v);
-    void glEvalCoord1fv(const GLfloat *u);
-    void glEvalCoord1f(GLfloat u);
-    void glEvalCoord1dv(const GLdouble *u);
-    void glEvalCoord1d(GLdouble u);
-    void glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
-    void glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
-    void glMapGrid1f(GLint un, GLfloat u1, GLfloat u2);
-    void glMapGrid1d(GLint un, GLdouble u1, GLdouble u2);
-    void glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);
-    void glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);
-    void glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);
-    void glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);
-    void glPushAttrib(GLbitfield mask);
-    void glPopAttrib();
-    void glAccum(GLenum op, GLfloat value);
-    void glIndexMask(GLuint mask);
-    void glClearIndex(GLfloat c);
-    void glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glPushName(GLuint name);
-    void glPopName();
-    void glPassThrough(GLfloat token);
-    void glLoadName(GLuint name);
-    void glInitNames();
-    GLint glRenderMode(GLenum mode);
-    void glSelectBuffer(GLsizei size, GLuint *buffer);
-    void glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer);
-    void glTexGeniv(GLenum coord, GLenum pname, const GLint *params);
-    void glTexGeni(GLenum coord, GLenum pname, GLint param);
-    void glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params);
-    void glTexGenf(GLenum coord, GLenum pname, GLfloat param);
-    void glTexGendv(GLenum coord, GLenum pname, const GLdouble *params);
-    void glTexGend(GLenum coord, GLenum pname, GLdouble param);
-    void glTexEnviv(GLenum target, GLenum pname, const GLint *params);
-    void glTexEnvi(GLenum target, GLenum pname, GLint param);
-    void glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glTexEnvf(GLenum target, GLenum pname, GLfloat param);
-    void glShadeModel(GLenum mode);
-    void glPolygonStipple(const GLubyte *mask);
-    void glMaterialiv(GLenum face, GLenum pname, const GLint *params);
-    void glMateriali(GLenum face, GLenum pname, GLint param);
-    void glMaterialfv(GLenum face, GLenum pname, const GLfloat *params);
-    void glMaterialf(GLenum face, GLenum pname, GLfloat param);
-    void glLineStipple(GLint factor, GLushort pattern);
-    void glLightModeliv(GLenum pname, const GLint *params);
-    void glLightModeli(GLenum pname, GLint param);
-    void glLightModelfv(GLenum pname, const GLfloat *params);
-    void glLightModelf(GLenum pname, GLfloat param);
-    void glLightiv(GLenum light, GLenum pname, const GLint *params);
-    void glLighti(GLenum light, GLenum pname, GLint param);
-    void glLightfv(GLenum light, GLenum pname, const GLfloat *params);
-    void glLightf(GLenum light, GLenum pname, GLfloat param);
-    void glFogiv(GLenum pname, const GLint *params);
-    void glFogi(GLenum pname, GLint param);
-    void glFogfv(GLenum pname, const GLfloat *params);
-    void glFogf(GLenum pname, GLfloat param);
-    void glColorMaterial(GLenum face, GLenum mode);
-    void glClipPlane(GLenum plane, const GLdouble *equation);
-    void glVertex4sv(const GLshort *v);
-    void glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w);
-    void glVertex4iv(const GLint *v);
-    void glVertex4i(GLint x, GLint y, GLint z, GLint w);
-    void glVertex4fv(const GLfloat *v);
-    void glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void glVertex4dv(const GLdouble *v);
-    void glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glVertex3sv(const GLshort *v);
-    void glVertex3s(GLshort x, GLshort y, GLshort z);
-    void glVertex3iv(const GLint *v);
-    void glVertex3i(GLint x, GLint y, GLint z);
-    void glVertex3fv(const GLfloat *v);
-    void glVertex3f(GLfloat x, GLfloat y, GLfloat z);
-    void glVertex3dv(const GLdouble *v);
-    void glVertex3d(GLdouble x, GLdouble y, GLdouble z);
-    void glVertex2sv(const GLshort *v);
-    void glVertex2s(GLshort x, GLshort y);
-    void glVertex2iv(const GLint *v);
-    void glVertex2i(GLint x, GLint y);
-    void glVertex2fv(const GLfloat *v);
-    void glVertex2f(GLfloat x, GLfloat y);
-    void glVertex2dv(const GLdouble *v);
-    void glVertex2d(GLdouble x, GLdouble y);
-    void glTexCoord4sv(const GLshort *v);
-    void glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q);
-    void glTexCoord4iv(const GLint *v);
-    void glTexCoord4i(GLint s, GLint t, GLint r, GLint q);
-    void glTexCoord4fv(const GLfloat *v);
-    void glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
-    void glTexCoord4dv(const GLdouble *v);
-    void glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q);
-    void glTexCoord3sv(const GLshort *v);
-    void glTexCoord3s(GLshort s, GLshort t, GLshort r);
-    void glTexCoord3iv(const GLint *v);
-    void glTexCoord3i(GLint s, GLint t, GLint r);
-    void glTexCoord3fv(const GLfloat *v);
-    void glTexCoord3f(GLfloat s, GLfloat t, GLfloat r);
-    void glTexCoord3dv(const GLdouble *v);
-    void glTexCoord3d(GLdouble s, GLdouble t, GLdouble r);
-    void glTexCoord2sv(const GLshort *v);
-    void glTexCoord2s(GLshort s, GLshort t);
-    void glTexCoord2iv(const GLint *v);
-    void glTexCoord2i(GLint s, GLint t);
-    void glTexCoord2fv(const GLfloat *v);
-    void glTexCoord2f(GLfloat s, GLfloat t);
-    void glTexCoord2dv(const GLdouble *v);
-    void glTexCoord2d(GLdouble s, GLdouble t);
-    void glTexCoord1sv(const GLshort *v);
-    void glTexCoord1s(GLshort s);
-    void glTexCoord1iv(const GLint *v);
-    void glTexCoord1i(GLint s);
-    void glTexCoord1fv(const GLfloat *v);
-    void glTexCoord1f(GLfloat s);
-    void glTexCoord1dv(const GLdouble *v);
-    void glTexCoord1d(GLdouble s);
-    void glRectsv(const GLshort *v1, const GLshort *v2);
-    void glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
-    void glRectiv(const GLint *v1, const GLint *v2);
-    void glRecti(GLint x1, GLint y1, GLint x2, GLint y2);
-    void glRectfv(const GLfloat *v1, const GLfloat *v2);
-    void glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
-    void glRectdv(const GLdouble *v1, const GLdouble *v2);
-    void glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
-    void glRasterPos4sv(const GLshort *v);
-    void glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w);
-    void glRasterPos4iv(const GLint *v);
-    void glRasterPos4i(GLint x, GLint y, GLint z, GLint w);
-    void glRasterPos4fv(const GLfloat *v);
-    void glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void glRasterPos4dv(const GLdouble *v);
-    void glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glRasterPos3sv(const GLshort *v);
-    void glRasterPos3s(GLshort x, GLshort y, GLshort z);
-    void glRasterPos3iv(const GLint *v);
-    void glRasterPos3i(GLint x, GLint y, GLint z);
-    void glRasterPos3fv(const GLfloat *v);
-    void glRasterPos3f(GLfloat x, GLfloat y, GLfloat z);
-    void glRasterPos3dv(const GLdouble *v);
-    void glRasterPos3d(GLdouble x, GLdouble y, GLdouble z);
-    void glRasterPos2sv(const GLshort *v);
-    void glRasterPos2s(GLshort x, GLshort y);
-    void glRasterPos2iv(const GLint *v);
-    void glRasterPos2i(GLint x, GLint y);
-    void glRasterPos2fv(const GLfloat *v);
-    void glRasterPos2f(GLfloat x, GLfloat y);
-    void glRasterPos2dv(const GLdouble *v);
-    void glRasterPos2d(GLdouble x, GLdouble y);
-    void glNormal3sv(const GLshort *v);
-    void glNormal3s(GLshort nx, GLshort ny, GLshort nz);
-    void glNormal3iv(const GLint *v);
-    void glNormal3i(GLint nx, GLint ny, GLint nz);
-    void glNormal3fv(const GLfloat *v);
-    void glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz);
-    void glNormal3dv(const GLdouble *v);
-    void glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz);
-    void glNormal3bv(const GLbyte *v);
-    void glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz);
-    void glIndexsv(const GLshort *c);
-    void glIndexs(GLshort c);
-    void glIndexiv(const GLint *c);
-    void glIndexi(GLint c);
-    void glIndexfv(const GLfloat *c);
-    void glIndexf(GLfloat c);
-    void glIndexdv(const GLdouble *c);
-    void glIndexd(GLdouble c);
-    void glEnd();
-    void glEdgeFlagv(const GLboolean *flag);
-    void glEdgeFlag(GLboolean flag);
-    void glColor4usv(const GLushort *v);
-    void glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha);
-    void glColor4uiv(const GLuint *v);
-    void glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha);
-    void glColor4ubv(const GLubyte *v);
-    void glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
-    void glColor4sv(const GLshort *v);
-    void glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha);
-    void glColor4iv(const GLint *v);
-    void glColor4i(GLint red, GLint green, GLint blue, GLint alpha);
-    void glColor4fv(const GLfloat *v);
-    void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glColor4dv(const GLdouble *v);
-    void glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
-    void glColor4bv(const GLbyte *v);
-    void glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
-    void glColor3usv(const GLushort *v);
-    void glColor3us(GLushort red, GLushort green, GLushort blue);
-    void glColor3uiv(const GLuint *v);
-    void glColor3ui(GLuint red, GLuint green, GLuint blue);
-    void glColor3ubv(const GLubyte *v);
-    void glColor3ub(GLubyte red, GLubyte green, GLubyte blue);
-    void glColor3sv(const GLshort *v);
-    void glColor3s(GLshort red, GLshort green, GLshort blue);
-    void glColor3iv(const GLint *v);
-    void glColor3i(GLint red, GLint green, GLint blue);
-    void glColor3fv(const GLfloat *v);
-    void glColor3f(GLfloat red, GLfloat green, GLfloat blue);
-    void glColor3dv(const GLdouble *v);
-    void glColor3d(GLdouble red, GLdouble green, GLdouble blue);
-    void glColor3bv(const GLbyte *v);
-    void glColor3b(GLbyte red, GLbyte green, GLbyte blue);
-    void glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap);
-    void glBegin(GLenum mode);
-    void glListBase(GLuint base);
-    GLuint glGenLists(GLsizei range);
-    void glDeleteLists(GLuint list, GLsizei range);
-    void glCallLists(GLsizei n, GLenum type, const GLvoid *lists);
-    void glCallList(GLuint list);
-    void glEndList();
-    void glNewList(GLuint list, GLenum mode);
-
-    // OpenGL 1.1 deprecated functions
-    void glPushClientAttrib(GLbitfield mask);
-    void glPopClientAttrib();
-    void glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities);
-    GLboolean glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences);
-    void glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer);
-    void glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glEnableClientState(GLenum array);
-    void glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer);
-    void glDisableClientState(GLenum array);
-    void glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glArrayElement(GLint i);
-
-    // OpenGL 1.2 deprecated functions
-    void glResetMinmax(GLenum target);
-    void glResetHistogram(GLenum target);
-    void glMinmax(GLenum target, GLenum internalformat, GLboolean sink);
-    void glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink);
-    void glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
-    void glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
-    void glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column);
-    void glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span);
-    void glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image);
-    void glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
-    void glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glConvolutionParameteri(GLenum target, GLenum pname, GLint params);
-    void glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params);
-    void glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image);
-    void glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image);
-    void glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width);
-    void glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data);
-    void glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table);
-    void glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
-    void glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table);
-
-    // OpenGL 1.3 deprecated functions
-    void glMultTransposeMatrixd(const GLdouble *m);
-    void glMultTransposeMatrixf(const GLfloat *m);
-    void glLoadTransposeMatrixd(const GLdouble *m);
-    void glLoadTransposeMatrixf(const GLfloat *m);
-    void glMultiTexCoord4sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);
-    void glMultiTexCoord4iv(GLenum target, const GLint *v);
-    void glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q);
-    void glMultiTexCoord4fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
-    void glMultiTexCoord4dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
-    void glMultiTexCoord3sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r);
-    void glMultiTexCoord3iv(GLenum target, const GLint *v);
-    void glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r);
-    void glMultiTexCoord3fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r);
-    void glMultiTexCoord3dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r);
-    void glMultiTexCoord2sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord2s(GLenum target, GLshort s, GLshort t);
-    void glMultiTexCoord2iv(GLenum target, const GLint *v);
-    void glMultiTexCoord2i(GLenum target, GLint s, GLint t);
-    void glMultiTexCoord2fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t);
-    void glMultiTexCoord2dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t);
-    void glMultiTexCoord1sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord1s(GLenum target, GLshort s);
-    void glMultiTexCoord1iv(GLenum target, const GLint *v);
-    void glMultiTexCoord1i(GLenum target, GLint s);
-    void glMultiTexCoord1fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord1f(GLenum target, GLfloat s);
-    void glMultiTexCoord1dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord1d(GLenum target, GLdouble s);
-    void glClientActiveTexture(GLenum texture);
-
-    // OpenGL 1.4 deprecated functions
-    void glWindowPos3sv(const GLshort *v);
-    void glWindowPos3s(GLshort x, GLshort y, GLshort z);
-    void glWindowPos3iv(const GLint *v);
-    void glWindowPos3i(GLint x, GLint y, GLint z);
-    void glWindowPos3fv(const GLfloat *v);
-    void glWindowPos3f(GLfloat x, GLfloat y, GLfloat z);
-    void glWindowPos3dv(const GLdouble *v);
-    void glWindowPos3d(GLdouble x, GLdouble y, GLdouble z);
-    void glWindowPos2sv(const GLshort *v);
-    void glWindowPos2s(GLshort x, GLshort y);
-    void glWindowPos2iv(const GLint *v);
-    void glWindowPos2i(GLint x, GLint y);
-    void glWindowPos2fv(const GLfloat *v);
-    void glWindowPos2f(GLfloat x, GLfloat y);
-    void glWindowPos2dv(const GLdouble *v);
-    void glWindowPos2d(GLdouble x, GLdouble y);
-    void glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glSecondaryColor3usv(const GLushort *v);
-    void glSecondaryColor3us(GLushort red, GLushort green, GLushort blue);
-    void glSecondaryColor3uiv(const GLuint *v);
-    void glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue);
-    void glSecondaryColor3ubv(const GLubyte *v);
-    void glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue);
-    void glSecondaryColor3sv(const GLshort *v);
-    void glSecondaryColor3s(GLshort red, GLshort green, GLshort blue);
-    void glSecondaryColor3iv(const GLint *v);
-    void glSecondaryColor3i(GLint red, GLint green, GLint blue);
-    void glSecondaryColor3fv(const GLfloat *v);
-    void glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue);
-    void glSecondaryColor3dv(const GLdouble *v);
-    void glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue);
-    void glSecondaryColor3bv(const GLbyte *v);
-    void glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue);
-    void glFogCoordPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glFogCoorddv(const GLdouble *coord);
-    void glFogCoordd(GLdouble coord);
-    void glFogCoordfv(const GLfloat *coord);
-    void glFogCoordf(GLfloat coord);
-
-    // OpenGL 1.5 deprecated functions
-
-    // OpenGL 2.0 deprecated functions
-    void glVertexAttrib4usv(GLuint index, const GLushort *v);
-    void glVertexAttrib4uiv(GLuint index, const GLuint *v);
-    void glVertexAttrib4ubv(GLuint index, const GLubyte *v);
-    void glVertexAttrib4sv(GLuint index, const GLshort *v);
-    void glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
-    void glVertexAttrib4iv(GLuint index, const GLint *v);
-    void glVertexAttrib4fv(GLuint index, const GLfloat *v);
-    void glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void glVertexAttrib4dv(GLuint index, const GLdouble *v);
-    void glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glVertexAttrib4bv(GLuint index, const GLbyte *v);
-    void glVertexAttrib4Nusv(GLuint index, const GLushort *v);
-    void glVertexAttrib4Nuiv(GLuint index, const GLuint *v);
-    void glVertexAttrib4Nubv(GLuint index, const GLubyte *v);
-    void glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
-    void glVertexAttrib4Nsv(GLuint index, const GLshort *v);
-    void glVertexAttrib4Niv(GLuint index, const GLint *v);
-    void glVertexAttrib4Nbv(GLuint index, const GLbyte *v);
-    void glVertexAttrib3sv(GLuint index, const GLshort *v);
-    void glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z);
-    void glVertexAttrib3fv(GLuint index, const GLfloat *v);
-    void glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z);
-    void glVertexAttrib3dv(GLuint index, const GLdouble *v);
-    void glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z);
-    void glVertexAttrib2sv(GLuint index, const GLshort *v);
-    void glVertexAttrib2s(GLuint index, GLshort x, GLshort y);
-    void glVertexAttrib2fv(GLuint index, const GLfloat *v);
-    void glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y);
-    void glVertexAttrib2dv(GLuint index, const GLdouble *v);
-    void glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y);
-    void glVertexAttrib1sv(GLuint index, const GLshort *v);
-    void glVertexAttrib1s(GLuint index, GLshort x);
-    void glVertexAttrib1fv(GLuint index, const GLfloat *v);
-    void glVertexAttrib1f(GLuint index, GLfloat x);
-    void glVertexAttrib1dv(GLuint index, const GLdouble *v);
-    void glVertexAttrib1d(GLuint index, GLdouble x);
-
-    // OpenGL 2.1 deprecated functions
-
-    // OpenGL 3.0 deprecated functions
-    void glVertexAttribI4usv(GLuint index, const GLushort *v);
-    void glVertexAttribI4ubv(GLuint index, const GLubyte *v);
-    void glVertexAttribI4sv(GLuint index, const GLshort *v);
-    void glVertexAttribI4bv(GLuint index, const GLbyte *v);
-    void glVertexAttribI4uiv(GLuint index, const GLuint *v);
-    void glVertexAttribI3uiv(GLuint index, const GLuint *v);
-    void glVertexAttribI2uiv(GLuint index, const GLuint *v);
-    void glVertexAttribI1uiv(GLuint index, const GLuint *v);
-    void glVertexAttribI4iv(GLuint index, const GLint *v);
-    void glVertexAttribI3iv(GLuint index, const GLint *v);
-    void glVertexAttribI2iv(GLuint index, const GLint *v);
-    void glVertexAttribI1iv(GLuint index, const GLint *v);
-    void glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
-    void glVertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z);
-    void glVertexAttribI2ui(GLuint index, GLuint x, GLuint y);
-    void glVertexAttribI1ui(GLuint index, GLuint x);
-    void glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w);
-    void glVertexAttribI3i(GLuint index, GLint x, GLint y, GLint z);
-    void glVertexAttribI2i(GLuint index, GLint x, GLint y);
-    void glVertexAttribI1i(GLuint index, GLint x);
-
-    // OpenGL 3.1 deprecated functions
-
-    // OpenGL 3.2 deprecated functions
-
-    // OpenGL 3.3 deprecated functions
-
-    // OpenGL 4.0 deprecated functions
-
-    // OpenGL 4.1 deprecated functions
-
-    // OpenGL 4.2 deprecated functions
-
-    // OpenGL 4.3 deprecated functions
-
-private:
-    friend class QOpenGLContext;
-
-    static bool isContextCompatible(QOpenGLContext *context);
-    static QOpenGLVersionProfile versionProfile();
-
-    QOpenGLFunctions_1_0_CoreBackend* d_1_0_Core;
-    QOpenGLFunctions_1_1_CoreBackend* d_1_1_Core;
-    QOpenGLFunctions_1_2_CoreBackend* d_1_2_Core;
-    QOpenGLFunctions_1_3_CoreBackend* d_1_3_Core;
-    QOpenGLFunctions_1_4_CoreBackend* d_1_4_Core;
-    QOpenGLFunctions_1_5_CoreBackend* d_1_5_Core;
-    QOpenGLFunctions_2_0_CoreBackend* d_2_0_Core;
-    QOpenGLFunctions_2_1_CoreBackend* d_2_1_Core;
-    QOpenGLFunctions_3_0_CoreBackend* d_3_0_Core;
-    QOpenGLFunctions_3_1_CoreBackend* d_3_1_Core;
-    QOpenGLFunctions_3_2_CoreBackend* d_3_2_Core;
-    QOpenGLFunctions_3_3_CoreBackend* d_3_3_Core;
-    QOpenGLFunctions_4_0_CoreBackend* d_4_0_Core;
-    QOpenGLFunctions_4_1_CoreBackend* d_4_1_Core;
-    QOpenGLFunctions_4_2_CoreBackend* d_4_2_Core;
-    QOpenGLFunctions_4_3_CoreBackend* d_4_3_Core;
-    QOpenGLFunctions_1_0_DeprecatedBackend* d_1_0_Deprecated;
-    QOpenGLFunctions_1_1_DeprecatedBackend* d_1_1_Deprecated;
-    QOpenGLFunctions_1_2_DeprecatedBackend* d_1_2_Deprecated;
-    QOpenGLFunctions_1_3_DeprecatedBackend* d_1_3_Deprecated;
-    QOpenGLFunctions_1_4_DeprecatedBackend* d_1_4_Deprecated;
-    void *m_reserved_2_0_Deprecated; // To maintain BC
-    QOpenGLFunctions_3_3_DeprecatedBackend* d_3_3_Deprecated;
-};
-
-// OpenGL 1.0 core functions
-inline void QOpenGLFunctions_4_3_Compatibility::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_0_Core->f.Viewport(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glDepthRange(GLdouble nearVal, GLdouble farVal)
-{
-    d_1_0_Core->f.DepthRange(nearVal, farVal);
-}
-
-inline GLboolean QOpenGLFunctions_4_3_Compatibility::glIsEnabled(GLenum cap)
-{
-    return d_1_0_Core->f.IsEnabled(cap);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetTexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetTexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
-{
-    d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
-}
-
-inline const GLubyte * QOpenGLFunctions_4_3_Compatibility::glGetString(GLenum name)
-{
-    return d_1_0_Core->f.GetString(name);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetIntegerv(GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetIntegerv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetFloatv(GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetFloatv(pname, params);
-}
-
-inline GLenum QOpenGLFunctions_4_3_Compatibility::glGetError()
-{
-    return d_1_0_Core->f.GetError();
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetDoublev(GLenum pname, GLdouble *params)
-{
-    d_1_0_Core->f.GetDoublev(pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetBooleanv(GLenum pname, GLboolean *params)
-{
-    d_1_0_Core->f.GetBooleanv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
-{
-    d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glReadBuffer(GLenum mode)
-{
-    d_1_0_Core->f.ReadBuffer(mode);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glPixelStorei(GLenum pname, GLint param)
-{
-    d_1_0_Core->f.PixelStorei(pname, param);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glPixelStoref(GLenum pname, GLfloat param)
-{
-    d_1_0_Core->f.PixelStoref(pname, param);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glDepthFunc(GLenum func)
-{
-    d_1_0_Core->f.DepthFunc(func);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
-{
-    d_1_0_Core->f.StencilOp(fail, zfail, zpass);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glStencilFunc(GLenum func, GLint ref, GLuint mask)
-{
-    d_1_0_Core->f.StencilFunc(func, ref, mask);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glLogicOp(GLenum opcode)
-{
-    d_1_0_Core->f.LogicOp(opcode);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glBlendFunc(GLenum sfactor, GLenum dfactor)
-{
-    d_1_0_Core->f.BlendFunc(sfactor, dfactor);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glFlush()
-{
-    d_1_0_Core->f.Flush();
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glFinish()
-{
-    d_1_0_Core->f.Finish();
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glEnable(GLenum cap)
-{
-    d_1_0_Core->f.Enable(cap);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glDisable(GLenum cap)
-{
-    d_1_0_Core->f.Disable(cap);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glDepthMask(GLboolean flag)
-{
-    d_1_0_Core->f.DepthMask(flag);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
-{
-    d_1_0_Core->f.ColorMask(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glStencilMask(GLuint mask)
-{
-    d_1_0_Core->f.StencilMask(mask);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glClearDepth(GLdouble depth)
-{
-    d_1_0_Core->f.ClearDepth(depth);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glClearStencil(GLint s)
-{
-    d_1_0_Core->f.ClearStencil(s);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Core->f.ClearColor(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glClear(GLbitfield mask)
-{
-    d_1_0_Core->f.Clear(mask);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glDrawBuffer(GLenum mode)
-{
-    d_1_0_Core->f.DrawBuffer(mode);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Core->f.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Core->f.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_0_Core->f.TexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexParameteri(GLenum target, GLenum pname, GLint param)
-{
-    d_1_0_Core->f.TexParameteri(target, pname, param);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Core->f.TexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
-{
-    d_1_0_Core->f.TexParameterf(target, pname, param);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_0_Core->f.Scissor(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glPolygonMode(GLenum face, GLenum mode)
-{
-    d_1_0_Core->f.PolygonMode(face, mode);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glPointSize(GLfloat size)
-{
-    d_1_0_Core->f.PointSize(size);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glLineWidth(GLfloat width)
-{
-    d_1_0_Core->f.LineWidth(width);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glHint(GLenum target, GLenum mode)
-{
-    d_1_0_Core->f.Hint(target, mode);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glFrontFace(GLenum mode)
-{
-    d_1_0_Core->f.FrontFace(mode);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glCullFace(GLenum mode)
-{
-    d_1_0_Core->f.CullFace(mode);
-}
-
-
-// OpenGL 1.1 core functions
-inline void QOpenGLFunctions_4_3_Compatibility::glIndexubv(const GLubyte *c)
-{
-    d_1_1_Deprecated->f.Indexubv(c);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glIndexub(GLubyte c)
-{
-    d_1_1_Deprecated->f.Indexub(c);
-}
-
-inline GLboolean QOpenGLFunctions_4_3_Compatibility::glIsTexture(GLuint texture)
-{
-    return d_1_1_Core->f.IsTexture(texture);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGenTextures(GLsizei n, GLuint *textures)
-{
-    d_1_1_Core->f.GenTextures(n, textures);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glDeleteTextures(GLsizei n, const GLuint *textures)
-{
-    d_1_1_Core->f.DeleteTextures(n, textures);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glBindTexture(GLenum target, GLuint texture)
-{
-    d_1_1_Core->f.BindTexture(target, texture);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_1_Core->f.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_1_Core->f.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_1_Core->f.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
-{
-    d_1_1_Core->f.CopyTexSubImage1D(target, level, xoffset, x, y, width);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
-{
-    d_1_1_Core->f.CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
-{
-    d_1_1_Core->f.CopyTexImage1D(target, level, internalformat, x, y, width, border);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glPolygonOffset(GLfloat factor, GLfloat units)
-{
-    d_1_1_Core->f.PolygonOffset(factor, units);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetPointerv(GLenum pname, GLvoid* *params)
-{
-    d_1_1_Deprecated->f.GetPointerv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
-{
-    d_1_1_Core->f.DrawElements(mode, count, type, indices);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glDrawArrays(GLenum mode, GLint first, GLsizei count)
-{
-    d_1_1_Core->f.DrawArrays(mode, first, count);
-}
-
-
-// OpenGL 1.2 core functions
-inline void QOpenGLFunctions_4_3_Compatibility::glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_2_Core->f.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_2_Core->f.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_2_Core->f.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
-{
-    d_1_2_Core->f.DrawRangeElements(mode, start, end, count, type, indices);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glBlendEquation(GLenum mode)
-{
-    d_1_2_Core->f.BlendEquation(mode);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_2_Core->f.BlendColor(red, green, blue, alpha);
-}
-
-
-// OpenGL 1.3 core functions
-inline void QOpenGLFunctions_4_3_Compatibility::glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img)
-{
-    d_1_3_Core->f.GetCompressedTexImage(target, level, img);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glSampleCoverage(GLfloat value, GLboolean invert)
-{
-    d_1_3_Core->f.SampleCoverage(value, invert);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glActiveTexture(GLenum texture)
-{
-    d_1_3_Core->f.ActiveTexture(texture);
-}
-
-
-// OpenGL 1.4 core functions
-inline void QOpenGLFunctions_4_3_Compatibility::glPointParameteriv(GLenum pname, const GLint *params)
-{
-    d_1_4_Core->f.PointParameteriv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glPointParameteri(GLenum pname, GLint param)
-{
-    d_1_4_Core->f.PointParameteri(pname, param);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glPointParameterfv(GLenum pname, const GLfloat *params)
-{
-    d_1_4_Core->f.PointParameterfv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glPointParameterf(GLenum pname, GLfloat param)
-{
-    d_1_4_Core->f.PointParameterf(pname, param);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount)
-{
-    d_1_4_Core->f.MultiDrawElements(mode, count, type, indices, drawcount);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
-{
-    d_1_4_Core->f.MultiDrawArrays(mode, first, count, drawcount);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
-{
-    d_1_4_Core->f.BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
-}
-
-
-// OpenGL 1.5 core functions
-inline void QOpenGLFunctions_4_3_Compatibility::glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params)
-{
-    d_1_5_Core->f.GetBufferPointerv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetBufferParameteriv(target, pname, params);
-}
-
-inline GLboolean QOpenGLFunctions_4_3_Compatibility::glUnmapBuffer(GLenum target)
-{
-    return d_1_5_Core->f.UnmapBuffer(target);
-}
-
-inline GLvoid* QOpenGLFunctions_4_3_Compatibility::glMapBuffer(GLenum target, GLenum access)
-{
-    return d_1_5_Core->f.MapBuffer(target, access);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data)
-{
-    d_1_5_Core->f.GetBufferSubData(target, offset, size, data);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data)
-{
-    d_1_5_Core->f.BufferSubData(target, offset, size, data);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)
-{
-    d_1_5_Core->f.BufferData(target, size, data, usage);
-}
-
-inline GLboolean QOpenGLFunctions_4_3_Compatibility::glIsBuffer(GLuint buffer)
-{
-    return d_1_5_Core->f.IsBuffer(buffer);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGenBuffers(GLsizei n, GLuint *buffers)
-{
-    d_1_5_Core->f.GenBuffers(n, buffers);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glDeleteBuffers(GLsizei n, const GLuint *buffers)
-{
-    d_1_5_Core->f.DeleteBuffers(n, buffers);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glBindBuffer(GLenum target, GLuint buffer)
-{
-    d_1_5_Core->f.BindBuffer(target, buffer);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
-{
-    d_1_5_Core->f.GetQueryObjectuiv(id, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetQueryObjectiv(id, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetQueryiv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetQueryiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glEndQuery(GLenum target)
-{
-    d_1_5_Core->f.EndQuery(target);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glBeginQuery(GLenum target, GLuint id)
-{
-    d_1_5_Core->f.BeginQuery(target, id);
-}
-
-inline GLboolean QOpenGLFunctions_4_3_Compatibility::glIsQuery(GLuint id)
-{
-    return d_1_5_Core->f.IsQuery(id);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glDeleteQueries(GLsizei n, const GLuint *ids)
-{
-    d_1_5_Core->f.DeleteQueries(n, ids);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGenQueries(GLsizei n, GLuint *ids)
-{
-    d_1_5_Core->f.GenQueries(n, ids);
-}
-
-
-// OpenGL 2.0 core functions
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer)
-{
-    d_2_0_Core->f.VertexAttribPointer(index, size, type, normalized, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glValidateProgram(GLuint program)
-{
-    d_2_0_Core->f.ValidateProgram(program);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix3fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUniform4iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform4iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUniform3iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform3iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUniform2iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform2iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUniform1iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform1iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUniform4fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform4fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUniform3fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform3fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUniform2fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform2fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUniform1fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform1fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
-{
-    d_2_0_Core->f.Uniform4i(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUniform3i(GLint location, GLint v0, GLint v1, GLint v2)
-{
-    d_2_0_Core->f.Uniform3i(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUniform2i(GLint location, GLint v0, GLint v1)
-{
-    d_2_0_Core->f.Uniform2i(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUniform1i(GLint location, GLint v0)
-{
-    d_2_0_Core->f.Uniform1i(location, v0);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
-{
-    d_2_0_Core->f.Uniform4f(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
-{
-    d_2_0_Core->f.Uniform3f(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUniform2f(GLint location, GLfloat v0, GLfloat v1)
-{
-    d_2_0_Core->f.Uniform2f(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUniform1f(GLint location, GLfloat v0)
-{
-    d_2_0_Core->f.Uniform1f(location, v0);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUseProgram(GLuint program)
-{
-    d_2_0_Core->f.UseProgram(program);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length)
-{
-    d_2_0_Core->f.ShaderSource(shader, count, string, length);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glLinkProgram(GLuint program)
-{
-    d_2_0_Core->f.LinkProgram(program);
-}
-
-inline GLboolean QOpenGLFunctions_4_3_Compatibility::glIsShader(GLuint shader)
-{
-    return d_2_0_Core->f.IsShader(shader);
-}
-
-inline GLboolean QOpenGLFunctions_4_3_Compatibility::glIsProgram(GLuint program)
-{
-    return d_2_0_Core->f.IsProgram(program);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer)
-{
-    d_2_0_Core->f.GetVertexAttribPointerv(index, pname, pointer);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetVertexAttribiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
-{
-    d_2_0_Core->f.GetVertexAttribfv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
-{
-    d_2_0_Core->f.GetVertexAttribdv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetUniformiv(GLuint program, GLint location, GLint *params)
-{
-    d_2_0_Core->f.GetUniformiv(program, location, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetUniformfv(GLuint program, GLint location, GLfloat *params)
-{
-    d_2_0_Core->f.GetUniformfv(program, location, params);
-}
-
-inline GLint QOpenGLFunctions_4_3_Compatibility::glGetUniformLocation(GLuint program, const GLchar *name)
-{
-    return d_2_0_Core->f.GetUniformLocation(program, name);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
-{
-    d_2_0_Core->f.GetShaderSource(shader, bufSize, length, source);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-{
-    d_2_0_Core->f.GetShaderInfoLog(shader, bufSize, length, infoLog);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetShaderiv(GLuint shader, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetShaderiv(shader, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-{
-    d_2_0_Core->f.GetProgramInfoLog(program, bufSize, length, infoLog);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetProgramiv(GLuint program, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetProgramiv(program, pname, params);
-}
-
-inline GLint QOpenGLFunctions_4_3_Compatibility::glGetAttribLocation(GLuint program, const GLchar *name)
-{
-    return d_2_0_Core->f.GetAttribLocation(program, name);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj)
-{
-    d_2_0_Core->f.GetAttachedShaders(program, maxCount, count, obj);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
-{
-    d_2_0_Core->f.GetActiveUniform(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
-{
-    d_2_0_Core->f.GetActiveAttrib(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glEnableVertexAttribArray(GLuint index)
-{
-    d_2_0_Core->f.EnableVertexAttribArray(index);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glDisableVertexAttribArray(GLuint index)
-{
-    d_2_0_Core->f.DisableVertexAttribArray(index);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glDetachShader(GLuint program, GLuint shader)
-{
-    d_2_0_Core->f.DetachShader(program, shader);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glDeleteShader(GLuint shader)
-{
-    d_2_0_Core->f.DeleteShader(shader);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glDeleteProgram(GLuint program)
-{
-    d_2_0_Core->f.DeleteProgram(program);
-}
-
-inline GLuint QOpenGLFunctions_4_3_Compatibility::glCreateShader(GLenum type)
-{
-    return d_2_0_Core->f.CreateShader(type);
-}
-
-inline GLuint QOpenGLFunctions_4_3_Compatibility::glCreateProgram()
-{
-    return d_2_0_Core->f.CreateProgram();
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glCompileShader(GLuint shader)
-{
-    d_2_0_Core->f.CompileShader(shader);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glBindAttribLocation(GLuint program, GLuint index, const GLchar *name)
-{
-    d_2_0_Core->f.BindAttribLocation(program, index, name);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glAttachShader(GLuint program, GLuint shader)
-{
-    d_2_0_Core->f.AttachShader(program, shader);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glStencilMaskSeparate(GLenum face, GLuint mask)
-{
-    d_2_0_Core->f.StencilMaskSeparate(face, mask);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
-{
-    d_2_0_Core->f.StencilFuncSeparate(face, func, ref, mask);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
-{
-    d_2_0_Core->f.StencilOpSeparate(face, sfail, dpfail, dppass);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glDrawBuffers(GLsizei n, const GLenum *bufs)
-{
-    d_2_0_Core->f.DrawBuffers(n, bufs);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
-{
-    d_2_0_Core->f.BlendEquationSeparate(modeRGB, modeAlpha);
-}
-
-
-// OpenGL 2.1 core functions
-inline void QOpenGLFunctions_4_3_Compatibility::glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix4x3fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix3x4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix4x2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix2x4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix3x2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix2x3fv(location, count, transpose, value);
-}
-
-
-// OpenGL 3.0 core functions
-inline GLboolean QOpenGLFunctions_4_3_Compatibility::glIsVertexArray(GLuint array)
-{
-    return d_3_0_Core->f.IsVertexArray(array);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGenVertexArrays(GLsizei n, GLuint *arrays)
-{
-    d_3_0_Core->f.GenVertexArrays(n, arrays);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glDeleteVertexArrays(GLsizei n, const GLuint *arrays)
-{
-    d_3_0_Core->f.DeleteVertexArrays(n, arrays);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glBindVertexArray(GLuint array)
-{
-    d_3_0_Core->f.BindVertexArray(array);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
-{
-    d_3_0_Core->f.FlushMappedBufferRange(target, offset, length);
-}
-
-inline GLvoid* QOpenGLFunctions_4_3_Compatibility::glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
-{
-    return d_3_0_Core->f.MapBufferRange(target, offset, length, access);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
-{
-    d_3_0_Core->f.FramebufferTextureLayer(target, attachment, texture, level, layer);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    d_3_0_Core->f.RenderbufferStorageMultisample(target, samples, internalformat, width, height);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
-{
-    d_3_0_Core->f.BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGenerateMipmap(GLenum target)
-{
-    d_3_0_Core->f.GenerateMipmap(target);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
-{
-    d_3_0_Core->f.FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
-{
-    d_3_0_Core->f.FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
-{
-    d_3_0_Core->f.FramebufferTexture2D(target, attachment, textarget, texture, level);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
-{
-    d_3_0_Core->f.FramebufferTexture1D(target, attachment, textarget, texture, level);
-}
-
-inline GLenum QOpenGLFunctions_4_3_Compatibility::glCheckFramebufferStatus(GLenum target)
-{
-    return d_3_0_Core->f.CheckFramebufferStatus(target);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGenFramebuffers(GLsizei n, GLuint *framebuffers)
-{
-    d_3_0_Core->f.GenFramebuffers(n, framebuffers);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
-{
-    d_3_0_Core->f.DeleteFramebuffers(n, framebuffers);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glBindFramebuffer(GLenum target, GLuint framebuffer)
-{
-    d_3_0_Core->f.BindFramebuffer(target, framebuffer);
-}
-
-inline GLboolean QOpenGLFunctions_4_3_Compatibility::glIsFramebuffer(GLuint framebuffer)
-{
-    return d_3_0_Core->f.IsFramebuffer(framebuffer);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetRenderbufferParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    d_3_0_Core->f.RenderbufferStorage(target, internalformat, width, height);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGenRenderbuffers(GLsizei n, GLuint *renderbuffers)
-{
-    d_3_0_Core->f.GenRenderbuffers(n, renderbuffers);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
-{
-    d_3_0_Core->f.DeleteRenderbuffers(n, renderbuffers);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glBindRenderbuffer(GLenum target, GLuint renderbuffer)
-{
-    d_3_0_Core->f.BindRenderbuffer(target, renderbuffer);
-}
-
-inline GLboolean QOpenGLFunctions_4_3_Compatibility::glIsRenderbuffer(GLuint renderbuffer)
-{
-    return d_3_0_Core->f.IsRenderbuffer(renderbuffer);
-}
-
-inline const GLubyte * QOpenGLFunctions_4_3_Compatibility::glGetStringi(GLenum name, GLuint index)
-{
-    return d_3_0_Core->f.GetStringi(name, index);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
-{
-    d_3_0_Core->f.ClearBufferfi(buffer, drawbuffer, depth, stencil);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
-{
-    d_3_0_Core->f.ClearBufferfv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
-{
-    d_3_0_Core->f.ClearBufferuiv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
-{
-    d_3_0_Core->f.ClearBufferiv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params)
-{
-    d_3_0_Core->f.GetTexParameterIuiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetTexParameterIiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params)
-{
-    d_3_0_Core->f.TexParameterIuiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexParameterIiv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_3_0_Core->f.TexParameterIiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUniform4uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform4uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUniform3uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform3uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUniform2uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform2uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUniform1uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform1uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
-{
-    d_3_0_Core->f.Uniform4ui(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
-{
-    d_3_0_Core->f.Uniform3ui(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUniform2ui(GLint location, GLuint v0, GLuint v1)
-{
-    d_3_0_Core->f.Uniform2ui(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUniform1ui(GLint location, GLuint v0)
-{
-    d_3_0_Core->f.Uniform1ui(location, v0);
-}
-
-inline GLint QOpenGLFunctions_4_3_Compatibility::glGetFragDataLocation(GLuint program, const GLchar *name)
-{
-    return d_3_0_Core->f.GetFragDataLocation(program, name);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name)
-{
-    d_3_0_Core->f.BindFragDataLocation(program, color, name);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetUniformuiv(GLuint program, GLint location, GLuint *params)
-{
-    d_3_0_Core->f.GetUniformuiv(program, location, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
-{
-    d_3_0_Core->f.GetVertexAttribIuiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetVertexAttribIiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_3_0_Core->f.VertexAttribIPointer(index, size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glEndConditionalRender()
-{
-    d_3_0_Core->f.EndConditionalRender();
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glBeginConditionalRender(GLuint id, GLenum mode)
-{
-    d_3_0_Core->f.BeginConditionalRender(id, mode);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glClampColor(GLenum target, GLenum clamp)
-{
-    d_3_0_Core->f.ClampColor(target, clamp);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
-{
-    d_3_0_Core->f.GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode)
-{
-    d_3_0_Core->f.TransformFeedbackVaryings(program, count, varyings, bufferMode);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
-{
-    d_3_0_Core->f.BindBufferBase(target, index, buffer);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
-{
-    d_3_0_Core->f.BindBufferRange(target, index, buffer, offset, size);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glEndTransformFeedback()
-{
-    d_3_0_Core->f.EndTransformFeedback();
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glBeginTransformFeedback(GLenum primitiveMode)
-{
-    d_3_0_Core->f.BeginTransformFeedback(primitiveMode);
-}
-
-inline GLboolean QOpenGLFunctions_4_3_Compatibility::glIsEnabledi(GLenum target, GLuint index)
-{
-    return d_3_0_Core->f.IsEnabledi(target, index);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glDisablei(GLenum target, GLuint index)
-{
-    d_3_0_Core->f.Disablei(target, index);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glEnablei(GLenum target, GLuint index)
-{
-    d_3_0_Core->f.Enablei(target, index);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetIntegeri_v(GLenum target, GLuint index, GLint *data)
-{
-    d_3_0_Core->f.GetIntegeri_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetBooleani_v(GLenum target, GLuint index, GLboolean *data)
-{
-    d_3_0_Core->f.GetBooleani_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
-{
-    d_3_0_Core->f.ColorMaski(index, r, g, b, a);
-}
-
-
-// OpenGL 3.1 core functions
-inline void QOpenGLFunctions_4_3_Compatibility::glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
-{
-    d_3_1_Core->f.CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
-{
-    d_3_1_Core->f.UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
-{
-    d_3_1_Core->f.GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params)
-{
-    d_3_1_Core->f.GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
-}
-
-inline GLuint QOpenGLFunctions_4_3_Compatibility::glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName)
-{
-    return d_3_1_Core->f.GetUniformBlockIndex(program, uniformBlockName);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName)
-{
-    d_3_1_Core->f.GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params)
-{
-    d_3_1_Core->f.GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const *uniformNames, GLuint *uniformIndices)
-{
-    d_3_1_Core->f.GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glPrimitiveRestartIndex(GLuint index)
-{
-    d_3_1_Core->f.PrimitiveRestartIndex(index);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer)
-{
-    d_3_1_Core->f.TexBuffer(target, internalformat, buffer);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount)
-{
-    d_3_1_Core->f.DrawElementsInstanced(mode, count, type, indices, instancecount);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount)
-{
-    d_3_1_Core->f.DrawArraysInstanced(mode, first, count, instancecount);
-}
-
-
-// OpenGL 3.2 core functions
-inline void QOpenGLFunctions_4_3_Compatibility::glSampleMaski(GLuint index, GLbitfield mask)
-{
-    d_3_2_Core->f.SampleMaski(index, mask);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val)
-{
-    d_3_2_Core->f.GetMultisamplefv(pname, index, val);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexImage3DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
-{
-    d_3_2_Core->f.TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexImage2DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
-{
-    d_3_2_Core->f.TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values)
-{
-    d_3_2_Core->f.GetSynciv(sync, pname, bufSize, length, values);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetInteger64v(GLenum pname, GLint64 *params)
-{
-    d_3_2_Core->f.GetInteger64v(pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
-{
-    d_3_2_Core->f.WaitSync(sync, flags, timeout);
-}
-
-inline GLenum QOpenGLFunctions_4_3_Compatibility::glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
-{
-    return d_3_2_Core->f.ClientWaitSync(sync, flags, timeout);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glDeleteSync(GLsync sync)
-{
-    d_3_2_Core->f.DeleteSync(sync);
-}
-
-inline GLboolean QOpenGLFunctions_4_3_Compatibility::glIsSync(GLsync sync)
-{
-    return d_3_2_Core->f.IsSync(sync);
-}
-
-inline GLsync QOpenGLFunctions_4_3_Compatibility::glFenceSync(GLenum condition, GLbitfield flags)
-{
-    return d_3_2_Core->f.FenceSync(condition, flags);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProvokingVertex(GLenum mode)
-{
-    d_3_2_Core->f.ProvokingVertex(mode);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount, const GLint *basevertex)
-{
-    d_3_2_Core->f.MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount, GLint basevertex)
-{
-    d_3_2_Core->f.DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)
-{
-    d_3_2_Core->f.DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)
-{
-    d_3_2_Core->f.DrawElementsBaseVertex(mode, count, type, indices, basevertex);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level)
-{
-    d_3_2_Core->f.FramebufferTexture(target, attachment, texture, level);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params)
-{
-    d_3_2_Core->f.GetBufferParameteri64v(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data)
-{
-    d_3_2_Core->f.GetInteger64i_v(target, index, data);
-}
-
-
-// OpenGL 3.3 core functions
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribP4uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP4uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP4ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribP3uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP3uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP3ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribP2uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP2uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP2ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribP1uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP1uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP1ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glSecondaryColorP3uiv(GLenum type, const GLuint *color)
-{
-    d_3_3_Deprecated->f.SecondaryColorP3uiv(type, color);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glSecondaryColorP3ui(GLenum type, GLuint color)
-{
-    d_3_3_Deprecated->f.SecondaryColorP3ui(type, color);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glColorP4uiv(GLenum type, const GLuint *color)
-{
-    d_3_3_Deprecated->f.ColorP4uiv(type, color);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glColorP4ui(GLenum type, GLuint color)
-{
-    d_3_3_Deprecated->f.ColorP4ui(type, color);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glColorP3uiv(GLenum type, const GLuint *color)
-{
-    d_3_3_Deprecated->f.ColorP3uiv(type, color);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glColorP3ui(GLenum type, GLuint color)
-{
-    d_3_3_Deprecated->f.ColorP3ui(type, color);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glNormalP3uiv(GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.NormalP3uiv(type, coords);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glNormalP3ui(GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.NormalP3ui(type, coords);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP4uiv(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP4ui(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP3uiv(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP3ui(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP2uiv(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP2ui(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP1uiv(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP1ui(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexCoordP4uiv(GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.TexCoordP4uiv(type, coords);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexCoordP4ui(GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.TexCoordP4ui(type, coords);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexCoordP3uiv(GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.TexCoordP3uiv(type, coords);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexCoordP3ui(GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.TexCoordP3ui(type, coords);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexCoordP2uiv(GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.TexCoordP2uiv(type, coords);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexCoordP2ui(GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.TexCoordP2ui(type, coords);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexCoordP1uiv(GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.TexCoordP1uiv(type, coords);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexCoordP1ui(GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.TexCoordP1ui(type, coords);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexP4uiv(GLenum type, const GLuint *value)
-{
-    d_3_3_Deprecated->f.VertexP4uiv(type, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexP4ui(GLenum type, GLuint value)
-{
-    d_3_3_Deprecated->f.VertexP4ui(type, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexP3uiv(GLenum type, const GLuint *value)
-{
-    d_3_3_Deprecated->f.VertexP3uiv(type, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexP3ui(GLenum type, GLuint value)
-{
-    d_3_3_Deprecated->f.VertexP3ui(type, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexP2uiv(GLenum type, const GLuint *value)
-{
-    d_3_3_Deprecated->f.VertexP2uiv(type, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexP2ui(GLenum type, GLuint value)
-{
-    d_3_3_Deprecated->f.VertexP2ui(type, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params)
-{
-    d_3_3_Core->f.GetQueryObjectui64v(id, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params)
-{
-    d_3_3_Core->f.GetQueryObjecti64v(id, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glQueryCounter(GLuint id, GLenum target)
-{
-    d_3_3_Core->f.QueryCounter(id, target);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params)
-{
-    d_3_3_Core->f.GetSamplerParameterIuiv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params)
-{
-    d_3_3_Core->f.GetSamplerParameterfv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params)
-{
-    d_3_3_Core->f.GetSamplerParameterIiv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params)
-{
-    d_3_3_Core->f.GetSamplerParameteriv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param)
-{
-    d_3_3_Core->f.SamplerParameterIuiv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param)
-{
-    d_3_3_Core->f.SamplerParameterIiv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param)
-{
-    d_3_3_Core->f.SamplerParameterfv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
-{
-    d_3_3_Core->f.SamplerParameterf(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param)
-{
-    d_3_3_Core->f.SamplerParameteriv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glSamplerParameteri(GLuint sampler, GLenum pname, GLint param)
-{
-    d_3_3_Core->f.SamplerParameteri(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glBindSampler(GLuint unit, GLuint sampler)
-{
-    d_3_3_Core->f.BindSampler(unit, sampler);
-}
-
-inline GLboolean QOpenGLFunctions_4_3_Compatibility::glIsSampler(GLuint sampler)
-{
-    return d_3_3_Core->f.IsSampler(sampler);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glDeleteSamplers(GLsizei count, const GLuint *samplers)
-{
-    d_3_3_Core->f.DeleteSamplers(count, samplers);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGenSamplers(GLsizei count, GLuint *samplers)
-{
-    d_3_3_Core->f.GenSamplers(count, samplers);
-}
-
-inline GLint QOpenGLFunctions_4_3_Compatibility::glGetFragDataIndex(GLuint program, const GLchar *name)
-{
-    return d_3_3_Core->f.GetFragDataIndex(program, name);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glBindFragDataLocationIndexed(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name)
-{
-    d_3_3_Core->f.BindFragDataLocationIndexed(program, colorNumber, index, name);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribDivisor(GLuint index, GLuint divisor)
-{
-    d_3_3_Core->f.VertexAttribDivisor(index, divisor);
-}
-
-
-// OpenGL 4.0 core functions
-inline void QOpenGLFunctions_4_3_Compatibility::glGetQueryIndexediv(GLenum target, GLuint index, GLenum pname, GLint *params)
-{
-    d_4_0_Core->f.GetQueryIndexediv(target, index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glEndQueryIndexed(GLenum target, GLuint index)
-{
-    d_4_0_Core->f.EndQueryIndexed(target, index);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glBeginQueryIndexed(GLenum target, GLuint index, GLuint id)
-{
-    d_4_0_Core->f.BeginQueryIndexed(target, index, id);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glDrawTransformFeedbackStream(GLenum mode, GLuint id, GLuint stream)
-{
-    d_4_0_Core->f.DrawTransformFeedbackStream(mode, id, stream);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glDrawTransformFeedback(GLenum mode, GLuint id)
-{
-    d_4_0_Core->f.DrawTransformFeedback(mode, id);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glResumeTransformFeedback()
-{
-    d_4_0_Core->f.ResumeTransformFeedback();
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glPauseTransformFeedback()
-{
-    d_4_0_Core->f.PauseTransformFeedback();
-}
-
-inline GLboolean QOpenGLFunctions_4_3_Compatibility::glIsTransformFeedback(GLuint id)
-{
-    return d_4_0_Core->f.IsTransformFeedback(id);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGenTransformFeedbacks(GLsizei n, GLuint *ids)
-{
-    d_4_0_Core->f.GenTransformFeedbacks(n, ids);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids)
-{
-    d_4_0_Core->f.DeleteTransformFeedbacks(n, ids);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glBindTransformFeedback(GLenum target, GLuint id)
-{
-    d_4_0_Core->f.BindTransformFeedback(target, id);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glPatchParameterfv(GLenum pname, const GLfloat *values)
-{
-    d_4_0_Core->f.PatchParameterfv(pname, values);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glPatchParameteri(GLenum pname, GLint value)
-{
-    d_4_0_Core->f.PatchParameteri(pname, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetProgramStageiv(GLuint program, GLenum shadertype, GLenum pname, GLint *values)
-{
-    d_4_0_Core->f.GetProgramStageiv(program, shadertype, pname, values);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetUniformSubroutineuiv(GLenum shadertype, GLint location, GLuint *params)
-{
-    d_4_0_Core->f.GetUniformSubroutineuiv(shadertype, location, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUniformSubroutinesuiv(GLenum shadertype, GLsizei count, const GLuint *indices)
-{
-    d_4_0_Core->f.UniformSubroutinesuiv(shadertype, count, indices);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetActiveSubroutineName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
-{
-    d_4_0_Core->f.GetActiveSubroutineName(program, shadertype, index, bufsize, length, name);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetActiveSubroutineUniformName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
-{
-    d_4_0_Core->f.GetActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetActiveSubroutineUniformiv(GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values)
-{
-    d_4_0_Core->f.GetActiveSubroutineUniformiv(program, shadertype, index, pname, values);
-}
-
-inline GLuint QOpenGLFunctions_4_3_Compatibility::glGetSubroutineIndex(GLuint program, GLenum shadertype, const GLchar *name)
-{
-    return d_4_0_Core->f.GetSubroutineIndex(program, shadertype, name);
-}
-
-inline GLint QOpenGLFunctions_4_3_Compatibility::glGetSubroutineUniformLocation(GLuint program, GLenum shadertype, const GLchar *name)
-{
-    return d_4_0_Core->f.GetSubroutineUniformLocation(program, shadertype, name);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetUniformdv(GLuint program, GLint location, GLdouble *params)
-{
-    d_4_0_Core->f.GetUniformdv(program, location, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUniformMatrix4x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix4x3dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUniformMatrix4x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix4x2dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUniformMatrix3x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix3x4dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUniformMatrix3x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix3x2dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUniformMatrix2x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix2x4dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUniformMatrix2x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix2x3dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix4dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUniformMatrix3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix3dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUniformMatrix2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix2dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUniform4dv(GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_0_Core->f.Uniform4dv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUniform3dv(GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_0_Core->f.Uniform3dv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUniform2dv(GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_0_Core->f.Uniform2dv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUniform1dv(GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_0_Core->f.Uniform1dv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUniform4d(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_4_0_Core->f.Uniform4d(location, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUniform3d(GLint location, GLdouble x, GLdouble y, GLdouble z)
-{
-    d_4_0_Core->f.Uniform3d(location, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUniform2d(GLint location, GLdouble x, GLdouble y)
-{
-    d_4_0_Core->f.Uniform2d(location, x, y);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUniform1d(GLint location, GLdouble x)
-{
-    d_4_0_Core->f.Uniform1d(location, x);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glDrawElementsIndirect(GLenum mode, GLenum type, const GLvoid *indirect)
-{
-    d_4_0_Core->f.DrawElementsIndirect(mode, type, indirect);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glDrawArraysIndirect(GLenum mode, const GLvoid *indirect)
-{
-    d_4_0_Core->f.DrawArraysIndirect(mode, indirect);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glBlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
-{
-    d_4_0_Core->f.BlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glBlendFunci(GLuint buf, GLenum src, GLenum dst)
-{
-    d_4_0_Core->f.BlendFunci(buf, src, dst);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glBlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha)
-{
-    d_4_0_Core->f.BlendEquationSeparatei(buf, modeRGB, modeAlpha);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glBlendEquationi(GLuint buf, GLenum mode)
-{
-    d_4_0_Core->f.BlendEquationi(buf, mode);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMinSampleShading(GLfloat value)
-{
-    d_4_0_Core->f.MinSampleShading(value);
-}
-
-
-// OpenGL 4.1 core functions
-inline void QOpenGLFunctions_4_3_Compatibility::glGetDoublei_v(GLenum target, GLuint index, GLdouble *data)
-{
-    d_4_1_Core->f.GetDoublei_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetFloati_v(GLenum target, GLuint index, GLfloat *data)
-{
-    d_4_1_Core->f.GetFloati_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glDepthRangeIndexed(GLuint index, GLdouble n, GLdouble f)
-{
-    d_4_1_Core->f.DepthRangeIndexed(index, n, f);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glDepthRangeArrayv(GLuint first, GLsizei count, const GLdouble *v)
-{
-    d_4_1_Core->f.DepthRangeArrayv(first, count, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glScissorIndexedv(GLuint index, const GLint *v)
-{
-    d_4_1_Core->f.ScissorIndexedv(index, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glScissorIndexed(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height)
-{
-    d_4_1_Core->f.ScissorIndexed(index, left, bottom, width, height);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glScissorArrayv(GLuint first, GLsizei count, const GLint *v)
-{
-    d_4_1_Core->f.ScissorArrayv(first, count, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glViewportIndexedfv(GLuint index, const GLfloat *v)
-{
-    d_4_1_Core->f.ViewportIndexedfv(index, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glViewportIndexedf(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h)
-{
-    d_4_1_Core->f.ViewportIndexedf(index, x, y, w, h);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glViewportArrayv(GLuint first, GLsizei count, const GLfloat *v)
-{
-    d_4_1_Core->f.ViewportArrayv(first, count, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetVertexAttribLdv(GLuint index, GLenum pname, GLdouble *params)
-{
-    d_4_1_Core->f.GetVertexAttribLdv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribLPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_4_1_Core->f.VertexAttribLPointer(index, size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribL4dv(GLuint index, const GLdouble *v)
-{
-    d_4_1_Core->f.VertexAttribL4dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribL3dv(GLuint index, const GLdouble *v)
-{
-    d_4_1_Core->f.VertexAttribL3dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribL2dv(GLuint index, const GLdouble *v)
-{
-    d_4_1_Core->f.VertexAttribL2dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribL1dv(GLuint index, const GLdouble *v)
-{
-    d_4_1_Core->f.VertexAttribL1dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribL4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_4_1_Core->f.VertexAttribL4d(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribL3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
-{
-    d_4_1_Core->f.VertexAttribL3d(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribL2d(GLuint index, GLdouble x, GLdouble y)
-{
-    d_4_1_Core->f.VertexAttribL2d(index, x, y);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribL1d(GLuint index, GLdouble x)
-{
-    d_4_1_Core->f.VertexAttribL1d(index, x);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-{
-    d_4_1_Core->f.GetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glValidateProgramPipeline(GLuint pipeline)
-{
-    d_4_1_Core->f.ValidateProgramPipeline(pipeline);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniformMatrix4x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4x3dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniformMatrix3x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3x4dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniformMatrix4x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4x2dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniformMatrix2x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2x4dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniformMatrix3x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3x2dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniformMatrix2x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2x3dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniformMatrix4x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4x3fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniformMatrix3x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3x4fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniformMatrix4x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4x2fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniformMatrix2x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2x4fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniformMatrix3x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3x2fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniformMatrix2x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2x3fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniformMatrix4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniformMatrix3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniformMatrix2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniformMatrix4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniformMatrix3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniformMatrix2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform4uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
-{
-    d_4_1_Core->f.ProgramUniform4uiv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
-{
-    d_4_1_Core->f.ProgramUniform4ui(program, location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform4dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniform4dv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform4d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3)
-{
-    d_4_1_Core->f.ProgramUniform4d(program, location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform4fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniform4fv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
-{
-    d_4_1_Core->f.ProgramUniform4f(program, location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform4iv(GLuint program, GLint location, GLsizei count, const GLint *value)
-{
-    d_4_1_Core->f.ProgramUniform4iv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
-{
-    d_4_1_Core->f.ProgramUniform4i(program, location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform3uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
-{
-    d_4_1_Core->f.ProgramUniform3uiv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2)
-{
-    d_4_1_Core->f.ProgramUniform3ui(program, location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform3dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniform3dv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform3d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2)
-{
-    d_4_1_Core->f.ProgramUniform3d(program, location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform3fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniform3fv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
-{
-    d_4_1_Core->f.ProgramUniform3f(program, location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform3iv(GLuint program, GLint location, GLsizei count, const GLint *value)
-{
-    d_4_1_Core->f.ProgramUniform3iv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2)
-{
-    d_4_1_Core->f.ProgramUniform3i(program, location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform2uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
-{
-    d_4_1_Core->f.ProgramUniform2uiv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1)
-{
-    d_4_1_Core->f.ProgramUniform2ui(program, location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform2dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniform2dv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform2d(GLuint program, GLint location, GLdouble v0, GLdouble v1)
-{
-    d_4_1_Core->f.ProgramUniform2d(program, location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform2fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniform2fv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1)
-{
-    d_4_1_Core->f.ProgramUniform2f(program, location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform2iv(GLuint program, GLint location, GLsizei count, const GLint *value)
-{
-    d_4_1_Core->f.ProgramUniform2iv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1)
-{
-    d_4_1_Core->f.ProgramUniform2i(program, location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform1uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
-{
-    d_4_1_Core->f.ProgramUniform1uiv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform1ui(GLuint program, GLint location, GLuint v0)
-{
-    d_4_1_Core->f.ProgramUniform1ui(program, location, v0);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform1dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniform1dv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform1d(GLuint program, GLint location, GLdouble v0)
-{
-    d_4_1_Core->f.ProgramUniform1d(program, location, v0);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform1fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniform1fv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform1f(GLuint program, GLint location, GLfloat v0)
-{
-    d_4_1_Core->f.ProgramUniform1f(program, location, v0);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform1iv(GLuint program, GLint location, GLsizei count, const GLint *value)
-{
-    d_4_1_Core->f.ProgramUniform1iv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform1i(GLuint program, GLint location, GLint v0)
-{
-    d_4_1_Core->f.ProgramUniform1i(program, location, v0);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params)
-{
-    d_4_1_Core->f.GetProgramPipelineiv(pipeline, pname, params);
-}
-
-inline GLboolean QOpenGLFunctions_4_3_Compatibility::glIsProgramPipeline(GLuint pipeline)
-{
-    return d_4_1_Core->f.IsProgramPipeline(pipeline);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGenProgramPipelines(GLsizei n, GLuint *pipelines)
-{
-    d_4_1_Core->f.GenProgramPipelines(n, pipelines);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glDeleteProgramPipelines(GLsizei n, const GLuint *pipelines)
-{
-    d_4_1_Core->f.DeleteProgramPipelines(n, pipelines);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glBindProgramPipeline(GLuint pipeline)
-{
-    d_4_1_Core->f.BindProgramPipeline(pipeline);
-}
-
-inline GLuint QOpenGLFunctions_4_3_Compatibility::glCreateShaderProgramv(GLenum type, GLsizei count, const GLchar* const *strings)
-{
-    return d_4_1_Core->f.CreateShaderProgramv(type, count, strings);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glActiveShaderProgram(GLuint pipeline, GLuint program)
-{
-    d_4_1_Core->f.ActiveShaderProgram(pipeline, program);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program)
-{
-    d_4_1_Core->f.UseProgramStages(pipeline, stages, program);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProgramParameteri(GLuint program, GLenum pname, GLint value)
-{
-    d_4_1_Core->f.ProgramParameteri(program, pname, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid *binary, GLsizei length)
-{
-    d_4_1_Core->f.ProgramBinary(program, binaryFormat, binary, length);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, GLvoid *binary)
-{
-    d_4_1_Core->f.GetProgramBinary(program, bufSize, length, binaryFormat, binary);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glClearDepthf(GLfloat dd)
-{
-    d_4_1_Core->f.ClearDepthf(dd);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glDepthRangef(GLfloat n, GLfloat f)
-{
-    d_4_1_Core->f.DepthRangef(n, f);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision)
-{
-    d_4_1_Core->f.GetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glShaderBinary(GLsizei count, const GLuint *shaders, GLenum binaryformat, const GLvoid *binary, GLsizei length)
-{
-    d_4_1_Core->f.ShaderBinary(count, shaders, binaryformat, binary, length);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glReleaseShaderCompiler()
-{
-    d_4_1_Core->f.ReleaseShaderCompiler();
-}
-
-
-// OpenGL 4.2 core functions
-inline void QOpenGLFunctions_4_3_Compatibility::glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
-{
-    d_4_2_Core->f.TexStorage3D(target, levels, internalformat, width, height, depth);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    d_4_2_Core->f.TexStorage2D(target, levels, internalformat, width, height);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexStorage1D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width)
-{
-    d_4_2_Core->f.TexStorage1D(target, levels, internalformat, width);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMemoryBarrier(GLbitfield barriers)
-{
-    d_4_2_Core->f.MemoryBarrier(barriers);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glBindImageTexture(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format)
-{
-    d_4_2_Core->f.BindImageTexture(unit, texture, level, layered, layer, access, format);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetActiveAtomicCounterBufferiv(GLuint program, GLuint bufferIndex, GLenum pname, GLint *params)
-{
-    d_4_2_Core->f.GetActiveAtomicCounterBufferiv(program, bufferIndex, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params)
-{
-    d_4_2_Core->f.GetInternalformativ(target, internalformat, pname, bufSize, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glDrawTransformFeedbackStreamInstanced(GLenum mode, GLuint id, GLuint stream, GLsizei instancecount)
-{
-    d_4_2_Core->f.DrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glDrawTransformFeedbackInstanced(GLenum mode, GLuint id, GLsizei instancecount)
-{
-    d_4_2_Core->f.DrawTransformFeedbackInstanced(mode, id, instancecount);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glDrawElementsInstancedBaseVertexBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance)
-{
-    d_4_2_Core->f.DrawElementsInstancedBaseVertexBaseInstance(mode, count, type, indices, instancecount, basevertex, baseinstance);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glDrawElementsInstancedBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLuint baseinstance)
-{
-    d_4_2_Core->f.DrawElementsInstancedBaseInstance(mode, count, type, indices, instancecount, baseinstance);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glDrawArraysInstancedBaseInstance(GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance)
-{
-    d_4_2_Core->f.DrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);
-}
-
-
-// OpenGL 4.3 core functions
-inline void QOpenGLFunctions_4_3_Compatibility::glTexStorage3DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
-{
-    d_4_3_Core->f.TexStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexStorage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
-{
-    d_4_3_Core->f.TexStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexBufferRange(GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size)
-{
-    d_4_3_Core->f.TexBufferRange(target, internalformat, buffer, offset, size);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glShaderStorageBlockBinding(GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding)
-{
-    d_4_3_Core->f.ShaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding);
-}
-
-inline GLint QOpenGLFunctions_4_3_Compatibility::glGetProgramResourceLocationIndex(GLuint program, GLenum programInterface, const GLchar *name)
-{
-    return d_4_3_Core->f.GetProgramResourceLocationIndex(program, programInterface, name);
-}
-
-inline GLint QOpenGLFunctions_4_3_Compatibility::glGetProgramResourceLocation(GLuint program, GLenum programInterface, const GLchar *name)
-{
-    return d_4_3_Core->f.GetProgramResourceLocation(program, programInterface, name);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetProgramResourceiv(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params)
-{
-    d_4_3_Core->f.GetProgramResourceiv(program, programInterface, index, propCount, props, bufSize, length, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetProgramResourceName(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name)
-{
-    d_4_3_Core->f.GetProgramResourceName(program, programInterface, index, bufSize, length, name);
-}
-
-inline GLuint QOpenGLFunctions_4_3_Compatibility::glGetProgramResourceIndex(GLuint program, GLenum programInterface, const GLchar *name)
-{
-    return d_4_3_Core->f.GetProgramResourceIndex(program, programInterface, name);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetProgramInterfaceiv(GLuint program, GLenum programInterface, GLenum pname, GLint *params)
-{
-    d_4_3_Core->f.GetProgramInterfaceiv(program, programInterface, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMultiDrawElementsIndirect(GLenum mode, GLenum type, const void *indirect, GLsizei drawcount, GLsizei stride)
-{
-    d_4_3_Core->f.MultiDrawElementsIndirect(mode, type, indirect, drawcount, stride);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMultiDrawArraysIndirect(GLenum mode, const void *indirect, GLsizei drawcount, GLsizei stride)
-{
-    d_4_3_Core->f.MultiDrawArraysIndirect(mode, indirect, drawcount, stride);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glInvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_4_3_Core->f.InvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glInvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments)
-{
-    d_4_3_Core->f.InvalidateFramebuffer(target, numAttachments, attachments);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glInvalidateBufferData(GLuint buffer)
-{
-    d_4_3_Core->f.InvalidateBufferData(buffer);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glInvalidateBufferSubData(GLuint buffer, GLintptr offset, GLsizeiptr length)
-{
-    d_4_3_Core->f.InvalidateBufferSubData(buffer, offset, length);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glInvalidateTexImage(GLuint texture, GLint level)
-{
-    d_4_3_Core->f.InvalidateTexImage(texture, level);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glInvalidateTexSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth)
-{
-    d_4_3_Core->f.InvalidateTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetInternalformati64v(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint64 *params)
-{
-    d_4_3_Core->f.GetInternalformati64v(target, internalformat, pname, bufSize, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetFramebufferParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_4_3_Core->f.GetFramebufferParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glFramebufferParameteri(GLenum target, GLenum pname, GLint param)
-{
-    d_4_3_Core->f.FramebufferParameteri(target, pname, param);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexBindingDivisor(GLuint bindingindex, GLuint divisor)
-{
-    d_4_3_Core->f.VertexBindingDivisor(bindingindex, divisor);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribBinding(GLuint attribindex, GLuint bindingindex)
-{
-    d_4_3_Core->f.VertexAttribBinding(attribindex, bindingindex);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribLFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
-{
-    d_4_3_Core->f.VertexAttribLFormat(attribindex, size, type, relativeoffset);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribIFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
-{
-    d_4_3_Core->f.VertexAttribIFormat(attribindex, size, type, relativeoffset);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribFormat(GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset)
-{
-    d_4_3_Core->f.VertexAttribFormat(attribindex, size, type, normalized, relativeoffset);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glBindVertexBuffer(GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride)
-{
-    d_4_3_Core->f.BindVertexBuffer(bindingindex, buffer, offset, stride);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTextureView(GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers)
-{
-    d_4_3_Core->f.TextureView(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glCopyImageSubData(GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth)
-{
-    d_4_3_Core->f.CopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glDispatchComputeIndirect(GLintptr indirect)
-{
-    d_4_3_Core->f.DispatchComputeIndirect(indirect);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glDispatchCompute(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z)
-{
-    d_4_3_Core->f.DispatchCompute(num_groups_x, num_groups_y, num_groups_z);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glClearBufferSubData(GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data)
-{
-    d_4_3_Core->f.ClearBufferSubData(target, internalformat, offset, size, format, type, data);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glClearBufferData(GLenum target, GLenum internalformat, GLenum format, GLenum type, const void *data)
-{
-    d_4_3_Core->f.ClearBufferData(target, internalformat, format, type, data);
-}
-
-
-// OpenGL 1.0 deprecated functions
-inline void QOpenGLFunctions_4_3_Compatibility::glTranslatef(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Translatef(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTranslated(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Translated(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glScalef(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Scalef(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glScaled(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Scaled(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Rotatef(angle, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Rotated(angle, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glPushMatrix()
-{
-    d_1_0_Deprecated->f.PushMatrix();
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glPopMatrix()
-{
-    d_1_0_Deprecated->f.PopMatrix();
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
-{
-    d_1_0_Deprecated->f.Ortho(left, right, bottom, top, zNear, zFar);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMultMatrixd(const GLdouble *m)
-{
-    d_1_0_Deprecated->f.MultMatrixd(m);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMultMatrixf(const GLfloat *m)
-{
-    d_1_0_Deprecated->f.MultMatrixf(m);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMatrixMode(GLenum mode)
-{
-    d_1_0_Deprecated->f.MatrixMode(mode);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glLoadMatrixd(const GLdouble *m)
-{
-    d_1_0_Deprecated->f.LoadMatrixd(m);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glLoadMatrixf(const GLfloat *m)
-{
-    d_1_0_Deprecated->f.LoadMatrixf(m);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glLoadIdentity()
-{
-    d_1_0_Deprecated->f.LoadIdentity();
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
-{
-    d_1_0_Deprecated->f.Frustum(left, right, bottom, top, zNear, zFar);
-}
-
-inline GLboolean QOpenGLFunctions_4_3_Compatibility::glIsList(GLuint list)
-{
-    return d_1_0_Deprecated->f.IsList(list);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetTexGeniv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetTexGenfv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
-{
-    d_1_0_Deprecated->f.GetTexGendv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetTexEnviv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetTexEnviv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetTexEnvfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetPolygonStipple(GLubyte *mask)
-{
-    d_1_0_Deprecated->f.GetPolygonStipple(mask);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetPixelMapusv(GLenum map, GLushort *values)
-{
-    d_1_0_Deprecated->f.GetPixelMapusv(map, values);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetPixelMapuiv(GLenum map, GLuint *values)
-{
-    d_1_0_Deprecated->f.GetPixelMapuiv(map, values);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetPixelMapfv(GLenum map, GLfloat *values)
-{
-    d_1_0_Deprecated->f.GetPixelMapfv(map, values);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetMaterialiv(GLenum face, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetMaterialiv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetMaterialfv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetMapiv(GLenum target, GLenum query, GLint *v)
-{
-    d_1_0_Deprecated->f.GetMapiv(target, query, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetMapfv(GLenum target, GLenum query, GLfloat *v)
-{
-    d_1_0_Deprecated->f.GetMapfv(target, query, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetMapdv(GLenum target, GLenum query, GLdouble *v)
-{
-    d_1_0_Deprecated->f.GetMapdv(target, query, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetLightiv(GLenum light, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetLightiv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetLightfv(GLenum light, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetLightfv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetClipPlane(GLenum plane, GLdouble *equation)
-{
-    d_1_0_Deprecated->f.GetClipPlane(plane, equation);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Deprecated->f.DrawPixels(width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
-{
-    d_1_0_Deprecated->f.CopyPixels(x, y, width, height, type);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values)
-{
-    d_1_0_Deprecated->f.PixelMapusv(map, mapsize, values);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values)
-{
-    d_1_0_Deprecated->f.PixelMapuiv(map, mapsize, values);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values)
-{
-    d_1_0_Deprecated->f.PixelMapfv(map, mapsize, values);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glPixelTransferi(GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.PixelTransferi(pname, param);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glPixelTransferf(GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.PixelTransferf(pname, param);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glPixelZoom(GLfloat xfactor, GLfloat yfactor)
-{
-    d_1_0_Deprecated->f.PixelZoom(xfactor, yfactor);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glAlphaFunc(GLenum func, GLfloat ref)
-{
-    d_1_0_Deprecated->f.AlphaFunc(func, ref);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glEvalPoint2(GLint i, GLint j)
-{
-    d_1_0_Deprecated->f.EvalPoint2(i, j);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
-{
-    d_1_0_Deprecated->f.EvalMesh2(mode, i1, i2, j1, j2);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glEvalPoint1(GLint i)
-{
-    d_1_0_Deprecated->f.EvalPoint1(i);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glEvalMesh1(GLenum mode, GLint i1, GLint i2)
-{
-    d_1_0_Deprecated->f.EvalMesh1(mode, i1, i2);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glEvalCoord2fv(const GLfloat *u)
-{
-    d_1_0_Deprecated->f.EvalCoord2fv(u);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glEvalCoord2f(GLfloat u, GLfloat v)
-{
-    d_1_0_Deprecated->f.EvalCoord2f(u, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glEvalCoord2dv(const GLdouble *u)
-{
-    d_1_0_Deprecated->f.EvalCoord2dv(u);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glEvalCoord2d(GLdouble u, GLdouble v)
-{
-    d_1_0_Deprecated->f.EvalCoord2d(u, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glEvalCoord1fv(const GLfloat *u)
-{
-    d_1_0_Deprecated->f.EvalCoord1fv(u);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glEvalCoord1f(GLfloat u)
-{
-    d_1_0_Deprecated->f.EvalCoord1f(u);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glEvalCoord1dv(const GLdouble *u)
-{
-    d_1_0_Deprecated->f.EvalCoord1dv(u);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glEvalCoord1d(GLdouble u)
-{
-    d_1_0_Deprecated->f.EvalCoord1d(u);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
-{
-    d_1_0_Deprecated->f.MapGrid2f(un, u1, u2, vn, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
-{
-    d_1_0_Deprecated->f.MapGrid2d(un, u1, u2, vn, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
-{
-    d_1_0_Deprecated->f.MapGrid1f(un, u1, u2);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
-{
-    d_1_0_Deprecated->f.MapGrid1d(un, u1, u2);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
-{
-    d_1_0_Deprecated->f.Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
-{
-    d_1_0_Deprecated->f.Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
-{
-    d_1_0_Deprecated->f.Map1f(target, u1, u2, stride, order, points);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
-{
-    d_1_0_Deprecated->f.Map1d(target, u1, u2, stride, order, points);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glPushAttrib(GLbitfield mask)
-{
-    d_1_0_Deprecated->f.PushAttrib(mask);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glPopAttrib()
-{
-    d_1_0_Deprecated->f.PopAttrib();
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glAccum(GLenum op, GLfloat value)
-{
-    d_1_0_Deprecated->f.Accum(op, value);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glIndexMask(GLuint mask)
-{
-    d_1_0_Deprecated->f.IndexMask(mask);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glClearIndex(GLfloat c)
-{
-    d_1_0_Deprecated->f.ClearIndex(c);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Deprecated->f.ClearAccum(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glPushName(GLuint name)
-{
-    d_1_0_Deprecated->f.PushName(name);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glPopName()
-{
-    d_1_0_Deprecated->f.PopName();
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glPassThrough(GLfloat token)
-{
-    d_1_0_Deprecated->f.PassThrough(token);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glLoadName(GLuint name)
-{
-    d_1_0_Deprecated->f.LoadName(name);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glInitNames()
-{
-    d_1_0_Deprecated->f.InitNames();
-}
-
-inline GLint QOpenGLFunctions_4_3_Compatibility::glRenderMode(GLenum mode)
-{
-    return d_1_0_Deprecated->f.RenderMode(mode);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glSelectBuffer(GLsizei size, GLuint *buffer)
-{
-    d_1_0_Deprecated->f.SelectBuffer(size, buffer);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
-{
-    d_1_0_Deprecated->f.FeedbackBuffer(size, type, buffer);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexGeniv(GLenum coord, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.TexGeniv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexGeni(GLenum coord, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.TexGeni(coord, pname, param);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.TexGenfv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexGenf(GLenum coord, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.TexGenf(coord, pname, param);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
-{
-    d_1_0_Deprecated->f.TexGendv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexGend(GLenum coord, GLenum pname, GLdouble param)
-{
-    d_1_0_Deprecated->f.TexGend(coord, pname, param);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexEnviv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.TexEnviv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexEnvi(GLenum target, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.TexEnvi(target, pname, param);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.TexEnvfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexEnvf(GLenum target, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.TexEnvf(target, pname, param);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glShadeModel(GLenum mode)
-{
-    d_1_0_Deprecated->f.ShadeModel(mode);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glPolygonStipple(const GLubyte *mask)
-{
-    d_1_0_Deprecated->f.PolygonStipple(mask);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMaterialiv(GLenum face, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.Materialiv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMateriali(GLenum face, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.Materiali(face, pname, param);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.Materialfv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMaterialf(GLenum face, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.Materialf(face, pname, param);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glLineStipple(GLint factor, GLushort pattern)
-{
-    d_1_0_Deprecated->f.LineStipple(factor, pattern);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glLightModeliv(GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.LightModeliv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glLightModeli(GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.LightModeli(pname, param);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glLightModelfv(GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.LightModelfv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glLightModelf(GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.LightModelf(pname, param);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glLightiv(GLenum light, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.Lightiv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glLighti(GLenum light, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.Lighti(light, pname, param);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glLightfv(GLenum light, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.Lightfv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glLightf(GLenum light, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.Lightf(light, pname, param);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glFogiv(GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.Fogiv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glFogi(GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.Fogi(pname, param);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glFogfv(GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.Fogfv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glFogf(GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.Fogf(pname, param);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glColorMaterial(GLenum face, GLenum mode)
-{
-    d_1_0_Deprecated->f.ColorMaterial(face, mode);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glClipPlane(GLenum plane, const GLdouble *equation)
-{
-    d_1_0_Deprecated->f.ClipPlane(plane, equation);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertex4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Vertex4sv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
-{
-    d_1_0_Deprecated->f.Vertex4s(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertex4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Vertex4iv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertex4i(GLint x, GLint y, GLint z, GLint w)
-{
-    d_1_0_Deprecated->f.Vertex4i(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertex4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Vertex4fv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    d_1_0_Deprecated->f.Vertex4f(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertex4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Vertex4dv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_1_0_Deprecated->f.Vertex4d(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertex3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Vertex3sv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertex3s(GLshort x, GLshort y, GLshort z)
-{
-    d_1_0_Deprecated->f.Vertex3s(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertex3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Vertex3iv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertex3i(GLint x, GLint y, GLint z)
-{
-    d_1_0_Deprecated->f.Vertex3i(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertex3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Vertex3fv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertex3f(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Vertex3f(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertex3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Vertex3dv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertex3d(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Vertex3d(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertex2sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Vertex2sv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertex2s(GLshort x, GLshort y)
-{
-    d_1_0_Deprecated->f.Vertex2s(x, y);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertex2iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Vertex2iv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertex2i(GLint x, GLint y)
-{
-    d_1_0_Deprecated->f.Vertex2i(x, y);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertex2fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Vertex2fv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertex2f(GLfloat x, GLfloat y)
-{
-    d_1_0_Deprecated->f.Vertex2f(x, y);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertex2dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Vertex2dv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertex2d(GLdouble x, GLdouble y)
-{
-    d_1_0_Deprecated->f.Vertex2d(x, y);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord4sv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
-{
-    d_1_0_Deprecated->f.TexCoord4s(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord4iv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
-{
-    d_1_0_Deprecated->f.TexCoord4i(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord4fv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
-{
-    d_1_0_Deprecated->f.TexCoord4f(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord4dv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
-{
-    d_1_0_Deprecated->f.TexCoord4d(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord3sv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord3s(GLshort s, GLshort t, GLshort r)
-{
-    d_1_0_Deprecated->f.TexCoord3s(s, t, r);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord3iv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord3i(GLint s, GLint t, GLint r)
-{
-    d_1_0_Deprecated->f.TexCoord3i(s, t, r);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord3fv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
-{
-    d_1_0_Deprecated->f.TexCoord3f(s, t, r);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord3dv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
-{
-    d_1_0_Deprecated->f.TexCoord3d(s, t, r);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord2sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord2sv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord2s(GLshort s, GLshort t)
-{
-    d_1_0_Deprecated->f.TexCoord2s(s, t);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord2iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord2iv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord2i(GLint s, GLint t)
-{
-    d_1_0_Deprecated->f.TexCoord2i(s, t);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord2fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord2fv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord2f(GLfloat s, GLfloat t)
-{
-    d_1_0_Deprecated->f.TexCoord2f(s, t);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord2dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord2dv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord2d(GLdouble s, GLdouble t)
-{
-    d_1_0_Deprecated->f.TexCoord2d(s, t);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord1sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord1sv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord1s(GLshort s)
-{
-    d_1_0_Deprecated->f.TexCoord1s(s);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord1iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord1iv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord1i(GLint s)
-{
-    d_1_0_Deprecated->f.TexCoord1i(s);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord1fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord1fv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord1f(GLfloat s)
-{
-    d_1_0_Deprecated->f.TexCoord1f(s);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord1dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord1dv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord1d(GLdouble s)
-{
-    d_1_0_Deprecated->f.TexCoord1d(s);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glRectsv(const GLshort *v1, const GLshort *v2)
-{
-    d_1_0_Deprecated->f.Rectsv(v1, v2);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
-{
-    d_1_0_Deprecated->f.Rects(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glRectiv(const GLint *v1, const GLint *v2)
-{
-    d_1_0_Deprecated->f.Rectiv(v1, v2);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
-{
-    d_1_0_Deprecated->f.Recti(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glRectfv(const GLfloat *v1, const GLfloat *v2)
-{
-    d_1_0_Deprecated->f.Rectfv(v1, v2);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
-{
-    d_1_0_Deprecated->f.Rectf(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glRectdv(const GLdouble *v1, const GLdouble *v2)
-{
-    d_1_0_Deprecated->f.Rectdv(v1, v2);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
-{
-    d_1_0_Deprecated->f.Rectd(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glRasterPos4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.RasterPos4sv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
-{
-    d_1_0_Deprecated->f.RasterPos4s(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glRasterPos4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.RasterPos4iv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
-{
-    d_1_0_Deprecated->f.RasterPos4i(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glRasterPos4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.RasterPos4fv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    d_1_0_Deprecated->f.RasterPos4f(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glRasterPos4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.RasterPos4dv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_1_0_Deprecated->f.RasterPos4d(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glRasterPos3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.RasterPos3sv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glRasterPos3s(GLshort x, GLshort y, GLshort z)
-{
-    d_1_0_Deprecated->f.RasterPos3s(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glRasterPos3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.RasterPos3iv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glRasterPos3i(GLint x, GLint y, GLint z)
-{
-    d_1_0_Deprecated->f.RasterPos3i(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glRasterPos3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.RasterPos3fv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.RasterPos3f(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glRasterPos3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.RasterPos3dv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.RasterPos3d(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glRasterPos2sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.RasterPos2sv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glRasterPos2s(GLshort x, GLshort y)
-{
-    d_1_0_Deprecated->f.RasterPos2s(x, y);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glRasterPos2iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.RasterPos2iv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glRasterPos2i(GLint x, GLint y)
-{
-    d_1_0_Deprecated->f.RasterPos2i(x, y);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glRasterPos2fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.RasterPos2fv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glRasterPos2f(GLfloat x, GLfloat y)
-{
-    d_1_0_Deprecated->f.RasterPos2f(x, y);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glRasterPos2dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.RasterPos2dv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glRasterPos2d(GLdouble x, GLdouble y)
-{
-    d_1_0_Deprecated->f.RasterPos2d(x, y);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glNormal3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Normal3sv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glNormal3s(GLshort nx, GLshort ny, GLshort nz)
-{
-    d_1_0_Deprecated->f.Normal3s(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glNormal3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Normal3iv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glNormal3i(GLint nx, GLint ny, GLint nz)
-{
-    d_1_0_Deprecated->f.Normal3i(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glNormal3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Normal3fv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
-{
-    d_1_0_Deprecated->f.Normal3f(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glNormal3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Normal3dv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
-{
-    d_1_0_Deprecated->f.Normal3d(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glNormal3bv(const GLbyte *v)
-{
-    d_1_0_Deprecated->f.Normal3bv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
-{
-    d_1_0_Deprecated->f.Normal3b(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glIndexsv(const GLshort *c)
-{
-    d_1_0_Deprecated->f.Indexsv(c);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glIndexs(GLshort c)
-{
-    d_1_0_Deprecated->f.Indexs(c);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glIndexiv(const GLint *c)
-{
-    d_1_0_Deprecated->f.Indexiv(c);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glIndexi(GLint c)
-{
-    d_1_0_Deprecated->f.Indexi(c);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glIndexfv(const GLfloat *c)
-{
-    d_1_0_Deprecated->f.Indexfv(c);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glIndexf(GLfloat c)
-{
-    d_1_0_Deprecated->f.Indexf(c);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glIndexdv(const GLdouble *c)
-{
-    d_1_0_Deprecated->f.Indexdv(c);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glIndexd(GLdouble c)
-{
-    d_1_0_Deprecated->f.Indexd(c);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glEnd()
-{
-    d_1_0_Deprecated->f.End();
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glEdgeFlagv(const GLboolean *flag)
-{
-    d_1_0_Deprecated->f.EdgeFlagv(flag);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glEdgeFlag(GLboolean flag)
-{
-    d_1_0_Deprecated->f.EdgeFlag(flag);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glColor4usv(const GLushort *v)
-{
-    d_1_0_Deprecated->f.Color4usv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
-{
-    d_1_0_Deprecated->f.Color4us(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glColor4uiv(const GLuint *v)
-{
-    d_1_0_Deprecated->f.Color4uiv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
-{
-    d_1_0_Deprecated->f.Color4ui(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glColor4ubv(const GLubyte *v)
-{
-    d_1_0_Deprecated->f.Color4ubv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
-{
-    d_1_0_Deprecated->f.Color4ub(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glColor4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Color4sv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
-{
-    d_1_0_Deprecated->f.Color4s(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glColor4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Color4iv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
-{
-    d_1_0_Deprecated->f.Color4i(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glColor4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Color4fv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Deprecated->f.Color4f(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glColor4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Color4dv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
-{
-    d_1_0_Deprecated->f.Color4d(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glColor4bv(const GLbyte *v)
-{
-    d_1_0_Deprecated->f.Color4bv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
-{
-    d_1_0_Deprecated->f.Color4b(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glColor3usv(const GLushort *v)
-{
-    d_1_0_Deprecated->f.Color3usv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glColor3us(GLushort red, GLushort green, GLushort blue)
-{
-    d_1_0_Deprecated->f.Color3us(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glColor3uiv(const GLuint *v)
-{
-    d_1_0_Deprecated->f.Color3uiv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glColor3ui(GLuint red, GLuint green, GLuint blue)
-{
-    d_1_0_Deprecated->f.Color3ui(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glColor3ubv(const GLubyte *v)
-{
-    d_1_0_Deprecated->f.Color3ubv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
-{
-    d_1_0_Deprecated->f.Color3ub(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glColor3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Color3sv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glColor3s(GLshort red, GLshort green, GLshort blue)
-{
-    d_1_0_Deprecated->f.Color3s(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glColor3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Color3iv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glColor3i(GLint red, GLint green, GLint blue)
-{
-    d_1_0_Deprecated->f.Color3i(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glColor3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Color3fv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glColor3f(GLfloat red, GLfloat green, GLfloat blue)
-{
-    d_1_0_Deprecated->f.Color3f(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glColor3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Color3dv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glColor3d(GLdouble red, GLdouble green, GLdouble blue)
-{
-    d_1_0_Deprecated->f.Color3d(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glColor3bv(const GLbyte *v)
-{
-    d_1_0_Deprecated->f.Color3bv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glColor3b(GLbyte red, GLbyte green, GLbyte blue)
-{
-    d_1_0_Deprecated->f.Color3b(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
-{
-    d_1_0_Deprecated->f.Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glBegin(GLenum mode)
-{
-    d_1_0_Deprecated->f.Begin(mode);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glListBase(GLuint base)
-{
-    d_1_0_Deprecated->f.ListBase(base);
-}
-
-inline GLuint QOpenGLFunctions_4_3_Compatibility::glGenLists(GLsizei range)
-{
-    return d_1_0_Deprecated->f.GenLists(range);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glDeleteLists(GLuint list, GLsizei range)
-{
-    d_1_0_Deprecated->f.DeleteLists(list, range);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glCallLists(GLsizei n, GLenum type, const GLvoid *lists)
-{
-    d_1_0_Deprecated->f.CallLists(n, type, lists);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glCallList(GLuint list)
-{
-    d_1_0_Deprecated->f.CallList(list);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glEndList()
-{
-    d_1_0_Deprecated->f.EndList();
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glNewList(GLuint list, GLenum mode)
-{
-    d_1_0_Deprecated->f.NewList(list, mode);
-}
-
-
-// OpenGL 1.1 deprecated functions
-inline void QOpenGLFunctions_4_3_Compatibility::glPushClientAttrib(GLbitfield mask)
-{
-    d_1_1_Deprecated->f.PushClientAttrib(mask);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glPopClientAttrib()
-{
-    d_1_1_Deprecated->f.PopClientAttrib();
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities)
-{
-    d_1_1_Deprecated->f.PrioritizeTextures(n, textures, priorities);
-}
-
-inline GLboolean QOpenGLFunctions_4_3_Compatibility::glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
-{
-    return d_1_1_Deprecated->f.AreTexturesResident(n, textures, residences);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.VertexPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.TexCoordPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.NormalPointer(type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.InterleavedArrays(format, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.IndexPointer(type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glEnableClientState(GLenum array)
-{
-    d_1_1_Deprecated->f.EnableClientState(array);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.EdgeFlagPointer(stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glDisableClientState(GLenum array)
-{
-    d_1_1_Deprecated->f.DisableClientState(array);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_1_Deprecated->f.ColorPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glArrayElement(GLint i)
-{
-    d_1_1_Deprecated->f.ArrayElement(i);
-}
-
-
-// OpenGL 1.2 deprecated functions
-inline void QOpenGLFunctions_4_3_Compatibility::glResetMinmax(GLenum target)
-{
-    d_1_2_Deprecated->f.ResetMinmax(target);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glResetHistogram(GLenum target)
-{
-    d_1_2_Deprecated->f.ResetHistogram(target);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMinmax(GLenum target, GLenum internalformat, GLboolean sink)
-{
-    d_1_2_Deprecated->f.Minmax(target, internalformat, sink);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
-{
-    d_1_2_Deprecated->f.Histogram(target, width, internalformat, sink);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetMinmaxParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetMinmaxParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
-{
-    d_1_2_Deprecated->f.GetMinmax(target, reset, format, type, values);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetHistogramParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetHistogramParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
-{
-    d_1_2_Deprecated->f.GetHistogram(target, reset, format, type, values);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column)
-{
-    d_1_2_Deprecated->f.SeparableFilter2D(target, internalformat, width, height, format, type, row, column);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span)
-{
-    d_1_2_Deprecated->f.GetSeparableFilter(target, format, type, row, column, span);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetConvolutionParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetConvolutionParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image)
-{
-    d_1_2_Deprecated->f.GetConvolutionFilter(target, format, type, image);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_2_Deprecated->f.CopyConvolutionFilter2D(target, internalformat, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
-{
-    d_1_2_Deprecated->f.CopyConvolutionFilter1D(target, internalformat, x, y, width);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glConvolutionParameteri(GLenum target, GLenum pname, GLint params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameteri(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameterf(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image)
-{
-    d_1_2_Deprecated->f.ConvolutionFilter2D(target, internalformat, width, height, format, type, image);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image)
-{
-    d_1_2_Deprecated->f.ConvolutionFilter1D(target, internalformat, width, format, type, image);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
-{
-    d_1_2_Deprecated->f.CopyColorSubTable(target, start, x, y, width);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data)
-{
-    d_1_2_Deprecated->f.ColorSubTable(target, start, count, format, type, data);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetColorTableParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetColorTableParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table)
-{
-    d_1_2_Deprecated->f.GetColorTable(target, format, type, table);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
-{
-    d_1_2_Deprecated->f.CopyColorTable(target, internalformat, x, y, width);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_2_Deprecated->f.ColorTableParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_2_Deprecated->f.ColorTableParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table)
-{
-    d_1_2_Deprecated->f.ColorTable(target, internalformat, width, format, type, table);
-}
-
-
-// OpenGL 1.3 deprecated functions
-inline void QOpenGLFunctions_4_3_Compatibility::glMultTransposeMatrixd(const GLdouble *m)
-{
-    d_1_3_Deprecated->f.MultTransposeMatrixd(m);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMultTransposeMatrixf(const GLfloat *m)
-{
-    d_1_3_Deprecated->f.MultTransposeMatrixf(m);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glLoadTransposeMatrixd(const GLdouble *m)
-{
-    d_1_3_Deprecated->f.LoadTransposeMatrixd(m);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glLoadTransposeMatrixf(const GLfloat *m)
-{
-    d_1_3_Deprecated->f.LoadTransposeMatrixf(m);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord4sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4sv(target, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4s(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord4iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4iv(target, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4i(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord4fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4fv(target, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4f(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord4dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4dv(target, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4d(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord3sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3sv(target, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3s(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord3iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3iv(target, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3i(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord3fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3fv(target, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3f(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord3dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3dv(target, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3d(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord2sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2sv(target, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord2s(GLenum target, GLshort s, GLshort t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2s(target, s, t);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord2iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2iv(target, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord2i(GLenum target, GLint s, GLint t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2i(target, s, t);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord2fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2fv(target, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2f(target, s, t);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord2dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2dv(target, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2d(target, s, t);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord1sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1sv(target, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord1s(GLenum target, GLshort s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1s(target, s);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord1iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1iv(target, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord1i(GLenum target, GLint s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1i(target, s);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord1fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1fv(target, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord1f(GLenum target, GLfloat s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1f(target, s);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord1dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1dv(target, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord1d(GLenum target, GLdouble s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1d(target, s);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glClientActiveTexture(GLenum texture)
-{
-    d_1_3_Deprecated->f.ClientActiveTexture(texture);
-}
-
-
-// OpenGL 1.4 deprecated functions
-inline void QOpenGLFunctions_4_3_Compatibility::glWindowPos3sv(const GLshort *v)
-{
-    d_1_4_Deprecated->f.WindowPos3sv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glWindowPos3s(GLshort x, GLshort y, GLshort z)
-{
-    d_1_4_Deprecated->f.WindowPos3s(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glWindowPos3iv(const GLint *v)
-{
-    d_1_4_Deprecated->f.WindowPos3iv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glWindowPos3i(GLint x, GLint y, GLint z)
-{
-    d_1_4_Deprecated->f.WindowPos3i(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glWindowPos3fv(const GLfloat *v)
-{
-    d_1_4_Deprecated->f.WindowPos3fv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glWindowPos3f(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_4_Deprecated->f.WindowPos3f(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glWindowPos3dv(const GLdouble *v)
-{
-    d_1_4_Deprecated->f.WindowPos3dv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glWindowPos3d(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_4_Deprecated->f.WindowPos3d(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glWindowPos2sv(const GLshort *v)
-{
-    d_1_4_Deprecated->f.WindowPos2sv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glWindowPos2s(GLshort x, GLshort y)
-{
-    d_1_4_Deprecated->f.WindowPos2s(x, y);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glWindowPos2iv(const GLint *v)
-{
-    d_1_4_Deprecated->f.WindowPos2iv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glWindowPos2i(GLint x, GLint y)
-{
-    d_1_4_Deprecated->f.WindowPos2i(x, y);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glWindowPos2fv(const GLfloat *v)
-{
-    d_1_4_Deprecated->f.WindowPos2fv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glWindowPos2f(GLfloat x, GLfloat y)
-{
-    d_1_4_Deprecated->f.WindowPos2f(x, y);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glWindowPos2dv(const GLdouble *v)
-{
-    d_1_4_Deprecated->f.WindowPos2dv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glWindowPos2d(GLdouble x, GLdouble y)
-{
-    d_1_4_Deprecated->f.WindowPos2d(x, y);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_4_Deprecated->f.SecondaryColorPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glSecondaryColor3usv(const GLushort *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3usv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glSecondaryColor3us(GLushort red, GLushort green, GLushort blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3us(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glSecondaryColor3uiv(const GLuint *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3uiv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3ui(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glSecondaryColor3ubv(const GLubyte *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3ubv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3ub(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glSecondaryColor3sv(const GLshort *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3sv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glSecondaryColor3s(GLshort red, GLshort green, GLshort blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3s(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glSecondaryColor3iv(const GLint *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3iv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glSecondaryColor3i(GLint red, GLint green, GLint blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3i(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glSecondaryColor3fv(const GLfloat *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3fv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3f(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glSecondaryColor3dv(const GLdouble *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3dv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3d(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glSecondaryColor3bv(const GLbyte *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3bv(v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3b(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glFogCoordPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_1_4_Deprecated->f.FogCoordPointer(type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glFogCoorddv(const GLdouble *coord)
-{
-    d_1_4_Deprecated->f.FogCoorddv(coord);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glFogCoordd(GLdouble coord)
-{
-    d_1_4_Deprecated->f.FogCoordd(coord);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glFogCoordfv(const GLfloat *coord)
-{
-    d_1_4_Deprecated->f.FogCoordfv(coord);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glFogCoordf(GLfloat coord)
-{
-    d_1_4_Deprecated->f.FogCoordf(coord);
-}
-
-
-// OpenGL 1.5 deprecated functions
-
-// OpenGL 2.0 deprecated functions
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4usv(GLuint index, const GLushort *v)
-{
-    d_2_0_Core->f.VertexAttrib4usv(index, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4uiv(GLuint index, const GLuint *v)
-{
-    d_2_0_Core->f.VertexAttrib4uiv(index, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4ubv(GLuint index, const GLubyte *v)
-{
-    d_2_0_Core->f.VertexAttrib4ubv(index, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4sv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib4sv(index, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
-{
-    d_2_0_Core->f.VertexAttrib4s(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4iv(GLuint index, const GLint *v)
-{
-    d_2_0_Core->f.VertexAttrib4iv(index, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4fv(GLuint index, const GLfloat *v)
-{
-    d_2_0_Core->f.VertexAttrib4fv(index, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    d_2_0_Core->f.VertexAttrib4f(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4dv(GLuint index, const GLdouble *v)
-{
-    d_2_0_Core->f.VertexAttrib4dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_2_0_Core->f.VertexAttrib4d(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4bv(GLuint index, const GLbyte *v)
-{
-    d_2_0_Core->f.VertexAttrib4bv(index, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4Nusv(GLuint index, const GLushort *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nusv(index, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4Nuiv(GLuint index, const GLuint *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nuiv(index, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4Nubv(GLuint index, const GLubyte *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nubv(index, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
-{
-    d_2_0_Core->f.VertexAttrib4Nub(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4Nsv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nsv(index, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4Niv(GLuint index, const GLint *v)
-{
-    d_2_0_Core->f.VertexAttrib4Niv(index, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4Nbv(GLuint index, const GLbyte *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nbv(index, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib3sv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib3sv(index, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
-{
-    d_2_0_Core->f.VertexAttrib3s(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib3fv(GLuint index, const GLfloat *v)
-{
-    d_2_0_Core->f.VertexAttrib3fv(index, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
-{
-    d_2_0_Core->f.VertexAttrib3f(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib3dv(GLuint index, const GLdouble *v)
-{
-    d_2_0_Core->f.VertexAttrib3dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
-{
-    d_2_0_Core->f.VertexAttrib3d(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib2sv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib2sv(index, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib2s(GLuint index, GLshort x, GLshort y)
-{
-    d_2_0_Core->f.VertexAttrib2s(index, x, y);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib2fv(GLuint index, const GLfloat *v)
-{
-    d_2_0_Core->f.VertexAttrib2fv(index, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
-{
-    d_2_0_Core->f.VertexAttrib2f(index, x, y);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib2dv(GLuint index, const GLdouble *v)
-{
-    d_2_0_Core->f.VertexAttrib2dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
-{
-    d_2_0_Core->f.VertexAttrib2d(index, x, y);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib1sv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib1sv(index, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib1s(GLuint index, GLshort x)
-{
-    d_2_0_Core->f.VertexAttrib1s(index, x);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib1fv(GLuint index, const GLfloat *v)
-{
-    d_2_0_Core->f.VertexAttrib1fv(index, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib1f(GLuint index, GLfloat x)
-{
-    d_2_0_Core->f.VertexAttrib1f(index, x);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib1dv(GLuint index, const GLdouble *v)
-{
-    d_2_0_Core->f.VertexAttrib1dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib1d(GLuint index, GLdouble x)
-{
-    d_2_0_Core->f.VertexAttrib1d(index, x);
-}
-
-
-// OpenGL 2.1 deprecated functions
-
-// OpenGL 3.0 deprecated functions
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI4usv(GLuint index, const GLushort *v)
-{
-    d_3_0_Core->f.VertexAttribI4usv(index, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI4ubv(GLuint index, const GLubyte *v)
-{
-    d_3_0_Core->f.VertexAttribI4ubv(index, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI4sv(GLuint index, const GLshort *v)
-{
-    d_3_0_Core->f.VertexAttribI4sv(index, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI4bv(GLuint index, const GLbyte *v)
-{
-    d_3_0_Core->f.VertexAttribI4bv(index, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI4uiv(GLuint index, const GLuint *v)
-{
-    d_3_0_Core->f.VertexAttribI4uiv(index, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI3uiv(GLuint index, const GLuint *v)
-{
-    d_3_0_Core->f.VertexAttribI3uiv(index, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI2uiv(GLuint index, const GLuint *v)
-{
-    d_3_0_Core->f.VertexAttribI2uiv(index, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI1uiv(GLuint index, const GLuint *v)
-{
-    d_3_0_Core->f.VertexAttribI1uiv(index, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI4iv(GLuint index, const GLint *v)
-{
-    d_3_0_Core->f.VertexAttribI4iv(index, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI3iv(GLuint index, const GLint *v)
-{
-    d_3_0_Core->f.VertexAttribI3iv(index, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI2iv(GLuint index, const GLint *v)
-{
-    d_3_0_Core->f.VertexAttribI2iv(index, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI1iv(GLuint index, const GLint *v)
-{
-    d_3_0_Core->f.VertexAttribI1iv(index, v);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
-{
-    d_3_0_Core->f.VertexAttribI4ui(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z)
-{
-    d_3_0_Core->f.VertexAttribI3ui(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI2ui(GLuint index, GLuint x, GLuint y)
-{
-    d_3_0_Core->f.VertexAttribI2ui(index, x, y);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI1ui(GLuint index, GLuint x)
-{
-    d_3_0_Core->f.VertexAttribI1ui(index, x);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
-{
-    d_3_0_Core->f.VertexAttribI4i(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI3i(GLuint index, GLint x, GLint y, GLint z)
-{
-    d_3_0_Core->f.VertexAttribI3i(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI2i(GLuint index, GLint x, GLint y)
-{
-    d_3_0_Core->f.VertexAttribI2i(index, x, y);
-}
-
-inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI1i(GLuint index, GLint x)
-{
-    d_3_0_Core->f.VertexAttribI1i(index, x);
-}
-
-
-// OpenGL 3.1 deprecated functions
-
-// OpenGL 3.2 deprecated functions
-
-// OpenGL 3.3 deprecated functions
-
-// OpenGL 4.0 deprecated functions
-
-// OpenGL 4.1 deprecated functions
-
-// OpenGL 4.2 deprecated functions
-
-// OpenGL 4.3 deprecated functions
-
-
-QT_END_NAMESPACE
-
-#ifdef Q_OS_WIN
-#pragma pop_macro("MemoryBarrier")
-#endif
-
-#endif // QT_NO_OPENGL && !QT_OPENGL_ES_2
-
-#endif
diff --git a/src/gui/opengl/qopenglfunctions_4_3_core.cpp b/src/gui/opengl/qopenglfunctions_4_3_core.cpp
deleted file mode 100644
index 8a867471b8..0000000000
--- a/src/gui/opengl/qopenglfunctions_4_3_core.cpp
+++ /dev/null
@@ -1,260 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#include "qopenglfunctions_4_3_core.h"
-#include "qopenglcontext.h"
-
-QT_BEGIN_NAMESPACE
-
-/*!
-    \class QOpenGLFunctions_4_3_Core
-    \inmodule QtGui
-    \since 5.1
-    \wrapper
-    \brief The QOpenGLFunctions_4_3_Core class provides all functions for OpenGL 4.3 core profile.
-
-    This class is a wrapper for functions from OpenGL 4.3 core profile.
-    See reference pages on \l {http://www.opengl.org/sdk/docs/}{opengl.org}
-    for function documentation.
-
-    \sa QAbstractOpenGLFunctions
-*/
-
-QOpenGLFunctions_4_3_Core::QOpenGLFunctions_4_3_Core()
- : QAbstractOpenGLFunctions()
- , d_1_0_Core(nullptr)
- , d_1_1_Core(nullptr)
- , d_1_2_Core(nullptr)
- , d_1_3_Core(nullptr)
- , d_1_4_Core(nullptr)
- , d_1_5_Core(nullptr)
- , d_2_0_Core(nullptr)
- , d_2_1_Core(nullptr)
- , d_3_0_Core(nullptr)
- , d_3_1_Core(nullptr)
- , d_3_2_Core(nullptr)
- , d_3_3_Core(nullptr)
- , d_4_0_Core(nullptr)
- , d_4_1_Core(nullptr)
- , d_4_2_Core(nullptr)
- , d_4_3_Core(nullptr)
-{
-}
-
-QOpenGLFunctions_4_3_Core::~QOpenGLFunctions_4_3_Core()
-{
-    if (d_1_0_Core) {
-        d_1_0_Core->refs.deref();
-        Q_ASSERT(d_1_0_Core->refs.loadRelaxed());
-    }
-    if (d_1_1_Core) {
-        d_1_1_Core->refs.deref();
-        Q_ASSERT(d_1_1_Core->refs.loadRelaxed());
-    }
-    if (d_1_2_Core) {
-        d_1_2_Core->refs.deref();
-        Q_ASSERT(d_1_2_Core->refs.loadRelaxed());
-    }
-    if (d_1_3_Core) {
-        d_1_3_Core->refs.deref();
-        Q_ASSERT(d_1_3_Core->refs.loadRelaxed());
-    }
-    if (d_1_4_Core) {
-        d_1_4_Core->refs.deref();
-        Q_ASSERT(d_1_4_Core->refs.loadRelaxed());
-    }
-    if (d_1_5_Core) {
-        d_1_5_Core->refs.deref();
-        Q_ASSERT(d_1_5_Core->refs.loadRelaxed());
-    }
-    if (d_2_0_Core) {
-        d_2_0_Core->refs.deref();
-        Q_ASSERT(d_2_0_Core->refs.loadRelaxed());
-    }
-    if (d_2_1_Core) {
-        d_2_1_Core->refs.deref();
-        Q_ASSERT(d_2_1_Core->refs.loadRelaxed());
-    }
-    if (d_3_0_Core) {
-        d_3_0_Core->refs.deref();
-        Q_ASSERT(d_3_0_Core->refs.loadRelaxed());
-    }
-    if (d_3_1_Core) {
-        d_3_1_Core->refs.deref();
-        Q_ASSERT(d_3_1_Core->refs.loadRelaxed());
-    }
-    if (d_3_2_Core) {
-        d_3_2_Core->refs.deref();
-        Q_ASSERT(d_3_2_Core->refs.loadRelaxed());
-    }
-    if (d_3_3_Core) {
-        d_3_3_Core->refs.deref();
-        Q_ASSERT(d_3_3_Core->refs.loadRelaxed());
-    }
-    if (d_4_0_Core) {
-        d_4_0_Core->refs.deref();
-        Q_ASSERT(d_4_0_Core->refs.loadRelaxed());
-    }
-    if (d_4_1_Core) {
-        d_4_1_Core->refs.deref();
-        Q_ASSERT(d_4_1_Core->refs.loadRelaxed());
-    }
-    if (d_4_2_Core) {
-        d_4_2_Core->refs.deref();
-        Q_ASSERT(d_4_2_Core->refs.loadRelaxed());
-    }
-    if (d_4_3_Core) {
-        d_4_3_Core->refs.deref();
-        Q_ASSERT(d_4_3_Core->refs.loadRelaxed());
-    }
-}
-
-bool QOpenGLFunctions_4_3_Core::initializeOpenGLFunctions()
-{
-    if ( isInitialized() )
-        return true;
-
-    QOpenGLContext* context = QOpenGLContext::currentContext();
-
-    // If owned by a context object make sure it is current.
-    // Also check that current context is capable of resolving all needed functions
-    if (((owningContext() && owningContext() == context) || !owningContext())
-        && QOpenGLFunctions_4_3_Core::isContextCompatible(context))
-    {
-        // Associate with private implementation, creating if necessary
-        // Function pointers in the backends are resolved at creation time
-        QOpenGLVersionFunctionsBackend* d = nullptr;
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        d_1_3_Core = static_cast<QOpenGLFunctions_1_3_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        d_1_4_Core = static_cast<QOpenGLFunctions_1_4_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        d_1_5_Core = static_cast<QOpenGLFunctions_1_5_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        d_2_0_Core = static_cast<QOpenGLFunctions_2_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        d_2_1_Core = static_cast<QOpenGLFunctions_2_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        d_3_0_Core = static_cast<QOpenGLFunctions_3_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
-        d_3_1_Core = static_cast<QOpenGLFunctions_3_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
-        d_3_2_Core = static_cast<QOpenGLFunctions_3_2_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_CoreBackend::versionStatus());
-        d_3_3_Core = static_cast<QOpenGLFunctions_3_3_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_0_CoreBackend::versionStatus());
-        d_4_0_Core = static_cast<QOpenGLFunctions_4_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_1_CoreBackend::versionStatus());
-        d_4_1_Core = static_cast<QOpenGLFunctions_4_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_2_CoreBackend::versionStatus());
-        d_4_2_Core = static_cast<QOpenGLFunctions_4_2_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_3_CoreBackend::versionStatus());
-        d_4_3_Core = static_cast<QOpenGLFunctions_4_3_CoreBackend*>(d);
-        d->refs.ref();
-
-        QAbstractOpenGLFunctions::initializeOpenGLFunctions();
-    }
-    return isInitialized();
-}
-
-bool QOpenGLFunctions_4_3_Core::isContextCompatible(QOpenGLContext *context)
-{
-    Q_ASSERT(context);
-    QSurfaceFormat f = context->format();
-    const QPair<int, int> v = qMakePair(f.majorVersion(), f.minorVersion());
-    if (v < qMakePair(4, 3))
-        return false;
-
-    return true;
-}
-
-QOpenGLVersionProfile QOpenGLFunctions_4_3_Core::versionProfile()
-{
-    QOpenGLVersionProfile v;
-    v.setVersion(4, 3);
-    v.setProfile(QSurfaceFormat::CoreProfile);
-    return v;
-}
-
-QT_END_NAMESPACE
diff --git a/src/gui/opengl/qopenglfunctions_4_3_core.h b/src/gui/opengl/qopenglfunctions_4_3_core.h
deleted file mode 100644
index 13675caf62..0000000000
--- a/src/gui/opengl/qopenglfunctions_4_3_core.h
+++ /dev/null
@@ -1,3246 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#ifndef QOPENGLVERSIONFUNCTIONS_4_3_CORE_H
-#define QOPENGLVERSIONFUNCTIONS_4_3_CORE_H
-
-#include <QtGui/qtguiglobal.h>
-
-#if !defined(QT_NO_OPENGL) && !defined(QT_OPENGL_ES_2)
-
-#include <QtGui/QOpenGLVersionFunctions>
-#include <QtGui/qopenglcontext.h>
-
-// MemoryBarrier is a macro on some architectures on Windows
-#ifdef Q_OS_WIN
-#pragma push_macro("MemoryBarrier")
-#undef MemoryBarrier
-#endif
-
-
-QT_BEGIN_NAMESPACE
-
-class Q_GUI_EXPORT QOpenGLFunctions_4_3_Core : public QAbstractOpenGLFunctions
-{
-public:
-    QOpenGLFunctions_4_3_Core();
-    ~QOpenGLFunctions_4_3_Core();
-
-    bool initializeOpenGLFunctions() override;
-
-    // OpenGL 1.0 core functions
-    void glViewport(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glDepthRange(GLdouble nearVal, GLdouble farVal);
-    GLboolean glIsEnabled(GLenum cap);
-    void glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params);
-    void glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params);
-    void glGetTexParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
-    const GLubyte * glGetString(GLenum name);
-    void glGetIntegerv(GLenum pname, GLint *params);
-    void glGetFloatv(GLenum pname, GLfloat *params);
-    GLenum glGetError();
-    void glGetDoublev(GLenum pname, GLdouble *params);
-    void glGetBooleanv(GLenum pname, GLboolean *params);
-    void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
-    void glReadBuffer(GLenum mode);
-    void glPixelStorei(GLenum pname, GLint param);
-    void glPixelStoref(GLenum pname, GLfloat param);
-    void glDepthFunc(GLenum func);
-    void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass);
-    void glStencilFunc(GLenum func, GLint ref, GLuint mask);
-    void glLogicOp(GLenum opcode);
-    void glBlendFunc(GLenum sfactor, GLenum dfactor);
-    void glFlush();
-    void glFinish();
-    void glEnable(GLenum cap);
-    void glDisable(GLenum cap);
-    void glDepthMask(GLboolean flag);
-    void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
-    void glStencilMask(GLuint mask);
-    void glClearDepth(GLdouble depth);
-    void glClearStencil(GLint s);
-    void glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glClear(GLbitfield mask);
-    void glDrawBuffer(GLenum mode);
-    void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glTexParameteri(GLenum target, GLenum pname, GLint param);
-    void glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glTexParameterf(GLenum target, GLenum pname, GLfloat param);
-    void glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glPolygonMode(GLenum face, GLenum mode);
-    void glPointSize(GLfloat size);
-    void glLineWidth(GLfloat width);
-    void glHint(GLenum target, GLenum mode);
-    void glFrontFace(GLenum mode);
-    void glCullFace(GLenum mode);
-
-    // OpenGL 1.1 core functions
-    void glIndexubv(const GLubyte *c);
-    void glIndexub(GLubyte c);
-    GLboolean glIsTexture(GLuint texture);
-    void glGenTextures(GLsizei n, GLuint *textures);
-    void glDeleteTextures(GLsizei n, const GLuint *textures);
-    void glBindTexture(GLenum target, GLuint texture);
-    void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
-    void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
-    void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
-    void glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
-    void glPolygonOffset(GLfloat factor, GLfloat units);
-    void glGetPointerv(GLenum pname, GLvoid* *params);
-    void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
-    void glDrawArrays(GLenum mode, GLint first, GLsizei count);
-
-    // OpenGL 1.2 core functions
-    void glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
-    void glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices);
-    void glBlendEquation(GLenum mode);
-    void glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-
-    // OpenGL 1.3 core functions
-    void glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img);
-    void glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data);
-    void glSampleCoverage(GLfloat value, GLboolean invert);
-    void glActiveTexture(GLenum texture);
-
-    // OpenGL 1.4 core functions
-    void glPointParameteriv(GLenum pname, const GLint *params);
-    void glPointParameteri(GLenum pname, GLint param);
-    void glPointParameterfv(GLenum pname, const GLfloat *params);
-    void glPointParameterf(GLenum pname, GLfloat param);
-    void glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount);
-    void glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount);
-    void glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
-
-    // OpenGL 1.5 core functions
-    void glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params);
-    void glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params);
-    GLboolean glUnmapBuffer(GLenum target);
-    GLvoid* glMapBuffer(GLenum target, GLenum access);
-    void glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data);
-    void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data);
-    void glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage);
-    GLboolean glIsBuffer(GLuint buffer);
-    void glGenBuffers(GLsizei n, GLuint *buffers);
-    void glDeleteBuffers(GLsizei n, const GLuint *buffers);
-    void glBindBuffer(GLenum target, GLuint buffer);
-    void glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params);
-    void glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params);
-    void glGetQueryiv(GLenum target, GLenum pname, GLint *params);
-    void glEndQuery(GLenum target);
-    void glBeginQuery(GLenum target, GLuint id);
-    GLboolean glIsQuery(GLuint id);
-    void glDeleteQueries(GLsizei n, const GLuint *ids);
-    void glGenQueries(GLsizei n, GLuint *ids);
-
-    // OpenGL 2.0 core functions
-    void glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer);
-    void glValidateProgram(GLuint program);
-    void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniform4iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform3iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform2iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform1iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform4fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform3fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform2fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform1fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
-    void glUniform3i(GLint location, GLint v0, GLint v1, GLint v2);
-    void glUniform2i(GLint location, GLint v0, GLint v1);
-    void glUniform1i(GLint location, GLint v0);
-    void glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
-    void glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
-    void glUniform2f(GLint location, GLfloat v0, GLfloat v1);
-    void glUniform1f(GLint location, GLfloat v0);
-    void glUseProgram(GLuint program);
-    void glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length);
-    void glLinkProgram(GLuint program);
-    GLboolean glIsShader(GLuint shader);
-    GLboolean glIsProgram(GLuint program);
-    void glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer);
-    void glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params);
-    void glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params);
-    void glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params);
-    void glGetUniformiv(GLuint program, GLint location, GLint *params);
-    void glGetUniformfv(GLuint program, GLint location, GLfloat *params);
-    GLint glGetUniformLocation(GLuint program, const GLchar *name);
-    void glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source);
-    void glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void glGetShaderiv(GLuint shader, GLenum pname, GLint *params);
-    void glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void glGetProgramiv(GLuint program, GLenum pname, GLint *params);
-    GLint glGetAttribLocation(GLuint program, const GLchar *name);
-    void glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj);
-    void glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
-    void glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
-    void glEnableVertexAttribArray(GLuint index);
-    void glDisableVertexAttribArray(GLuint index);
-    void glDetachShader(GLuint program, GLuint shader);
-    void glDeleteShader(GLuint shader);
-    void glDeleteProgram(GLuint program);
-    GLuint glCreateShader(GLenum type);
-    GLuint glCreateProgram();
-    void glCompileShader(GLuint shader);
-    void glBindAttribLocation(GLuint program, GLuint index, const GLchar *name);
-    void glAttachShader(GLuint program, GLuint shader);
-    void glStencilMaskSeparate(GLenum face, GLuint mask);
-    void glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask);
-    void glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);
-    void glDrawBuffers(GLsizei n, const GLenum *bufs);
-    void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha);
-
-    // OpenGL 2.1 core functions
-    void glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-
-    // OpenGL 3.0 core functions
-    GLboolean glIsVertexArray(GLuint array);
-    void glGenVertexArrays(GLsizei n, GLuint *arrays);
-    void glDeleteVertexArrays(GLsizei n, const GLuint *arrays);
-    void glBindVertexArray(GLuint array);
-    void glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length);
-    GLvoid* glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
-    void glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
-    void glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
-    void glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
-    void glGenerateMipmap(GLenum target);
-    void glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params);
-    void glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
-    void glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset);
-    void glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
-    void glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
-    GLenum glCheckFramebufferStatus(GLenum target);
-    void glGenFramebuffers(GLsizei n, GLuint *framebuffers);
-    void glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers);
-    void glBindFramebuffer(GLenum target, GLuint framebuffer);
-    GLboolean glIsFramebuffer(GLuint framebuffer);
-    void glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
-    void glGenRenderbuffers(GLsizei n, GLuint *renderbuffers);
-    void glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers);
-    void glBindRenderbuffer(GLenum target, GLuint renderbuffer);
-    GLboolean glIsRenderbuffer(GLuint renderbuffer);
-    const GLubyte * glGetStringi(GLenum name, GLuint index);
-    void glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
-    void glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value);
-    void glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value);
-    void glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value);
-    void glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params);
-    void glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params);
-    void glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params);
-    void glTexParameterIiv(GLenum target, GLenum pname, const GLint *params);
-    void glUniform4uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform3uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform2uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform1uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
-    void glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2);
-    void glUniform2ui(GLint location, GLuint v0, GLuint v1);
-    void glUniform1ui(GLint location, GLuint v0);
-    GLint glGetFragDataLocation(GLuint program, const GLchar *name);
-    void glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name);
-    void glGetUniformuiv(GLuint program, GLint location, GLuint *params);
-    void glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params);
-    void glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params);
-    void glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glEndConditionalRender();
-    void glBeginConditionalRender(GLuint id, GLenum mode);
-    void glClampColor(GLenum target, GLenum clamp);
-    void glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name);
-    void glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode);
-    void glBindBufferBase(GLenum target, GLuint index, GLuint buffer);
-    void glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
-    void glEndTransformFeedback();
-    void glBeginTransformFeedback(GLenum primitiveMode);
-    GLboolean glIsEnabledi(GLenum target, GLuint index);
-    void glDisablei(GLenum target, GLuint index);
-    void glEnablei(GLenum target, GLuint index);
-    void glGetIntegeri_v(GLenum target, GLuint index, GLint *data);
-    void glGetBooleani_v(GLenum target, GLuint index, GLboolean *data);
-    void glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a);
-
-    // OpenGL 3.1 core functions
-    void glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
-    void glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);
-    void glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName);
-    void glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params);
-    GLuint glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName);
-    void glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName);
-    void glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params);
-    void glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const *uniformNames, GLuint *uniformIndices);
-    void glPrimitiveRestartIndex(GLuint index);
-    void glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer);
-    void glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount);
-    void glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount);
-
-    // OpenGL 3.2 core functions
-    void glSampleMaski(GLuint index, GLbitfield mask);
-    void glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val);
-    void glTexImage3DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
-    void glTexImage2DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
-    void glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values);
-    void glGetInteger64v(GLenum pname, GLint64 *params);
-    void glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout);
-    GLenum glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout);
-    void glDeleteSync(GLsync sync);
-    GLboolean glIsSync(GLsync sync);
-    GLsync glFenceSync(GLenum condition, GLbitfield flags);
-    void glProvokingVertex(GLenum mode);
-    void glMultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount, const GLint *basevertex);
-    void glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount, GLint basevertex);
-    void glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex);
-    void glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex);
-    void glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level);
-    void glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params);
-    void glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data);
-
-    // OpenGL 3.3 core functions
-    void glVertexAttribP4uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glVertexAttribP3uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glVertexAttribP2uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glVertexAttribP1uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glSecondaryColorP3uiv(GLenum type, const GLuint *color);
-    void glSecondaryColorP3ui(GLenum type, GLuint color);
-    void glColorP4uiv(GLenum type, const GLuint *color);
-    void glColorP4ui(GLenum type, GLuint color);
-    void glColorP3uiv(GLenum type, const GLuint *color);
-    void glColorP3ui(GLenum type, GLuint color);
-    void glNormalP3uiv(GLenum type, const GLuint *coords);
-    void glNormalP3ui(GLenum type, GLuint coords);
-    void glMultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint *coords);
-    void glMultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords);
-    void glMultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint *coords);
-    void glMultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords);
-    void glMultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint *coords);
-    void glMultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords);
-    void glMultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint *coords);
-    void glMultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords);
-    void glTexCoordP4uiv(GLenum type, const GLuint *coords);
-    void glTexCoordP4ui(GLenum type, GLuint coords);
-    void glTexCoordP3uiv(GLenum type, const GLuint *coords);
-    void glTexCoordP3ui(GLenum type, GLuint coords);
-    void glTexCoordP2uiv(GLenum type, const GLuint *coords);
-    void glTexCoordP2ui(GLenum type, GLuint coords);
-    void glTexCoordP1uiv(GLenum type, const GLuint *coords);
-    void glTexCoordP1ui(GLenum type, GLuint coords);
-    void glVertexP4uiv(GLenum type, const GLuint *value);
-    void glVertexP4ui(GLenum type, GLuint value);
-    void glVertexP3uiv(GLenum type, const GLuint *value);
-    void glVertexP3ui(GLenum type, GLuint value);
-    void glVertexP2uiv(GLenum type, const GLuint *value);
-    void glVertexP2ui(GLenum type, GLuint value);
-    void glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params);
-    void glGetQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params);
-    void glQueryCounter(GLuint id, GLenum target);
-    void glGetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params);
-    void glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params);
-    void glGetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params);
-    void glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params);
-    void glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param);
-    void glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param);
-    void glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param);
-    void glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param);
-    void glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param);
-    void glSamplerParameteri(GLuint sampler, GLenum pname, GLint param);
-    void glBindSampler(GLuint unit, GLuint sampler);
-    GLboolean glIsSampler(GLuint sampler);
-    void glDeleteSamplers(GLsizei count, const GLuint *samplers);
-    void glGenSamplers(GLsizei count, GLuint *samplers);
-    GLint glGetFragDataIndex(GLuint program, const GLchar *name);
-    void glBindFragDataLocationIndexed(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name);
-    void glVertexAttribDivisor(GLuint index, GLuint divisor);
-
-    // OpenGL 4.0 core functions
-    void glGetQueryIndexediv(GLenum target, GLuint index, GLenum pname, GLint *params);
-    void glEndQueryIndexed(GLenum target, GLuint index);
-    void glBeginQueryIndexed(GLenum target, GLuint index, GLuint id);
-    void glDrawTransformFeedbackStream(GLenum mode, GLuint id, GLuint stream);
-    void glDrawTransformFeedback(GLenum mode, GLuint id);
-    void glResumeTransformFeedback();
-    void glPauseTransformFeedback();
-    GLboolean glIsTransformFeedback(GLuint id);
-    void glGenTransformFeedbacks(GLsizei n, GLuint *ids);
-    void glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids);
-    void glBindTransformFeedback(GLenum target, GLuint id);
-    void glPatchParameterfv(GLenum pname, const GLfloat *values);
-    void glPatchParameteri(GLenum pname, GLint value);
-    void glGetProgramStageiv(GLuint program, GLenum shadertype, GLenum pname, GLint *values);
-    void glGetUniformSubroutineuiv(GLenum shadertype, GLint location, GLuint *params);
-    void glUniformSubroutinesuiv(GLenum shadertype, GLsizei count, const GLuint *indices);
-    void glGetActiveSubroutineName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name);
-    void glGetActiveSubroutineUniformName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name);
-    void glGetActiveSubroutineUniformiv(GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values);
-    GLuint glGetSubroutineIndex(GLuint program, GLenum shadertype, const GLchar *name);
-    GLint glGetSubroutineUniformLocation(GLuint program, GLenum shadertype, const GLchar *name);
-    void glGetUniformdv(GLuint program, GLint location, GLdouble *params);
-    void glUniformMatrix4x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix4x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix3x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix3x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix2x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix2x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniform4dv(GLint location, GLsizei count, const GLdouble *value);
-    void glUniform3dv(GLint location, GLsizei count, const GLdouble *value);
-    void glUniform2dv(GLint location, GLsizei count, const GLdouble *value);
-    void glUniform1dv(GLint location, GLsizei count, const GLdouble *value);
-    void glUniform4d(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glUniform3d(GLint location, GLdouble x, GLdouble y, GLdouble z);
-    void glUniform2d(GLint location, GLdouble x, GLdouble y);
-    void glUniform1d(GLint location, GLdouble x);
-    void glDrawElementsIndirect(GLenum mode, GLenum type, const GLvoid *indirect);
-    void glDrawArraysIndirect(GLenum mode, const GLvoid *indirect);
-    void glBlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
-    void glBlendFunci(GLuint buf, GLenum src, GLenum dst);
-    void glBlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha);
-    void glBlendEquationi(GLuint buf, GLenum mode);
-    void glMinSampleShading(GLfloat value);
-
-    // OpenGL 4.1 core functions
-    void glGetDoublei_v(GLenum target, GLuint index, GLdouble *data);
-    void glGetFloati_v(GLenum target, GLuint index, GLfloat *data);
-    void glDepthRangeIndexed(GLuint index, GLdouble n, GLdouble f);
-    void glDepthRangeArrayv(GLuint first, GLsizei count, const GLdouble *v);
-    void glScissorIndexedv(GLuint index, const GLint *v);
-    void glScissorIndexed(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height);
-    void glScissorArrayv(GLuint first, GLsizei count, const GLint *v);
-    void glViewportIndexedfv(GLuint index, const GLfloat *v);
-    void glViewportIndexedf(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h);
-    void glViewportArrayv(GLuint first, GLsizei count, const GLfloat *v);
-    void glGetVertexAttribLdv(GLuint index, GLenum pname, GLdouble *params);
-    void glVertexAttribLPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void glVertexAttribL4dv(GLuint index, const GLdouble *v);
-    void glVertexAttribL3dv(GLuint index, const GLdouble *v);
-    void glVertexAttribL2dv(GLuint index, const GLdouble *v);
-    void glVertexAttribL1dv(GLuint index, const GLdouble *v);
-    void glVertexAttribL4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glVertexAttribL3d(GLuint index, GLdouble x, GLdouble y, GLdouble z);
-    void glVertexAttribL2d(GLuint index, GLdouble x, GLdouble y);
-    void glVertexAttribL1d(GLuint index, GLdouble x);
-    void glGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void glValidateProgramPipeline(GLuint pipeline);
-    void glProgramUniformMatrix4x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix3x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix4x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix2x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix3x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix2x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix4x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix3x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix4x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix2x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix3x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix2x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniform4uiv(GLuint program, GLint location, GLsizei count, const GLuint *value);
-    void glProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
-    void glProgramUniform4dv(GLuint program, GLint location, GLsizei count, const GLdouble *value);
-    void glProgramUniform4d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3);
-    void glProgramUniform4fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-    void glProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
-    void glProgramUniform4iv(GLuint program, GLint location, GLsizei count, const GLint *value);
-    void glProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
-    void glProgramUniform3uiv(GLuint program, GLint location, GLsizei count, const GLuint *value);
-    void glProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2);
-    void glProgramUniform3dv(GLuint program, GLint location, GLsizei count, const GLdouble *value);
-    void glProgramUniform3d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2);
-    void glProgramUniform3fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-    void glProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
-    void glProgramUniform3iv(GLuint program, GLint location, GLsizei count, const GLint *value);
-    void glProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2);
-    void glProgramUniform2uiv(GLuint program, GLint location, GLsizei count, const GLuint *value);
-    void glProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1);
-    void glProgramUniform2dv(GLuint program, GLint location, GLsizei count, const GLdouble *value);
-    void glProgramUniform2d(GLuint program, GLint location, GLdouble v0, GLdouble v1);
-    void glProgramUniform2fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-    void glProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1);
-    void glProgramUniform2iv(GLuint program, GLint location, GLsizei count, const GLint *value);
-    void glProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1);
-    void glProgramUniform1uiv(GLuint program, GLint location, GLsizei count, const GLuint *value);
-    void glProgramUniform1ui(GLuint program, GLint location, GLuint v0);
-    void glProgramUniform1dv(GLuint program, GLint location, GLsizei count, const GLdouble *value);
-    void glProgramUniform1d(GLuint program, GLint location, GLdouble v0);
-    void glProgramUniform1fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-    void glProgramUniform1f(GLuint program, GLint location, GLfloat v0);
-    void glProgramUniform1iv(GLuint program, GLint location, GLsizei count, const GLint *value);
-    void glProgramUniform1i(GLuint program, GLint location, GLint v0);
-    void glGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params);
-    GLboolean glIsProgramPipeline(GLuint pipeline);
-    void glGenProgramPipelines(GLsizei n, GLuint *pipelines);
-    void glDeleteProgramPipelines(GLsizei n, const GLuint *pipelines);
-    void glBindProgramPipeline(GLuint pipeline);
-    GLuint glCreateShaderProgramv(GLenum type, GLsizei count, const GLchar* const *strings);
-    void glActiveShaderProgram(GLuint pipeline, GLuint program);
-    void glUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program);
-    void glProgramParameteri(GLuint program, GLenum pname, GLint value);
-    void glProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid *binary, GLsizei length);
-    void glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, GLvoid *binary);
-    void glClearDepthf(GLfloat dd);
-    void glDepthRangef(GLfloat n, GLfloat f);
-    void glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision);
-    void glShaderBinary(GLsizei count, const GLuint *shaders, GLenum binaryformat, const GLvoid *binary, GLsizei length);
-    void glReleaseShaderCompiler();
-
-    // OpenGL 4.2 core functions
-    void glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
-    void glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);
-    void glTexStorage1D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width);
-    void glMemoryBarrier(GLbitfield barriers);
-    void glBindImageTexture(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format);
-    void glGetActiveAtomicCounterBufferiv(GLuint program, GLuint bufferIndex, GLenum pname, GLint *params);
-    void glGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params);
-    void glDrawTransformFeedbackStreamInstanced(GLenum mode, GLuint id, GLuint stream, GLsizei instancecount);
-    void glDrawTransformFeedbackInstanced(GLenum mode, GLuint id, GLsizei instancecount);
-    void glDrawElementsInstancedBaseVertexBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance);
-    void glDrawElementsInstancedBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLuint baseinstance);
-    void glDrawArraysInstancedBaseInstance(GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance);
-
-    // OpenGL 4.3 core functions
-    void glTexStorage3DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
-    void glTexStorage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
-    void glTexBufferRange(GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size);
-    void glShaderStorageBlockBinding(GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding);
-    GLint glGetProgramResourceLocationIndex(GLuint program, GLenum programInterface, const GLchar *name);
-    GLint glGetProgramResourceLocation(GLuint program, GLenum programInterface, const GLchar *name);
-    void glGetProgramResourceiv(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params);
-    void glGetProgramResourceName(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name);
-    GLuint glGetProgramResourceIndex(GLuint program, GLenum programInterface, const GLchar *name);
-    void glGetProgramInterfaceiv(GLuint program, GLenum programInterface, GLenum pname, GLint *params);
-    void glMultiDrawElementsIndirect(GLenum mode, GLenum type, const void *indirect, GLsizei drawcount, GLsizei stride);
-    void glMultiDrawArraysIndirect(GLenum mode, const void *indirect, GLsizei drawcount, GLsizei stride);
-    void glInvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glInvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments);
-    void glInvalidateBufferData(GLuint buffer);
-    void glInvalidateBufferSubData(GLuint buffer, GLintptr offset, GLsizeiptr length);
-    void glInvalidateTexImage(GLuint texture, GLint level);
-    void glInvalidateTexSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth);
-    void glGetInternalformati64v(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint64 *params);
-    void glGetFramebufferParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glFramebufferParameteri(GLenum target, GLenum pname, GLint param);
-    void glVertexBindingDivisor(GLuint bindingindex, GLuint divisor);
-    void glVertexAttribBinding(GLuint attribindex, GLuint bindingindex);
-    void glVertexAttribLFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);
-    void glVertexAttribIFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);
-    void glVertexAttribFormat(GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset);
-    void glBindVertexBuffer(GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride);
-    void glTextureView(GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers);
-    void glCopyImageSubData(GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth);
-    void glDispatchComputeIndirect(GLintptr indirect);
-    void glDispatchCompute(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z);
-    void glClearBufferSubData(GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data);
-    void glClearBufferData(GLenum target, GLenum internalformat, GLenum format, GLenum type, const void *data);
-
-private:
-    friend class QOpenGLContext;
-
-    static bool isContextCompatible(QOpenGLContext *context);
-    static QOpenGLVersionProfile versionProfile();
-
-    QOpenGLFunctions_1_0_CoreBackend* d_1_0_Core;
-    QOpenGLFunctions_1_1_CoreBackend* d_1_1_Core;
-    QOpenGLFunctions_1_2_CoreBackend* d_1_2_Core;
-    QOpenGLFunctions_1_3_CoreBackend* d_1_3_Core;
-    QOpenGLFunctions_1_4_CoreBackend* d_1_4_Core;
-    QOpenGLFunctions_1_5_CoreBackend* d_1_5_Core;
-    QOpenGLFunctions_2_0_CoreBackend* d_2_0_Core;
-    QOpenGLFunctions_2_1_CoreBackend* d_2_1_Core;
-    QOpenGLFunctions_3_0_CoreBackend* d_3_0_Core;
-    QOpenGLFunctions_3_1_CoreBackend* d_3_1_Core;
-    QOpenGLFunctions_3_2_CoreBackend* d_3_2_Core;
-    QOpenGLFunctions_3_3_CoreBackend* d_3_3_Core;
-    QOpenGLFunctions_4_0_CoreBackend* d_4_0_Core;
-    QOpenGLFunctions_4_1_CoreBackend* d_4_1_Core;
-    QOpenGLFunctions_4_2_CoreBackend* d_4_2_Core;
-    QOpenGLFunctions_4_3_CoreBackend* d_4_3_Core;
-};
-
-// OpenGL 1.0 core functions
-inline void QOpenGLFunctions_4_3_Core::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_0_Core->f.Viewport(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glDepthRange(GLdouble nearVal, GLdouble farVal)
-{
-    d_1_0_Core->f.DepthRange(nearVal, farVal);
-}
-
-inline GLboolean QOpenGLFunctions_4_3_Core::glIsEnabled(GLenum cap)
-{
-    return d_1_0_Core->f.IsEnabled(cap);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetTexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetTexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
-{
-    d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
-}
-
-inline const GLubyte * QOpenGLFunctions_4_3_Core::glGetString(GLenum name)
-{
-    return d_1_0_Core->f.GetString(name);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetIntegerv(GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetIntegerv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetFloatv(GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetFloatv(pname, params);
-}
-
-inline GLenum QOpenGLFunctions_4_3_Core::glGetError()
-{
-    return d_1_0_Core->f.GetError();
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetDoublev(GLenum pname, GLdouble *params)
-{
-    d_1_0_Core->f.GetDoublev(pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetBooleanv(GLenum pname, GLboolean *params)
-{
-    d_1_0_Core->f.GetBooleanv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
-{
-    d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glReadBuffer(GLenum mode)
-{
-    d_1_0_Core->f.ReadBuffer(mode);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glPixelStorei(GLenum pname, GLint param)
-{
-    d_1_0_Core->f.PixelStorei(pname, param);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glPixelStoref(GLenum pname, GLfloat param)
-{
-    d_1_0_Core->f.PixelStoref(pname, param);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glDepthFunc(GLenum func)
-{
-    d_1_0_Core->f.DepthFunc(func);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
-{
-    d_1_0_Core->f.StencilOp(fail, zfail, zpass);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glStencilFunc(GLenum func, GLint ref, GLuint mask)
-{
-    d_1_0_Core->f.StencilFunc(func, ref, mask);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glLogicOp(GLenum opcode)
-{
-    d_1_0_Core->f.LogicOp(opcode);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glBlendFunc(GLenum sfactor, GLenum dfactor)
-{
-    d_1_0_Core->f.BlendFunc(sfactor, dfactor);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glFlush()
-{
-    d_1_0_Core->f.Flush();
-}
-
-inline void QOpenGLFunctions_4_3_Core::glFinish()
-{
-    d_1_0_Core->f.Finish();
-}
-
-inline void QOpenGLFunctions_4_3_Core::glEnable(GLenum cap)
-{
-    d_1_0_Core->f.Enable(cap);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glDisable(GLenum cap)
-{
-    d_1_0_Core->f.Disable(cap);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glDepthMask(GLboolean flag)
-{
-    d_1_0_Core->f.DepthMask(flag);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
-{
-    d_1_0_Core->f.ColorMask(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glStencilMask(GLuint mask)
-{
-    d_1_0_Core->f.StencilMask(mask);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glClearDepth(GLdouble depth)
-{
-    d_1_0_Core->f.ClearDepth(depth);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glClearStencil(GLint s)
-{
-    d_1_0_Core->f.ClearStencil(s);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Core->f.ClearColor(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glClear(GLbitfield mask)
-{
-    d_1_0_Core->f.Clear(mask);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glDrawBuffer(GLenum mode)
-{
-    d_1_0_Core->f.DrawBuffer(mode);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Core->f.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_0_Core->f.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_0_Core->f.TexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glTexParameteri(GLenum target, GLenum pname, GLint param)
-{
-    d_1_0_Core->f.TexParameteri(target, pname, param);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Core->f.TexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
-{
-    d_1_0_Core->f.TexParameterf(target, pname, param);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_0_Core->f.Scissor(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glPolygonMode(GLenum face, GLenum mode)
-{
-    d_1_0_Core->f.PolygonMode(face, mode);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glPointSize(GLfloat size)
-{
-    d_1_0_Core->f.PointSize(size);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glLineWidth(GLfloat width)
-{
-    d_1_0_Core->f.LineWidth(width);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glHint(GLenum target, GLenum mode)
-{
-    d_1_0_Core->f.Hint(target, mode);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glFrontFace(GLenum mode)
-{
-    d_1_0_Core->f.FrontFace(mode);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glCullFace(GLenum mode)
-{
-    d_1_0_Core->f.CullFace(mode);
-}
-
-
-// OpenGL 1.1 core functions
-inline void QOpenGLFunctions_4_3_Core::glIndexubv(const GLubyte *c)
-{
-    Q_UNUSED(c);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_3_Core::glIndexub(GLubyte c)
-{
-    Q_UNUSED(c);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline GLboolean QOpenGLFunctions_4_3_Core::glIsTexture(GLuint texture)
-{
-    return d_1_1_Core->f.IsTexture(texture);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGenTextures(GLsizei n, GLuint *textures)
-{
-    d_1_1_Core->f.GenTextures(n, textures);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glDeleteTextures(GLsizei n, const GLuint *textures)
-{
-    d_1_1_Core->f.DeleteTextures(n, textures);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glBindTexture(GLenum target, GLuint texture)
-{
-    d_1_1_Core->f.BindTexture(target, texture);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_1_Core->f.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_1_Core->f.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_1_Core->f.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
-{
-    d_1_1_Core->f.CopyTexSubImage1D(target, level, xoffset, x, y, width);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
-{
-    d_1_1_Core->f.CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
-{
-    d_1_1_Core->f.CopyTexImage1D(target, level, internalformat, x, y, width, border);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glPolygonOffset(GLfloat factor, GLfloat units)
-{
-    d_1_1_Core->f.PolygonOffset(factor, units);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetPointerv(GLenum pname, GLvoid* *params)
-{
-    Q_UNUSED(pname);
-    Q_UNUSED(params);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_3_Core::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
-{
-    d_1_1_Core->f.DrawElements(mode, count, type, indices);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glDrawArrays(GLenum mode, GLint first, GLsizei count)
-{
-    d_1_1_Core->f.DrawArrays(mode, first, count);
-}
-
-
-// OpenGL 1.2 core functions
-inline void QOpenGLFunctions_4_3_Core::glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_2_Core->f.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_2_Core->f.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    d_1_2_Core->f.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
-{
-    d_1_2_Core->f.DrawRangeElements(mode, start, end, count, type, indices);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glBlendEquation(GLenum mode)
-{
-    d_1_2_Core->f.BlendEquation(mode);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_2_Core->f.BlendColor(red, green, blue, alpha);
-}
-
-
-// OpenGL 1.3 core functions
-inline void QOpenGLFunctions_4_3_Core::glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img)
-{
-    d_1_3_Core->f.GetCompressedTexImage(target, level, img);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
-{
-    d_1_3_Core->f.CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glSampleCoverage(GLfloat value, GLboolean invert)
-{
-    d_1_3_Core->f.SampleCoverage(value, invert);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glActiveTexture(GLenum texture)
-{
-    d_1_3_Core->f.ActiveTexture(texture);
-}
-
-
-// OpenGL 1.4 core functions
-inline void QOpenGLFunctions_4_3_Core::glPointParameteriv(GLenum pname, const GLint *params)
-{
-    d_1_4_Core->f.PointParameteriv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glPointParameteri(GLenum pname, GLint param)
-{
-    d_1_4_Core->f.PointParameteri(pname, param);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glPointParameterfv(GLenum pname, const GLfloat *params)
-{
-    d_1_4_Core->f.PointParameterfv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glPointParameterf(GLenum pname, GLfloat param)
-{
-    d_1_4_Core->f.PointParameterf(pname, param);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount)
-{
-    d_1_4_Core->f.MultiDrawElements(mode, count, type, indices, drawcount);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
-{
-    d_1_4_Core->f.MultiDrawArrays(mode, first, count, drawcount);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
-{
-    d_1_4_Core->f.BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
-}
-
-
-// OpenGL 1.5 core functions
-inline void QOpenGLFunctions_4_3_Core::glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params)
-{
-    d_1_5_Core->f.GetBufferPointerv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetBufferParameteriv(target, pname, params);
-}
-
-inline GLboolean QOpenGLFunctions_4_3_Core::glUnmapBuffer(GLenum target)
-{
-    return d_1_5_Core->f.UnmapBuffer(target);
-}
-
-inline GLvoid* QOpenGLFunctions_4_3_Core::glMapBuffer(GLenum target, GLenum access)
-{
-    return d_1_5_Core->f.MapBuffer(target, access);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data)
-{
-    d_1_5_Core->f.GetBufferSubData(target, offset, size, data);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data)
-{
-    d_1_5_Core->f.BufferSubData(target, offset, size, data);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)
-{
-    d_1_5_Core->f.BufferData(target, size, data, usage);
-}
-
-inline GLboolean QOpenGLFunctions_4_3_Core::glIsBuffer(GLuint buffer)
-{
-    return d_1_5_Core->f.IsBuffer(buffer);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGenBuffers(GLsizei n, GLuint *buffers)
-{
-    d_1_5_Core->f.GenBuffers(n, buffers);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glDeleteBuffers(GLsizei n, const GLuint *buffers)
-{
-    d_1_5_Core->f.DeleteBuffers(n, buffers);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glBindBuffer(GLenum target, GLuint buffer)
-{
-    d_1_5_Core->f.BindBuffer(target, buffer);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
-{
-    d_1_5_Core->f.GetQueryObjectuiv(id, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetQueryObjectiv(id, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetQueryiv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetQueryiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glEndQuery(GLenum target)
-{
-    d_1_5_Core->f.EndQuery(target);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glBeginQuery(GLenum target, GLuint id)
-{
-    d_1_5_Core->f.BeginQuery(target, id);
-}
-
-inline GLboolean QOpenGLFunctions_4_3_Core::glIsQuery(GLuint id)
-{
-    return d_1_5_Core->f.IsQuery(id);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glDeleteQueries(GLsizei n, const GLuint *ids)
-{
-    d_1_5_Core->f.DeleteQueries(n, ids);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGenQueries(GLsizei n, GLuint *ids)
-{
-    d_1_5_Core->f.GenQueries(n, ids);
-}
-
-
-// OpenGL 2.0 core functions
-inline void QOpenGLFunctions_4_3_Core::glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer)
-{
-    d_2_0_Core->f.VertexAttribPointer(index, size, type, normalized, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glValidateProgram(GLuint program)
-{
-    d_2_0_Core->f.ValidateProgram(program);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix3fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUniform4iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform4iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUniform3iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform3iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUniform2iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform2iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUniform1iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform1iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUniform4fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform4fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUniform3fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform3fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUniform2fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform2fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUniform1fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform1fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
-{
-    d_2_0_Core->f.Uniform4i(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUniform3i(GLint location, GLint v0, GLint v1, GLint v2)
-{
-    d_2_0_Core->f.Uniform3i(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUniform2i(GLint location, GLint v0, GLint v1)
-{
-    d_2_0_Core->f.Uniform2i(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUniform1i(GLint location, GLint v0)
-{
-    d_2_0_Core->f.Uniform1i(location, v0);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
-{
-    d_2_0_Core->f.Uniform4f(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
-{
-    d_2_0_Core->f.Uniform3f(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUniform2f(GLint location, GLfloat v0, GLfloat v1)
-{
-    d_2_0_Core->f.Uniform2f(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUniform1f(GLint location, GLfloat v0)
-{
-    d_2_0_Core->f.Uniform1f(location, v0);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUseProgram(GLuint program)
-{
-    d_2_0_Core->f.UseProgram(program);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length)
-{
-    d_2_0_Core->f.ShaderSource(shader, count, string, length);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glLinkProgram(GLuint program)
-{
-    d_2_0_Core->f.LinkProgram(program);
-}
-
-inline GLboolean QOpenGLFunctions_4_3_Core::glIsShader(GLuint shader)
-{
-    return d_2_0_Core->f.IsShader(shader);
-}
-
-inline GLboolean QOpenGLFunctions_4_3_Core::glIsProgram(GLuint program)
-{
-    return d_2_0_Core->f.IsProgram(program);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer)
-{
-    d_2_0_Core->f.GetVertexAttribPointerv(index, pname, pointer);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetVertexAttribiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
-{
-    d_2_0_Core->f.GetVertexAttribfv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
-{
-    d_2_0_Core->f.GetVertexAttribdv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetUniformiv(GLuint program, GLint location, GLint *params)
-{
-    d_2_0_Core->f.GetUniformiv(program, location, params);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetUniformfv(GLuint program, GLint location, GLfloat *params)
-{
-    d_2_0_Core->f.GetUniformfv(program, location, params);
-}
-
-inline GLint QOpenGLFunctions_4_3_Core::glGetUniformLocation(GLuint program, const GLchar *name)
-{
-    return d_2_0_Core->f.GetUniformLocation(program, name);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
-{
-    d_2_0_Core->f.GetShaderSource(shader, bufSize, length, source);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-{
-    d_2_0_Core->f.GetShaderInfoLog(shader, bufSize, length, infoLog);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetShaderiv(GLuint shader, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetShaderiv(shader, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-{
-    d_2_0_Core->f.GetProgramInfoLog(program, bufSize, length, infoLog);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetProgramiv(GLuint program, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetProgramiv(program, pname, params);
-}
-
-inline GLint QOpenGLFunctions_4_3_Core::glGetAttribLocation(GLuint program, const GLchar *name)
-{
-    return d_2_0_Core->f.GetAttribLocation(program, name);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj)
-{
-    d_2_0_Core->f.GetAttachedShaders(program, maxCount, count, obj);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
-{
-    d_2_0_Core->f.GetActiveUniform(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
-{
-    d_2_0_Core->f.GetActiveAttrib(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glEnableVertexAttribArray(GLuint index)
-{
-    d_2_0_Core->f.EnableVertexAttribArray(index);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glDisableVertexAttribArray(GLuint index)
-{
-    d_2_0_Core->f.DisableVertexAttribArray(index);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glDetachShader(GLuint program, GLuint shader)
-{
-    d_2_0_Core->f.DetachShader(program, shader);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glDeleteShader(GLuint shader)
-{
-    d_2_0_Core->f.DeleteShader(shader);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glDeleteProgram(GLuint program)
-{
-    d_2_0_Core->f.DeleteProgram(program);
-}
-
-inline GLuint QOpenGLFunctions_4_3_Core::glCreateShader(GLenum type)
-{
-    return d_2_0_Core->f.CreateShader(type);
-}
-
-inline GLuint QOpenGLFunctions_4_3_Core::glCreateProgram()
-{
-    return d_2_0_Core->f.CreateProgram();
-}
-
-inline void QOpenGLFunctions_4_3_Core::glCompileShader(GLuint shader)
-{
-    d_2_0_Core->f.CompileShader(shader);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glBindAttribLocation(GLuint program, GLuint index, const GLchar *name)
-{
-    d_2_0_Core->f.BindAttribLocation(program, index, name);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glAttachShader(GLuint program, GLuint shader)
-{
-    d_2_0_Core->f.AttachShader(program, shader);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glStencilMaskSeparate(GLenum face, GLuint mask)
-{
-    d_2_0_Core->f.StencilMaskSeparate(face, mask);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
-{
-    d_2_0_Core->f.StencilFuncSeparate(face, func, ref, mask);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
-{
-    d_2_0_Core->f.StencilOpSeparate(face, sfail, dpfail, dppass);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glDrawBuffers(GLsizei n, const GLenum *bufs)
-{
-    d_2_0_Core->f.DrawBuffers(n, bufs);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
-{
-    d_2_0_Core->f.BlendEquationSeparate(modeRGB, modeAlpha);
-}
-
-
-// OpenGL 2.1 core functions
-inline void QOpenGLFunctions_4_3_Core::glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix4x3fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix3x4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix4x2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix2x4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix3x2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix2x3fv(location, count, transpose, value);
-}
-
-
-// OpenGL 3.0 core functions
-inline GLboolean QOpenGLFunctions_4_3_Core::glIsVertexArray(GLuint array)
-{
-    return d_3_0_Core->f.IsVertexArray(array);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGenVertexArrays(GLsizei n, GLuint *arrays)
-{
-    d_3_0_Core->f.GenVertexArrays(n, arrays);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glDeleteVertexArrays(GLsizei n, const GLuint *arrays)
-{
-    d_3_0_Core->f.DeleteVertexArrays(n, arrays);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glBindVertexArray(GLuint array)
-{
-    d_3_0_Core->f.BindVertexArray(array);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
-{
-    d_3_0_Core->f.FlushMappedBufferRange(target, offset, length);
-}
-
-inline GLvoid* QOpenGLFunctions_4_3_Core::glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
-{
-    return d_3_0_Core->f.MapBufferRange(target, offset, length, access);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
-{
-    d_3_0_Core->f.FramebufferTextureLayer(target, attachment, texture, level, layer);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    d_3_0_Core->f.RenderbufferStorageMultisample(target, samples, internalformat, width, height);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
-{
-    d_3_0_Core->f.BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGenerateMipmap(GLenum target)
-{
-    d_3_0_Core->f.GenerateMipmap(target);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
-{
-    d_3_0_Core->f.FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
-{
-    d_3_0_Core->f.FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
-{
-    d_3_0_Core->f.FramebufferTexture2D(target, attachment, textarget, texture, level);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
-{
-    d_3_0_Core->f.FramebufferTexture1D(target, attachment, textarget, texture, level);
-}
-
-inline GLenum QOpenGLFunctions_4_3_Core::glCheckFramebufferStatus(GLenum target)
-{
-    return d_3_0_Core->f.CheckFramebufferStatus(target);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGenFramebuffers(GLsizei n, GLuint *framebuffers)
-{
-    d_3_0_Core->f.GenFramebuffers(n, framebuffers);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
-{
-    d_3_0_Core->f.DeleteFramebuffers(n, framebuffers);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glBindFramebuffer(GLenum target, GLuint framebuffer)
-{
-    d_3_0_Core->f.BindFramebuffer(target, framebuffer);
-}
-
-inline GLboolean QOpenGLFunctions_4_3_Core::glIsFramebuffer(GLuint framebuffer)
-{
-    return d_3_0_Core->f.IsFramebuffer(framebuffer);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetRenderbufferParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    d_3_0_Core->f.RenderbufferStorage(target, internalformat, width, height);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGenRenderbuffers(GLsizei n, GLuint *renderbuffers)
-{
-    d_3_0_Core->f.GenRenderbuffers(n, renderbuffers);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
-{
-    d_3_0_Core->f.DeleteRenderbuffers(n, renderbuffers);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glBindRenderbuffer(GLenum target, GLuint renderbuffer)
-{
-    d_3_0_Core->f.BindRenderbuffer(target, renderbuffer);
-}
-
-inline GLboolean QOpenGLFunctions_4_3_Core::glIsRenderbuffer(GLuint renderbuffer)
-{
-    return d_3_0_Core->f.IsRenderbuffer(renderbuffer);
-}
-
-inline const GLubyte * QOpenGLFunctions_4_3_Core::glGetStringi(GLenum name, GLuint index)
-{
-    return d_3_0_Core->f.GetStringi(name, index);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
-{
-    d_3_0_Core->f.ClearBufferfi(buffer, drawbuffer, depth, stencil);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
-{
-    d_3_0_Core->f.ClearBufferfv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
-{
-    d_3_0_Core->f.ClearBufferuiv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
-{
-    d_3_0_Core->f.ClearBufferiv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params)
-{
-    d_3_0_Core->f.GetTexParameterIuiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetTexParameterIiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params)
-{
-    d_3_0_Core->f.TexParameterIuiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glTexParameterIiv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_3_0_Core->f.TexParameterIiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUniform4uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform4uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUniform3uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform3uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUniform2uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform2uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUniform1uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform1uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
-{
-    d_3_0_Core->f.Uniform4ui(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
-{
-    d_3_0_Core->f.Uniform3ui(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUniform2ui(GLint location, GLuint v0, GLuint v1)
-{
-    d_3_0_Core->f.Uniform2ui(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUniform1ui(GLint location, GLuint v0)
-{
-    d_3_0_Core->f.Uniform1ui(location, v0);
-}
-
-inline GLint QOpenGLFunctions_4_3_Core::glGetFragDataLocation(GLuint program, const GLchar *name)
-{
-    return d_3_0_Core->f.GetFragDataLocation(program, name);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name)
-{
-    d_3_0_Core->f.BindFragDataLocation(program, color, name);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetUniformuiv(GLuint program, GLint location, GLuint *params)
-{
-    d_3_0_Core->f.GetUniformuiv(program, location, params);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
-{
-    d_3_0_Core->f.GetVertexAttribIuiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetVertexAttribIiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_3_0_Core->f.VertexAttribIPointer(index, size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glEndConditionalRender()
-{
-    d_3_0_Core->f.EndConditionalRender();
-}
-
-inline void QOpenGLFunctions_4_3_Core::glBeginConditionalRender(GLuint id, GLenum mode)
-{
-    d_3_0_Core->f.BeginConditionalRender(id, mode);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glClampColor(GLenum target, GLenum clamp)
-{
-    d_3_0_Core->f.ClampColor(target, clamp);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
-{
-    d_3_0_Core->f.GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode)
-{
-    d_3_0_Core->f.TransformFeedbackVaryings(program, count, varyings, bufferMode);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
-{
-    d_3_0_Core->f.BindBufferBase(target, index, buffer);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
-{
-    d_3_0_Core->f.BindBufferRange(target, index, buffer, offset, size);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glEndTransformFeedback()
-{
-    d_3_0_Core->f.EndTransformFeedback();
-}
-
-inline void QOpenGLFunctions_4_3_Core::glBeginTransformFeedback(GLenum primitiveMode)
-{
-    d_3_0_Core->f.BeginTransformFeedback(primitiveMode);
-}
-
-inline GLboolean QOpenGLFunctions_4_3_Core::glIsEnabledi(GLenum target, GLuint index)
-{
-    return d_3_0_Core->f.IsEnabledi(target, index);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glDisablei(GLenum target, GLuint index)
-{
-    d_3_0_Core->f.Disablei(target, index);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glEnablei(GLenum target, GLuint index)
-{
-    d_3_0_Core->f.Enablei(target, index);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetIntegeri_v(GLenum target, GLuint index, GLint *data)
-{
-    d_3_0_Core->f.GetIntegeri_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetBooleani_v(GLenum target, GLuint index, GLboolean *data)
-{
-    d_3_0_Core->f.GetBooleani_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
-{
-    d_3_0_Core->f.ColorMaski(index, r, g, b, a);
-}
-
-
-// OpenGL 3.1 core functions
-inline void QOpenGLFunctions_4_3_Core::glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
-{
-    d_3_1_Core->f.CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
-{
-    d_3_1_Core->f.UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
-{
-    d_3_1_Core->f.GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params)
-{
-    d_3_1_Core->f.GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
-}
-
-inline GLuint QOpenGLFunctions_4_3_Core::glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName)
-{
-    return d_3_1_Core->f.GetUniformBlockIndex(program, uniformBlockName);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName)
-{
-    d_3_1_Core->f.GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params)
-{
-    d_3_1_Core->f.GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const *uniformNames, GLuint *uniformIndices)
-{
-    d_3_1_Core->f.GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glPrimitiveRestartIndex(GLuint index)
-{
-    d_3_1_Core->f.PrimitiveRestartIndex(index);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer)
-{
-    d_3_1_Core->f.TexBuffer(target, internalformat, buffer);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount)
-{
-    d_3_1_Core->f.DrawElementsInstanced(mode, count, type, indices, instancecount);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount)
-{
-    d_3_1_Core->f.DrawArraysInstanced(mode, first, count, instancecount);
-}
-
-
-// OpenGL 3.2 core functions
-inline void QOpenGLFunctions_4_3_Core::glSampleMaski(GLuint index, GLbitfield mask)
-{
-    d_3_2_Core->f.SampleMaski(index, mask);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val)
-{
-    d_3_2_Core->f.GetMultisamplefv(pname, index, val);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glTexImage3DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
-{
-    d_3_2_Core->f.TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glTexImage2DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
-{
-    d_3_2_Core->f.TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values)
-{
-    d_3_2_Core->f.GetSynciv(sync, pname, bufSize, length, values);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetInteger64v(GLenum pname, GLint64 *params)
-{
-    d_3_2_Core->f.GetInteger64v(pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
-{
-    d_3_2_Core->f.WaitSync(sync, flags, timeout);
-}
-
-inline GLenum QOpenGLFunctions_4_3_Core::glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
-{
-    return d_3_2_Core->f.ClientWaitSync(sync, flags, timeout);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glDeleteSync(GLsync sync)
-{
-    d_3_2_Core->f.DeleteSync(sync);
-}
-
-inline GLboolean QOpenGLFunctions_4_3_Core::glIsSync(GLsync sync)
-{
-    return d_3_2_Core->f.IsSync(sync);
-}
-
-inline GLsync QOpenGLFunctions_4_3_Core::glFenceSync(GLenum condition, GLbitfield flags)
-{
-    return d_3_2_Core->f.FenceSync(condition, flags);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProvokingVertex(GLenum mode)
-{
-    d_3_2_Core->f.ProvokingVertex(mode);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glMultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount, const GLint *basevertex)
-{
-    d_3_2_Core->f.MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount, GLint basevertex)
-{
-    d_3_2_Core->f.DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)
-{
-    d_3_2_Core->f.DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)
-{
-    d_3_2_Core->f.DrawElementsBaseVertex(mode, count, type, indices, basevertex);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level)
-{
-    d_3_2_Core->f.FramebufferTexture(target, attachment, texture, level);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params)
-{
-    d_3_2_Core->f.GetBufferParameteri64v(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data)
-{
-    d_3_2_Core->f.GetInteger64i_v(target, index, data);
-}
-
-
-// OpenGL 3.3 core functions
-inline void QOpenGLFunctions_4_3_Core::glVertexAttribP4uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP4uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glVertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP4ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glVertexAttribP3uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP3uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glVertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP3ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glVertexAttribP2uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP2uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glVertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP2ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glVertexAttribP1uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP1uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glVertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP1ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glSecondaryColorP3uiv(GLenum type, const GLuint *color)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(color);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_3_Core::glSecondaryColorP3ui(GLenum type, GLuint color)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(color);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_3_Core::glColorP4uiv(GLenum type, const GLuint *color)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(color);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_3_Core::glColorP4ui(GLenum type, GLuint color)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(color);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_3_Core::glColorP3uiv(GLenum type, const GLuint *color)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(color);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_3_Core::glColorP3ui(GLenum type, GLuint color)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(color);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_3_Core::glNormalP3uiv(GLenum type, const GLuint *coords)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_3_Core::glNormalP3ui(GLenum type, GLuint coords)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_3_Core::glMultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint *coords)
-{
-    Q_UNUSED(texture);
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_3_Core::glMultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords)
-{
-    Q_UNUSED(texture);
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_3_Core::glMultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint *coords)
-{
-    Q_UNUSED(texture);
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_3_Core::glMultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords)
-{
-    Q_UNUSED(texture);
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_3_Core::glMultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint *coords)
-{
-    Q_UNUSED(texture);
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_3_Core::glMultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords)
-{
-    Q_UNUSED(texture);
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_3_Core::glMultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint *coords)
-{
-    Q_UNUSED(texture);
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_3_Core::glMultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords)
-{
-    Q_UNUSED(texture);
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_3_Core::glTexCoordP4uiv(GLenum type, const GLuint *coords)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_3_Core::glTexCoordP4ui(GLenum type, GLuint coords)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_3_Core::glTexCoordP3uiv(GLenum type, const GLuint *coords)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_3_Core::glTexCoordP3ui(GLenum type, GLuint coords)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_3_Core::glTexCoordP2uiv(GLenum type, const GLuint *coords)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_3_Core::glTexCoordP2ui(GLenum type, GLuint coords)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_3_Core::glTexCoordP1uiv(GLenum type, const GLuint *coords)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_3_Core::glTexCoordP1ui(GLenum type, GLuint coords)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(coords);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_3_Core::glVertexP4uiv(GLenum type, const GLuint *value)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(value);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_3_Core::glVertexP4ui(GLenum type, GLuint value)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(value);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_3_Core::glVertexP3uiv(GLenum type, const GLuint *value)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(value);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_3_Core::glVertexP3ui(GLenum type, GLuint value)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(value);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_3_Core::glVertexP2uiv(GLenum type, const GLuint *value)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(value);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_3_Core::glVertexP2ui(GLenum type, GLuint value)
-{
-    Q_UNUSED(type);
-    Q_UNUSED(value);
-    QOPENGL_DEPRECATEDFUNCTION;
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params)
-{
-    d_3_3_Core->f.GetQueryObjectui64v(id, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params)
-{
-    d_3_3_Core->f.GetQueryObjecti64v(id, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glQueryCounter(GLuint id, GLenum target)
-{
-    d_3_3_Core->f.QueryCounter(id, target);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params)
-{
-    d_3_3_Core->f.GetSamplerParameterIuiv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params)
-{
-    d_3_3_Core->f.GetSamplerParameterfv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params)
-{
-    d_3_3_Core->f.GetSamplerParameterIiv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params)
-{
-    d_3_3_Core->f.GetSamplerParameteriv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param)
-{
-    d_3_3_Core->f.SamplerParameterIuiv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param)
-{
-    d_3_3_Core->f.SamplerParameterIiv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param)
-{
-    d_3_3_Core->f.SamplerParameterfv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
-{
-    d_3_3_Core->f.SamplerParameterf(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param)
-{
-    d_3_3_Core->f.SamplerParameteriv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glSamplerParameteri(GLuint sampler, GLenum pname, GLint param)
-{
-    d_3_3_Core->f.SamplerParameteri(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glBindSampler(GLuint unit, GLuint sampler)
-{
-    d_3_3_Core->f.BindSampler(unit, sampler);
-}
-
-inline GLboolean QOpenGLFunctions_4_3_Core::glIsSampler(GLuint sampler)
-{
-    return d_3_3_Core->f.IsSampler(sampler);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glDeleteSamplers(GLsizei count, const GLuint *samplers)
-{
-    d_3_3_Core->f.DeleteSamplers(count, samplers);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGenSamplers(GLsizei count, GLuint *samplers)
-{
-    d_3_3_Core->f.GenSamplers(count, samplers);
-}
-
-inline GLint QOpenGLFunctions_4_3_Core::glGetFragDataIndex(GLuint program, const GLchar *name)
-{
-    return d_3_3_Core->f.GetFragDataIndex(program, name);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glBindFragDataLocationIndexed(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name)
-{
-    d_3_3_Core->f.BindFragDataLocationIndexed(program, colorNumber, index, name);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glVertexAttribDivisor(GLuint index, GLuint divisor)
-{
-    d_3_3_Core->f.VertexAttribDivisor(index, divisor);
-}
-
-
-// OpenGL 4.0 core functions
-inline void QOpenGLFunctions_4_3_Core::glGetQueryIndexediv(GLenum target, GLuint index, GLenum pname, GLint *params)
-{
-    d_4_0_Core->f.GetQueryIndexediv(target, index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glEndQueryIndexed(GLenum target, GLuint index)
-{
-    d_4_0_Core->f.EndQueryIndexed(target, index);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glBeginQueryIndexed(GLenum target, GLuint index, GLuint id)
-{
-    d_4_0_Core->f.BeginQueryIndexed(target, index, id);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glDrawTransformFeedbackStream(GLenum mode, GLuint id, GLuint stream)
-{
-    d_4_0_Core->f.DrawTransformFeedbackStream(mode, id, stream);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glDrawTransformFeedback(GLenum mode, GLuint id)
-{
-    d_4_0_Core->f.DrawTransformFeedback(mode, id);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glResumeTransformFeedback()
-{
-    d_4_0_Core->f.ResumeTransformFeedback();
-}
-
-inline void QOpenGLFunctions_4_3_Core::glPauseTransformFeedback()
-{
-    d_4_0_Core->f.PauseTransformFeedback();
-}
-
-inline GLboolean QOpenGLFunctions_4_3_Core::glIsTransformFeedback(GLuint id)
-{
-    return d_4_0_Core->f.IsTransformFeedback(id);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGenTransformFeedbacks(GLsizei n, GLuint *ids)
-{
-    d_4_0_Core->f.GenTransformFeedbacks(n, ids);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids)
-{
-    d_4_0_Core->f.DeleteTransformFeedbacks(n, ids);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glBindTransformFeedback(GLenum target, GLuint id)
-{
-    d_4_0_Core->f.BindTransformFeedback(target, id);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glPatchParameterfv(GLenum pname, const GLfloat *values)
-{
-    d_4_0_Core->f.PatchParameterfv(pname, values);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glPatchParameteri(GLenum pname, GLint value)
-{
-    d_4_0_Core->f.PatchParameteri(pname, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetProgramStageiv(GLuint program, GLenum shadertype, GLenum pname, GLint *values)
-{
-    d_4_0_Core->f.GetProgramStageiv(program, shadertype, pname, values);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetUniformSubroutineuiv(GLenum shadertype, GLint location, GLuint *params)
-{
-    d_4_0_Core->f.GetUniformSubroutineuiv(shadertype, location, params);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUniformSubroutinesuiv(GLenum shadertype, GLsizei count, const GLuint *indices)
-{
-    d_4_0_Core->f.UniformSubroutinesuiv(shadertype, count, indices);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetActiveSubroutineName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
-{
-    d_4_0_Core->f.GetActiveSubroutineName(program, shadertype, index, bufsize, length, name);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetActiveSubroutineUniformName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
-{
-    d_4_0_Core->f.GetActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetActiveSubroutineUniformiv(GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values)
-{
-    d_4_0_Core->f.GetActiveSubroutineUniformiv(program, shadertype, index, pname, values);
-}
-
-inline GLuint QOpenGLFunctions_4_3_Core::glGetSubroutineIndex(GLuint program, GLenum shadertype, const GLchar *name)
-{
-    return d_4_0_Core->f.GetSubroutineIndex(program, shadertype, name);
-}
-
-inline GLint QOpenGLFunctions_4_3_Core::glGetSubroutineUniformLocation(GLuint program, GLenum shadertype, const GLchar *name)
-{
-    return d_4_0_Core->f.GetSubroutineUniformLocation(program, shadertype, name);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetUniformdv(GLuint program, GLint location, GLdouble *params)
-{
-    d_4_0_Core->f.GetUniformdv(program, location, params);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUniformMatrix4x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix4x3dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUniformMatrix4x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix4x2dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUniformMatrix3x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix3x4dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUniformMatrix3x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix3x2dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUniformMatrix2x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix2x4dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUniformMatrix2x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix2x3dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix4dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUniformMatrix3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix3dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUniformMatrix2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix2dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUniform4dv(GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_0_Core->f.Uniform4dv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUniform3dv(GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_0_Core->f.Uniform3dv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUniform2dv(GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_0_Core->f.Uniform2dv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUniform1dv(GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_0_Core->f.Uniform1dv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUniform4d(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_4_0_Core->f.Uniform4d(location, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUniform3d(GLint location, GLdouble x, GLdouble y, GLdouble z)
-{
-    d_4_0_Core->f.Uniform3d(location, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUniform2d(GLint location, GLdouble x, GLdouble y)
-{
-    d_4_0_Core->f.Uniform2d(location, x, y);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUniform1d(GLint location, GLdouble x)
-{
-    d_4_0_Core->f.Uniform1d(location, x);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glDrawElementsIndirect(GLenum mode, GLenum type, const GLvoid *indirect)
-{
-    d_4_0_Core->f.DrawElementsIndirect(mode, type, indirect);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glDrawArraysIndirect(GLenum mode, const GLvoid *indirect)
-{
-    d_4_0_Core->f.DrawArraysIndirect(mode, indirect);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glBlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
-{
-    d_4_0_Core->f.BlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glBlendFunci(GLuint buf, GLenum src, GLenum dst)
-{
-    d_4_0_Core->f.BlendFunci(buf, src, dst);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glBlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha)
-{
-    d_4_0_Core->f.BlendEquationSeparatei(buf, modeRGB, modeAlpha);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glBlendEquationi(GLuint buf, GLenum mode)
-{
-    d_4_0_Core->f.BlendEquationi(buf, mode);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glMinSampleShading(GLfloat value)
-{
-    d_4_0_Core->f.MinSampleShading(value);
-}
-
-
-// OpenGL 4.1 core functions
-inline void QOpenGLFunctions_4_3_Core::glGetDoublei_v(GLenum target, GLuint index, GLdouble *data)
-{
-    d_4_1_Core->f.GetDoublei_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetFloati_v(GLenum target, GLuint index, GLfloat *data)
-{
-    d_4_1_Core->f.GetFloati_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glDepthRangeIndexed(GLuint index, GLdouble n, GLdouble f)
-{
-    d_4_1_Core->f.DepthRangeIndexed(index, n, f);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glDepthRangeArrayv(GLuint first, GLsizei count, const GLdouble *v)
-{
-    d_4_1_Core->f.DepthRangeArrayv(first, count, v);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glScissorIndexedv(GLuint index, const GLint *v)
-{
-    d_4_1_Core->f.ScissorIndexedv(index, v);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glScissorIndexed(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height)
-{
-    d_4_1_Core->f.ScissorIndexed(index, left, bottom, width, height);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glScissorArrayv(GLuint first, GLsizei count, const GLint *v)
-{
-    d_4_1_Core->f.ScissorArrayv(first, count, v);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glViewportIndexedfv(GLuint index, const GLfloat *v)
-{
-    d_4_1_Core->f.ViewportIndexedfv(index, v);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glViewportIndexedf(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h)
-{
-    d_4_1_Core->f.ViewportIndexedf(index, x, y, w, h);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glViewportArrayv(GLuint first, GLsizei count, const GLfloat *v)
-{
-    d_4_1_Core->f.ViewportArrayv(first, count, v);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetVertexAttribLdv(GLuint index, GLenum pname, GLdouble *params)
-{
-    d_4_1_Core->f.GetVertexAttribLdv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glVertexAttribLPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-{
-    d_4_1_Core->f.VertexAttribLPointer(index, size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glVertexAttribL4dv(GLuint index, const GLdouble *v)
-{
-    d_4_1_Core->f.VertexAttribL4dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glVertexAttribL3dv(GLuint index, const GLdouble *v)
-{
-    d_4_1_Core->f.VertexAttribL3dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glVertexAttribL2dv(GLuint index, const GLdouble *v)
-{
-    d_4_1_Core->f.VertexAttribL2dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glVertexAttribL1dv(GLuint index, const GLdouble *v)
-{
-    d_4_1_Core->f.VertexAttribL1dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glVertexAttribL4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_4_1_Core->f.VertexAttribL4d(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glVertexAttribL3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
-{
-    d_4_1_Core->f.VertexAttribL3d(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glVertexAttribL2d(GLuint index, GLdouble x, GLdouble y)
-{
-    d_4_1_Core->f.VertexAttribL2d(index, x, y);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glVertexAttribL1d(GLuint index, GLdouble x)
-{
-    d_4_1_Core->f.VertexAttribL1d(index, x);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-{
-    d_4_1_Core->f.GetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glValidateProgramPipeline(GLuint pipeline)
-{
-    d_4_1_Core->f.ValidateProgramPipeline(pipeline);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProgramUniformMatrix4x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4x3dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProgramUniformMatrix3x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3x4dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProgramUniformMatrix4x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4x2dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProgramUniformMatrix2x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2x4dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProgramUniformMatrix3x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3x2dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProgramUniformMatrix2x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2x3dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProgramUniformMatrix4x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4x3fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProgramUniformMatrix3x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3x4fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProgramUniformMatrix4x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4x2fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProgramUniformMatrix2x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2x4fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProgramUniformMatrix3x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3x2fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProgramUniformMatrix2x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2x3fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProgramUniformMatrix4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProgramUniformMatrix3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProgramUniformMatrix2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProgramUniformMatrix4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProgramUniformMatrix3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProgramUniformMatrix2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProgramUniform4uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
-{
-    d_4_1_Core->f.ProgramUniform4uiv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
-{
-    d_4_1_Core->f.ProgramUniform4ui(program, location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProgramUniform4dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniform4dv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProgramUniform4d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3)
-{
-    d_4_1_Core->f.ProgramUniform4d(program, location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProgramUniform4fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniform4fv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
-{
-    d_4_1_Core->f.ProgramUniform4f(program, location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProgramUniform4iv(GLuint program, GLint location, GLsizei count, const GLint *value)
-{
-    d_4_1_Core->f.ProgramUniform4iv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
-{
-    d_4_1_Core->f.ProgramUniform4i(program, location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProgramUniform3uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
-{
-    d_4_1_Core->f.ProgramUniform3uiv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2)
-{
-    d_4_1_Core->f.ProgramUniform3ui(program, location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProgramUniform3dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniform3dv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProgramUniform3d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2)
-{
-    d_4_1_Core->f.ProgramUniform3d(program, location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProgramUniform3fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniform3fv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
-{
-    d_4_1_Core->f.ProgramUniform3f(program, location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProgramUniform3iv(GLuint program, GLint location, GLsizei count, const GLint *value)
-{
-    d_4_1_Core->f.ProgramUniform3iv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2)
-{
-    d_4_1_Core->f.ProgramUniform3i(program, location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProgramUniform2uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
-{
-    d_4_1_Core->f.ProgramUniform2uiv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1)
-{
-    d_4_1_Core->f.ProgramUniform2ui(program, location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProgramUniform2dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniform2dv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProgramUniform2d(GLuint program, GLint location, GLdouble v0, GLdouble v1)
-{
-    d_4_1_Core->f.ProgramUniform2d(program, location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProgramUniform2fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniform2fv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1)
-{
-    d_4_1_Core->f.ProgramUniform2f(program, location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProgramUniform2iv(GLuint program, GLint location, GLsizei count, const GLint *value)
-{
-    d_4_1_Core->f.ProgramUniform2iv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1)
-{
-    d_4_1_Core->f.ProgramUniform2i(program, location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProgramUniform1uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
-{
-    d_4_1_Core->f.ProgramUniform1uiv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProgramUniform1ui(GLuint program, GLint location, GLuint v0)
-{
-    d_4_1_Core->f.ProgramUniform1ui(program, location, v0);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProgramUniform1dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniform1dv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProgramUniform1d(GLuint program, GLint location, GLdouble v0)
-{
-    d_4_1_Core->f.ProgramUniform1d(program, location, v0);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProgramUniform1fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniform1fv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProgramUniform1f(GLuint program, GLint location, GLfloat v0)
-{
-    d_4_1_Core->f.ProgramUniform1f(program, location, v0);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProgramUniform1iv(GLuint program, GLint location, GLsizei count, const GLint *value)
-{
-    d_4_1_Core->f.ProgramUniform1iv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProgramUniform1i(GLuint program, GLint location, GLint v0)
-{
-    d_4_1_Core->f.ProgramUniform1i(program, location, v0);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params)
-{
-    d_4_1_Core->f.GetProgramPipelineiv(pipeline, pname, params);
-}
-
-inline GLboolean QOpenGLFunctions_4_3_Core::glIsProgramPipeline(GLuint pipeline)
-{
-    return d_4_1_Core->f.IsProgramPipeline(pipeline);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGenProgramPipelines(GLsizei n, GLuint *pipelines)
-{
-    d_4_1_Core->f.GenProgramPipelines(n, pipelines);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glDeleteProgramPipelines(GLsizei n, const GLuint *pipelines)
-{
-    d_4_1_Core->f.DeleteProgramPipelines(n, pipelines);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glBindProgramPipeline(GLuint pipeline)
-{
-    d_4_1_Core->f.BindProgramPipeline(pipeline);
-}
-
-inline GLuint QOpenGLFunctions_4_3_Core::glCreateShaderProgramv(GLenum type, GLsizei count, const GLchar* const *strings)
-{
-    return d_4_1_Core->f.CreateShaderProgramv(type, count, strings);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glActiveShaderProgram(GLuint pipeline, GLuint program)
-{
-    d_4_1_Core->f.ActiveShaderProgram(pipeline, program);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program)
-{
-    d_4_1_Core->f.UseProgramStages(pipeline, stages, program);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProgramParameteri(GLuint program, GLenum pname, GLint value)
-{
-    d_4_1_Core->f.ProgramParameteri(program, pname, value);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid *binary, GLsizei length)
-{
-    d_4_1_Core->f.ProgramBinary(program, binaryFormat, binary, length);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, GLvoid *binary)
-{
-    d_4_1_Core->f.GetProgramBinary(program, bufSize, length, binaryFormat, binary);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glClearDepthf(GLfloat dd)
-{
-    d_4_1_Core->f.ClearDepthf(dd);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glDepthRangef(GLfloat n, GLfloat f)
-{
-    d_4_1_Core->f.DepthRangef(n, f);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision)
-{
-    d_4_1_Core->f.GetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glShaderBinary(GLsizei count, const GLuint *shaders, GLenum binaryformat, const GLvoid *binary, GLsizei length)
-{
-    d_4_1_Core->f.ShaderBinary(count, shaders, binaryformat, binary, length);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glReleaseShaderCompiler()
-{
-    d_4_1_Core->f.ReleaseShaderCompiler();
-}
-
-
-// OpenGL 4.2 core functions
-inline void QOpenGLFunctions_4_3_Core::glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
-{
-    d_4_2_Core->f.TexStorage3D(target, levels, internalformat, width, height, depth);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    d_4_2_Core->f.TexStorage2D(target, levels, internalformat, width, height);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glTexStorage1D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width)
-{
-    d_4_2_Core->f.TexStorage1D(target, levels, internalformat, width);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glMemoryBarrier(GLbitfield barriers)
-{
-    d_4_2_Core->f.MemoryBarrier(barriers);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glBindImageTexture(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format)
-{
-    d_4_2_Core->f.BindImageTexture(unit, texture, level, layered, layer, access, format);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetActiveAtomicCounterBufferiv(GLuint program, GLuint bufferIndex, GLenum pname, GLint *params)
-{
-    d_4_2_Core->f.GetActiveAtomicCounterBufferiv(program, bufferIndex, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params)
-{
-    d_4_2_Core->f.GetInternalformativ(target, internalformat, pname, bufSize, params);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glDrawTransformFeedbackStreamInstanced(GLenum mode, GLuint id, GLuint stream, GLsizei instancecount)
-{
-    d_4_2_Core->f.DrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glDrawTransformFeedbackInstanced(GLenum mode, GLuint id, GLsizei instancecount)
-{
-    d_4_2_Core->f.DrawTransformFeedbackInstanced(mode, id, instancecount);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glDrawElementsInstancedBaseVertexBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance)
-{
-    d_4_2_Core->f.DrawElementsInstancedBaseVertexBaseInstance(mode, count, type, indices, instancecount, basevertex, baseinstance);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glDrawElementsInstancedBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLuint baseinstance)
-{
-    d_4_2_Core->f.DrawElementsInstancedBaseInstance(mode, count, type, indices, instancecount, baseinstance);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glDrawArraysInstancedBaseInstance(GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance)
-{
-    d_4_2_Core->f.DrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);
-}
-
-
-// OpenGL 4.3 core functions
-inline void QOpenGLFunctions_4_3_Core::glTexStorage3DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
-{
-    d_4_3_Core->f.TexStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glTexStorage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
-{
-    d_4_3_Core->f.TexStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glTexBufferRange(GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size)
-{
-    d_4_3_Core->f.TexBufferRange(target, internalformat, buffer, offset, size);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glShaderStorageBlockBinding(GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding)
-{
-    d_4_3_Core->f.ShaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding);
-}
-
-inline GLint QOpenGLFunctions_4_3_Core::glGetProgramResourceLocationIndex(GLuint program, GLenum programInterface, const GLchar *name)
-{
-    return d_4_3_Core->f.GetProgramResourceLocationIndex(program, programInterface, name);
-}
-
-inline GLint QOpenGLFunctions_4_3_Core::glGetProgramResourceLocation(GLuint program, GLenum programInterface, const GLchar *name)
-{
-    return d_4_3_Core->f.GetProgramResourceLocation(program, programInterface, name);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetProgramResourceiv(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params)
-{
-    d_4_3_Core->f.GetProgramResourceiv(program, programInterface, index, propCount, props, bufSize, length, params);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetProgramResourceName(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name)
-{
-    d_4_3_Core->f.GetProgramResourceName(program, programInterface, index, bufSize, length, name);
-}
-
-inline GLuint QOpenGLFunctions_4_3_Core::glGetProgramResourceIndex(GLuint program, GLenum programInterface, const GLchar *name)
-{
-    return d_4_3_Core->f.GetProgramResourceIndex(program, programInterface, name);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetProgramInterfaceiv(GLuint program, GLenum programInterface, GLenum pname, GLint *params)
-{
-    d_4_3_Core->f.GetProgramInterfaceiv(program, programInterface, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glMultiDrawElementsIndirect(GLenum mode, GLenum type, const void *indirect, GLsizei drawcount, GLsizei stride)
-{
-    d_4_3_Core->f.MultiDrawElementsIndirect(mode, type, indirect, drawcount, stride);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glMultiDrawArraysIndirect(GLenum mode, const void *indirect, GLsizei drawcount, GLsizei stride)
-{
-    d_4_3_Core->f.MultiDrawArraysIndirect(mode, indirect, drawcount, stride);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glInvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_4_3_Core->f.InvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glInvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments)
-{
-    d_4_3_Core->f.InvalidateFramebuffer(target, numAttachments, attachments);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glInvalidateBufferData(GLuint buffer)
-{
-    d_4_3_Core->f.InvalidateBufferData(buffer);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glInvalidateBufferSubData(GLuint buffer, GLintptr offset, GLsizeiptr length)
-{
-    d_4_3_Core->f.InvalidateBufferSubData(buffer, offset, length);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glInvalidateTexImage(GLuint texture, GLint level)
-{
-    d_4_3_Core->f.InvalidateTexImage(texture, level);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glInvalidateTexSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth)
-{
-    d_4_3_Core->f.InvalidateTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetInternalformati64v(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint64 *params)
-{
-    d_4_3_Core->f.GetInternalformati64v(target, internalformat, pname, bufSize, params);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glGetFramebufferParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_4_3_Core->f.GetFramebufferParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glFramebufferParameteri(GLenum target, GLenum pname, GLint param)
-{
-    d_4_3_Core->f.FramebufferParameteri(target, pname, param);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glVertexBindingDivisor(GLuint bindingindex, GLuint divisor)
-{
-    d_4_3_Core->f.VertexBindingDivisor(bindingindex, divisor);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glVertexAttribBinding(GLuint attribindex, GLuint bindingindex)
-{
-    d_4_3_Core->f.VertexAttribBinding(attribindex, bindingindex);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glVertexAttribLFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
-{
-    d_4_3_Core->f.VertexAttribLFormat(attribindex, size, type, relativeoffset);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glVertexAttribIFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
-{
-    d_4_3_Core->f.VertexAttribIFormat(attribindex, size, type, relativeoffset);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glVertexAttribFormat(GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset)
-{
-    d_4_3_Core->f.VertexAttribFormat(attribindex, size, type, normalized, relativeoffset);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glBindVertexBuffer(GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride)
-{
-    d_4_3_Core->f.BindVertexBuffer(bindingindex, buffer, offset, stride);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glTextureView(GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers)
-{
-    d_4_3_Core->f.TextureView(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glCopyImageSubData(GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth)
-{
-    d_4_3_Core->f.CopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glDispatchComputeIndirect(GLintptr indirect)
-{
-    d_4_3_Core->f.DispatchComputeIndirect(indirect);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glDispatchCompute(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z)
-{
-    d_4_3_Core->f.DispatchCompute(num_groups_x, num_groups_y, num_groups_z);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glClearBufferSubData(GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data)
-{
-    d_4_3_Core->f.ClearBufferSubData(target, internalformat, offset, size, format, type, data);
-}
-
-inline void QOpenGLFunctions_4_3_Core::glClearBufferData(GLenum target, GLenum internalformat, GLenum format, GLenum type, const void *data)
-{
-    d_4_3_Core->f.ClearBufferData(target, internalformat, format, type, data);
-}
-
-
-
-QT_END_NAMESPACE
-
-#ifdef Q_OS_WIN
-#pragma pop_macro("MemoryBarrier")
-#endif
-
-#endif // QT_NO_OPENGL && !QT_OPENGL_ES_2
-
-#endif
diff --git a/src/gui/opengl/qopenglfunctions_4_4_compatibility.cpp b/src/gui/opengl/qopenglfunctions_4_4_compatibility.cpp
deleted file mode 100644
index 4fc4b50100..0000000000
--- a/src/gui/opengl/qopenglfunctions_4_4_compatibility.cpp
+++ /dev/null
@@ -1,326 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2015 Klaralvdalens Datakonsult AB (KDAB)
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#include "qopenglfunctions_4_4_compatibility.h"
-#include "qopenglcontext.h"
-
-QT_BEGIN_NAMESPACE
-
-/*!
-    \class QOpenGLFunctions_4_4_Compatibility
-    \inmodule QtGui
-    \since 5.5
-    \wrapper
-    \brief The QOpenGLFunctions_4_4_Compatibility class provides all functions for OpenGL 4.4 compatibility profile.
-
-    This class is a wrapper for functions from OpenGL 4.4 compatibility profile.
-    See reference pages on \l {http://www.opengl.org/sdk/docs/}{opengl.org}
-    for function documentation.
-
-    \sa QAbstractOpenGLFunctions
-*/
-
-QOpenGLFunctions_4_4_Compatibility::QOpenGLFunctions_4_4_Compatibility()
- : QAbstractOpenGLFunctions()
- , d_1_0_Core(nullptr)
- , d_1_1_Core(nullptr)
- , d_1_2_Core(nullptr)
- , d_1_3_Core(nullptr)
- , d_1_4_Core(nullptr)
- , d_1_5_Core(nullptr)
- , d_2_0_Core(nullptr)
- , d_2_1_Core(nullptr)
- , d_3_0_Core(nullptr)
- , d_3_1_Core(nullptr)
- , d_3_2_Core(nullptr)
- , d_3_3_Core(nullptr)
- , d_4_0_Core(nullptr)
- , d_4_1_Core(nullptr)
- , d_4_2_Core(nullptr)
- , d_4_3_Core(nullptr)
- , d_4_4_Core(nullptr)
- , d_1_0_Deprecated(nullptr)
- , d_1_1_Deprecated(nullptr)
- , d_1_2_Deprecated(nullptr)
- , d_1_3_Deprecated(nullptr)
- , d_1_4_Deprecated(nullptr)
- , d_3_3_Deprecated(nullptr)
-{
-}
-
-QOpenGLFunctions_4_4_Compatibility::~QOpenGLFunctions_4_4_Compatibility()
-{
-    if (d_1_0_Core) {
-        d_1_0_Core->refs.deref();
-        Q_ASSERT(d_1_0_Core->refs.loadRelaxed());
-    }
-    if (d_1_1_Core) {
-        d_1_1_Core->refs.deref();
-        Q_ASSERT(d_1_1_Core->refs.loadRelaxed());
-    }
-    if (d_1_2_Core) {
-        d_1_2_Core->refs.deref();
-        Q_ASSERT(d_1_2_Core->refs.loadRelaxed());
-    }
-    if (d_1_3_Core) {
-        d_1_3_Core->refs.deref();
-        Q_ASSERT(d_1_3_Core->refs.loadRelaxed());
-    }
-    if (d_1_4_Core) {
-        d_1_4_Core->refs.deref();
-        Q_ASSERT(d_1_4_Core->refs.loadRelaxed());
-    }
-    if (d_1_5_Core) {
-        d_1_5_Core->refs.deref();
-        Q_ASSERT(d_1_5_Core->refs.loadRelaxed());
-    }
-    if (d_2_0_Core) {
-        d_2_0_Core->refs.deref();
-        Q_ASSERT(d_2_0_Core->refs.loadRelaxed());
-    }
-    if (d_2_1_Core) {
-        d_2_1_Core->refs.deref();
-        Q_ASSERT(d_2_1_Core->refs.loadRelaxed());
-    }
-    if (d_3_0_Core) {
-        d_3_0_Core->refs.deref();
-        Q_ASSERT(d_3_0_Core->refs.loadRelaxed());
-    }
-    if (d_3_1_Core) {
-        d_3_1_Core->refs.deref();
-        Q_ASSERT(d_3_1_Core->refs.loadRelaxed());
-    }
-    if (d_3_2_Core) {
-        d_3_2_Core->refs.deref();
-        Q_ASSERT(d_3_2_Core->refs.loadRelaxed());
-    }
-    if (d_3_3_Core) {
-        d_3_3_Core->refs.deref();
-        Q_ASSERT(d_3_3_Core->refs.loadRelaxed());
-    }
-    if (d_4_0_Core) {
-        d_4_0_Core->refs.deref();
-        Q_ASSERT(d_4_0_Core->refs.loadRelaxed());
-    }
-    if (d_4_1_Core) {
-        d_4_1_Core->refs.deref();
-        Q_ASSERT(d_4_1_Core->refs.loadRelaxed());
-    }
-    if (d_4_2_Core) {
-        d_4_2_Core->refs.deref();
-        Q_ASSERT(d_4_2_Core->refs.loadRelaxed());
-    }
-    if (d_4_3_Core) {
-        d_4_3_Core->refs.deref();
-        Q_ASSERT(d_4_3_Core->refs.loadRelaxed());
-    }
-    if (d_4_4_Core) {
-        d_4_4_Core->refs.deref();
-        Q_ASSERT(d_4_4_Core->refs.loadRelaxed());
-    }
-    if (d_1_0_Deprecated) {
-        d_1_0_Deprecated->refs.deref();
-        Q_ASSERT(d_1_0_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_1_Deprecated) {
-        d_1_1_Deprecated->refs.deref();
-        Q_ASSERT(d_1_1_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_2_Deprecated) {
-        d_1_2_Deprecated->refs.deref();
-        Q_ASSERT(d_1_2_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_3_Deprecated) {
-        d_1_3_Deprecated->refs.deref();
-        Q_ASSERT(d_1_3_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_4_Deprecated) {
-        d_1_4_Deprecated->refs.deref();
-        Q_ASSERT(d_1_4_Deprecated->refs.loadRelaxed());
-    }
-    if (d_3_3_Deprecated) {
-        d_3_3_Deprecated->refs.deref();
-        Q_ASSERT(d_3_3_Deprecated->refs.loadRelaxed());
-    }
-}
-
-bool QOpenGLFunctions_4_4_Compatibility::initializeOpenGLFunctions()
-{
-    if ( isInitialized() )
-        return true;
-
-    QOpenGLContext* context = QOpenGLContext::currentContext();
-
-    // If owned by a context object make sure it is current.
-    // Also check that current context is capable of resolving all needed functions
-    if (((owningContext() && owningContext() == context) || !owningContext())
-        && QOpenGLFunctions_4_4_Compatibility::isContextCompatible(context))
-    {
-        // Associate with private implementation, creating if necessary
-        // Function pointers in the backends are resolved at creation time
-        QOpenGLVersionFunctionsBackend* d = nullptr;
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        d_1_3_Core = static_cast<QOpenGLFunctions_1_3_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        d_1_4_Core = static_cast<QOpenGLFunctions_1_4_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        d_1_5_Core = static_cast<QOpenGLFunctions_1_5_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        d_2_0_Core = static_cast<QOpenGLFunctions_2_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        d_2_1_Core = static_cast<QOpenGLFunctions_2_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        d_3_0_Core = static_cast<QOpenGLFunctions_3_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
-        d_3_1_Core = static_cast<QOpenGLFunctions_3_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
-        d_3_2_Core = static_cast<QOpenGLFunctions_3_2_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_CoreBackend::versionStatus());
-        d_3_3_Core = static_cast<QOpenGLFunctions_3_3_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_0_CoreBackend::versionStatus());
-        d_4_0_Core = static_cast<QOpenGLFunctions_4_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_1_CoreBackend::versionStatus());
-        d_4_1_Core = static_cast<QOpenGLFunctions_4_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_2_CoreBackend::versionStatus());
-        d_4_2_Core = static_cast<QOpenGLFunctions_4_2_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_3_CoreBackend::versionStatus());
-        d_4_3_Core = static_cast<QOpenGLFunctions_4_3_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_4_CoreBackend::versionStatus());
-        d_4_4_Core = static_cast<QOpenGLFunctions_4_4_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
-        d_1_0_Deprecated = static_cast<QOpenGLFunctions_1_0_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
-        d_1_1_Deprecated = static_cast<QOpenGLFunctions_1_1_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus());
-        d_1_2_Deprecated = static_cast<QOpenGLFunctions_1_2_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus());
-        d_1_3_Deprecated = static_cast<QOpenGLFunctions_1_3_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
-        d_1_4_Deprecated = static_cast<QOpenGLFunctions_1_4_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_DeprecatedBackend::versionStatus());
-        d_3_3_Deprecated = static_cast<QOpenGLFunctions_3_3_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        QAbstractOpenGLFunctions::initializeOpenGLFunctions();
-    }
-    return isInitialized();
-}
-
-bool QOpenGLFunctions_4_4_Compatibility::isContextCompatible(QOpenGLContext *context)
-{
-    Q_ASSERT(context);
-    QSurfaceFormat f = context->format();
-    const QPair<int, int> v = qMakePair(f.majorVersion(), f.minorVersion());
-    if (v < qMakePair(4, 4))
-        return false;
-
-    if (f.profile() == QSurfaceFormat::CoreProfile)
-        return false;
-
-    return true;
-}
-
-QOpenGLVersionProfile QOpenGLFunctions_4_4_Compatibility::versionProfile()
-{
-    QOpenGLVersionProfile v;
-    v.setVersion(4, 4);
-    v.setProfile(QSurfaceFormat::CompatibilityProfile);
-    return v;
-}
-
-QT_END_NAMESPACE
diff --git a/src/gui/opengl/qopenglfunctions_4_4_compatibility.h b/src/gui/opengl/qopenglfunctions_4_4_compatibility.h
deleted file mode 100644
index 0acab349a1..0000000000
--- a/src/gui/opengl/qopenglfunctions_4_4_compatibility.h
+++ /dev/null
@@ -1,5976 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2015 Klaralvdalens Datakonsult AB (KDAB)
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#ifndef QOPENGLVERSIONFUNCTIONS_4_4_COMPATIBILITY_H
-#define QOPENGLVERSIONFUNCTIONS_4_4_COMPATIBILITY_H
-
-#include <QtGui/qtguiglobal.h>
-
-#if !defined(QT_NO_OPENGL) && !defined(QT_OPENGL_ES_2)
-
-#include <QtGui/QOpenGLVersionFunctions>
-#include <QtGui/qopenglcontext.h>
-
-QT_BEGIN_NAMESPACE
-
-// MemoryBarrier is a macro on some architectures on Windows
-#ifdef Q_OS_WIN
-#pragma push_macro("MemoryBarrier")
-#undef MemoryBarrier
-#endif
-
-class Q_GUI_EXPORT QOpenGLFunctions_4_4_Compatibility : public QAbstractOpenGLFunctions
-{
-public:
-    QOpenGLFunctions_4_4_Compatibility();
-    ~QOpenGLFunctions_4_4_Compatibility();
-
-    bool initializeOpenGLFunctions() override;
-
-    // OpenGL 1.0 core functions
-    void glViewport(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glDepthRange(GLdouble nearVal, GLdouble farVal);
-    GLboolean glIsEnabled(GLenum cap);
-    void glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params);
-    void glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params);
-    void glGetTexParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, void *pixels);
-    const GLubyte * glGetString(GLenum name);
-    void glGetIntegerv(GLenum pname, GLint *data);
-    void glGetFloatv(GLenum pname, GLfloat *data);
-    GLenum glGetError();
-    void glGetDoublev(GLenum pname, GLdouble *data);
-    void glGetBooleanv(GLenum pname, GLboolean *data);
-    void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels);
-    void glReadBuffer(GLenum src);
-    void glPixelStorei(GLenum pname, GLint param);
-    void glPixelStoref(GLenum pname, GLfloat param);
-    void glDepthFunc(GLenum func);
-    void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass);
-    void glStencilFunc(GLenum func, GLint ref, GLuint mask);
-    void glLogicOp(GLenum opcode);
-    void glBlendFunc(GLenum sfactor, GLenum dfactor);
-    void glFlush();
-    void glFinish();
-    void glEnable(GLenum cap);
-    void glDisable(GLenum cap);
-    void glDepthMask(GLboolean flag);
-    void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
-    void glStencilMask(GLuint mask);
-    void glClearDepth(GLdouble depth);
-    void glClearStencil(GLint s);
-    void glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glClear(GLbitfield mask);
-    void glDrawBuffer(GLenum buf);
-    void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels);
-    void glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels);
-    void glTexParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glTexParameteri(GLenum target, GLenum pname, GLint param);
-    void glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glTexParameterf(GLenum target, GLenum pname, GLfloat param);
-    void glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glPolygonMode(GLenum face, GLenum mode);
-    void glPointSize(GLfloat size);
-    void glLineWidth(GLfloat width);
-    void glHint(GLenum target, GLenum mode);
-    void glFrontFace(GLenum mode);
-    void glCullFace(GLenum mode);
-
-    // OpenGL 1.1 core functions
-    GLboolean glIsTexture(GLuint texture);
-    void glGenTextures(GLsizei n, GLuint *textures);
-    void glDeleteTextures(GLsizei n, const GLuint *textures);
-    void glBindTexture(GLenum target, GLuint texture);
-    void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels);
-    void glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels);
-    void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
-    void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
-    void glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
-    void glPolygonOffset(GLfloat factor, GLfloat units);
-    void glDrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices);
-    void glDrawArrays(GLenum mode, GLint first, GLsizei count);
-
-    // OpenGL 1.2 core functions
-    void glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glBlendEquation(GLenum mode);
-    void glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels);
-    void glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels);
-    void glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices);
-
-    // OpenGL 1.3 core functions
-    void glGetCompressedTexImage(GLenum target, GLint level, void *img);
-    void glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data);
-    void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data);
-    void glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data);
-    void glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data);
-    void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data);
-    void glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data);
-    void glSampleCoverage(GLfloat value, GLboolean invert);
-    void glActiveTexture(GLenum texture);
-
-    // OpenGL 1.4 core functions
-    void glPointParameteriv(GLenum pname, const GLint *params);
-    void glPointParameteri(GLenum pname, GLint param);
-    void glPointParameterfv(GLenum pname, const GLfloat *params);
-    void glPointParameterf(GLenum pname, GLfloat param);
-    void glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const void *const *indices, GLsizei drawcount);
-    void glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount);
-    void glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
-
-    // OpenGL 1.5 core functions
-    void glGetBufferPointerv(GLenum target, GLenum pname, void * *params);
-    void glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params);
-    GLboolean glUnmapBuffer(GLenum target);
-    void * glMapBuffer(GLenum target, GLenum access);
-    void glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, void *data);
-    void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void *data);
-    void glBufferData(GLenum target, GLsizeiptr size, const void *data, GLenum usage);
-    GLboolean glIsBuffer(GLuint buffer);
-    void glGenBuffers(GLsizei n, GLuint *buffers);
-    void glDeleteBuffers(GLsizei n, const GLuint *buffers);
-    void glBindBuffer(GLenum target, GLuint buffer);
-    void glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params);
-    void glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params);
-    void glGetQueryiv(GLenum target, GLenum pname, GLint *params);
-    void glEndQuery(GLenum target);
-    void glBeginQuery(GLenum target, GLuint id);
-    GLboolean glIsQuery(GLuint id);
-    void glDeleteQueries(GLsizei n, const GLuint *ids);
-    void glGenQueries(GLsizei n, GLuint *ids);
-
-    // OpenGL 2.0 core functions
-    void glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer);
-    void glVertexAttrib4usv(GLuint index, const GLushort *v);
-    void glVertexAttrib4uiv(GLuint index, const GLuint *v);
-    void glVertexAttrib4ubv(GLuint index, const GLubyte *v);
-    void glVertexAttrib4sv(GLuint index, const GLshort *v);
-    void glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
-    void glVertexAttrib4iv(GLuint index, const GLint *v);
-    void glVertexAttrib4fv(GLuint index, const GLfloat *v);
-    void glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void glVertexAttrib4dv(GLuint index, const GLdouble *v);
-    void glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glVertexAttrib4bv(GLuint index, const GLbyte *v);
-    void glVertexAttrib4Nusv(GLuint index, const GLushort *v);
-    void glVertexAttrib4Nuiv(GLuint index, const GLuint *v);
-    void glVertexAttrib4Nubv(GLuint index, const GLubyte *v);
-    void glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
-    void glVertexAttrib4Nsv(GLuint index, const GLshort *v);
-    void glVertexAttrib4Niv(GLuint index, const GLint *v);
-    void glVertexAttrib4Nbv(GLuint index, const GLbyte *v);
-    void glVertexAttrib3sv(GLuint index, const GLshort *v);
-    void glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z);
-    void glVertexAttrib3fv(GLuint index, const GLfloat *v);
-    void glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z);
-    void glVertexAttrib3dv(GLuint index, const GLdouble *v);
-    void glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z);
-    void glVertexAttrib2sv(GLuint index, const GLshort *v);
-    void glVertexAttrib2s(GLuint index, GLshort x, GLshort y);
-    void glVertexAttrib2fv(GLuint index, const GLfloat *v);
-    void glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y);
-    void glVertexAttrib2dv(GLuint index, const GLdouble *v);
-    void glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y);
-    void glVertexAttrib1sv(GLuint index, const GLshort *v);
-    void glVertexAttrib1s(GLuint index, GLshort x);
-    void glVertexAttrib1fv(GLuint index, const GLfloat *v);
-    void glVertexAttrib1f(GLuint index, GLfloat x);
-    void glVertexAttrib1dv(GLuint index, const GLdouble *v);
-    void glVertexAttrib1d(GLuint index, GLdouble x);
-    void glValidateProgram(GLuint program);
-    void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniform4iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform3iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform2iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform1iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform4fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform3fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform2fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform1fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
-    void glUniform3i(GLint location, GLint v0, GLint v1, GLint v2);
-    void glUniform2i(GLint location, GLint v0, GLint v1);
-    void glUniform1i(GLint location, GLint v0);
-    void glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
-    void glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
-    void glUniform2f(GLint location, GLfloat v0, GLfloat v1);
-    void glUniform1f(GLint location, GLfloat v0);
-    void glUseProgram(GLuint program);
-    void glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length);
-    void glLinkProgram(GLuint program);
-    GLboolean glIsShader(GLuint shader);
-    GLboolean glIsProgram(GLuint program);
-    void glGetVertexAttribPointerv(GLuint index, GLenum pname, void * *pointer);
-    void glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params);
-    void glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params);
-    void glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params);
-    void glGetUniformiv(GLuint program, GLint location, GLint *params);
-    void glGetUniformfv(GLuint program, GLint location, GLfloat *params);
-    GLint glGetUniformLocation(GLuint program, const GLchar *name);
-    void glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source);
-    void glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void glGetShaderiv(GLuint shader, GLenum pname, GLint *params);
-    void glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void glGetProgramiv(GLuint program, GLenum pname, GLint *params);
-    GLint glGetAttribLocation(GLuint program, const GLchar *name);
-    void glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders);
-    void glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
-    void glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
-    void glEnableVertexAttribArray(GLuint index);
-    void glDisableVertexAttribArray(GLuint index);
-    void glDetachShader(GLuint program, GLuint shader);
-    void glDeleteShader(GLuint shader);
-    void glDeleteProgram(GLuint program);
-    GLuint glCreateShader(GLenum type);
-    GLuint glCreateProgram();
-    void glCompileShader(GLuint shader);
-    void glBindAttribLocation(GLuint program, GLuint index, const GLchar *name);
-    void glAttachShader(GLuint program, GLuint shader);
-    void glStencilMaskSeparate(GLenum face, GLuint mask);
-    void glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask);
-    void glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);
-    void glDrawBuffers(GLsizei n, const GLenum *bufs);
-    void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha);
-
-    // OpenGL 2.1 core functions
-    void glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-
-    // OpenGL 3.0 core functions
-    GLboolean glIsVertexArray(GLuint array);
-    void glGenVertexArrays(GLsizei n, GLuint *arrays);
-    void glDeleteVertexArrays(GLsizei n, const GLuint *arrays);
-    void glBindVertexArray(GLuint array);
-    void glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length);
-    void * glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
-    void glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
-    void glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
-    void glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
-    void glGenerateMipmap(GLenum target);
-    void glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params);
-    void glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
-    void glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset);
-    void glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
-    void glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
-    GLenum glCheckFramebufferStatus(GLenum target);
-    void glGenFramebuffers(GLsizei n, GLuint *framebuffers);
-    void glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers);
-    void glBindFramebuffer(GLenum target, GLuint framebuffer);
-    GLboolean glIsFramebuffer(GLuint framebuffer);
-    void glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
-    void glGenRenderbuffers(GLsizei n, GLuint *renderbuffers);
-    void glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers);
-    void glBindRenderbuffer(GLenum target, GLuint renderbuffer);
-    GLboolean glIsRenderbuffer(GLuint renderbuffer);
-    const GLubyte * glGetStringi(GLenum name, GLuint index);
-    void glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
-    void glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value);
-    void glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value);
-    void glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value);
-    void glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params);
-    void glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params);
-    void glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params);
-    void glTexParameterIiv(GLenum target, GLenum pname, const GLint *params);
-    void glUniform4uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform3uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform2uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform1uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
-    void glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2);
-    void glUniform2ui(GLint location, GLuint v0, GLuint v1);
-    void glUniform1ui(GLint location, GLuint v0);
-    GLint glGetFragDataLocation(GLuint program, const GLchar *name);
-    void glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name);
-    void glGetUniformuiv(GLuint program, GLint location, GLuint *params);
-    void glVertexAttribI4usv(GLuint index, const GLushort *v);
-    void glVertexAttribI4ubv(GLuint index, const GLubyte *v);
-    void glVertexAttribI4sv(GLuint index, const GLshort *v);
-    void glVertexAttribI4bv(GLuint index, const GLbyte *v);
-    void glVertexAttribI4uiv(GLuint index, const GLuint *v);
-    void glVertexAttribI3uiv(GLuint index, const GLuint *v);
-    void glVertexAttribI2uiv(GLuint index, const GLuint *v);
-    void glVertexAttribI1uiv(GLuint index, const GLuint *v);
-    void glVertexAttribI4iv(GLuint index, const GLint *v);
-    void glVertexAttribI3iv(GLuint index, const GLint *v);
-    void glVertexAttribI2iv(GLuint index, const GLint *v);
-    void glVertexAttribI1iv(GLuint index, const GLint *v);
-    void glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
-    void glVertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z);
-    void glVertexAttribI2ui(GLuint index, GLuint x, GLuint y);
-    void glVertexAttribI1ui(GLuint index, GLuint x);
-    void glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w);
-    void glVertexAttribI3i(GLuint index, GLint x, GLint y, GLint z);
-    void glVertexAttribI2i(GLuint index, GLint x, GLint y);
-    void glVertexAttribI1i(GLuint index, GLint x);
-    void glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params);
-    void glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params);
-    void glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer);
-    void glEndConditionalRender();
-    void glBeginConditionalRender(GLuint id, GLenum mode);
-    void glClampColor(GLenum target, GLenum clamp);
-    void glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name);
-    void glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode);
-    void glBindBufferBase(GLenum target, GLuint index, GLuint buffer);
-    void glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
-    void glEndTransformFeedback();
-    void glBeginTransformFeedback(GLenum primitiveMode);
-    GLboolean glIsEnabledi(GLenum target, GLuint index);
-    void glDisablei(GLenum target, GLuint index);
-    void glEnablei(GLenum target, GLuint index);
-    void glGetIntegeri_v(GLenum target, GLuint index, GLint *data);
-    void glGetBooleani_v(GLenum target, GLuint index, GLboolean *data);
-    void glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a);
-
-    // OpenGL 3.1 core functions
-    void glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);
-    void glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName);
-    void glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params);
-    GLuint glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName);
-    void glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName);
-    void glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params);
-    void glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar *const *uniformNames, GLuint *uniformIndices);
-    void glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
-    void glPrimitiveRestartIndex(GLuint index);
-    void glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer);
-    void glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount);
-    void glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount);
-
-    // OpenGL 3.2 core functions
-    void glSampleMaski(GLuint maskNumber, GLbitfield mask);
-    void glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val);
-    void glTexImage3DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
-    void glTexImage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
-    void glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level);
-    void glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params);
-    void glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data);
-    void glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values);
-    void glGetInteger64v(GLenum pname, GLint64 *data);
-    void glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout);
-    GLenum glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout);
-    void glDeleteSync(GLsync sync);
-    GLboolean glIsSync(GLsync sync);
-    GLsync glFenceSync(GLenum condition, GLbitfield flags);
-    void glProvokingVertex(GLenum mode);
-    void glMultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count, GLenum type, const void *const *indices, GLsizei drawcount, const GLint *basevertex);
-    void glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex);
-    void glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex);
-    void glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex);
-
-    // OpenGL 3.3 core functions
-    void glVertexAttribP4uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glVertexAttribP3uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glVertexAttribP2uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glVertexAttribP1uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glVertexAttribDivisor(GLuint index, GLuint divisor);
-    void glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params);
-    void glGetQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params);
-    void glQueryCounter(GLuint id, GLenum target);
-    void glGetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params);
-    void glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params);
-    void glGetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params);
-    void glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params);
-    void glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param);
-    void glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param);
-    void glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param);
-    void glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param);
-    void glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param);
-    void glSamplerParameteri(GLuint sampler, GLenum pname, GLint param);
-    void glBindSampler(GLuint unit, GLuint sampler);
-    GLboolean glIsSampler(GLuint sampler);
-    void glDeleteSamplers(GLsizei count, const GLuint *samplers);
-    void glGenSamplers(GLsizei count, GLuint *samplers);
-    GLint glGetFragDataIndex(GLuint program, const GLchar *name);
-    void glBindFragDataLocationIndexed(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name);
-
-    // OpenGL 4.0 core functions
-    void glGetQueryIndexediv(GLenum target, GLuint index, GLenum pname, GLint *params);
-    void glEndQueryIndexed(GLenum target, GLuint index);
-    void glBeginQueryIndexed(GLenum target, GLuint index, GLuint id);
-    void glDrawTransformFeedbackStream(GLenum mode, GLuint id, GLuint stream);
-    void glDrawTransformFeedback(GLenum mode, GLuint id);
-    void glResumeTransformFeedback();
-    void glPauseTransformFeedback();
-    GLboolean glIsTransformFeedback(GLuint id);
-    void glGenTransformFeedbacks(GLsizei n, GLuint *ids);
-    void glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids);
-    void glBindTransformFeedback(GLenum target, GLuint id);
-    void glPatchParameterfv(GLenum pname, const GLfloat *values);
-    void glPatchParameteri(GLenum pname, GLint value);
-    void glGetProgramStageiv(GLuint program, GLenum shadertype, GLenum pname, GLint *values);
-    void glGetUniformSubroutineuiv(GLenum shadertype, GLint location, GLuint *params);
-    void glUniformSubroutinesuiv(GLenum shadertype, GLsizei count, const GLuint *indices);
-    void glGetActiveSubroutineName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name);
-    void glGetActiveSubroutineUniformName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name);
-    void glGetActiveSubroutineUniformiv(GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values);
-    GLuint glGetSubroutineIndex(GLuint program, GLenum shadertype, const GLchar *name);
-    GLint glGetSubroutineUniformLocation(GLuint program, GLenum shadertype, const GLchar *name);
-    void glGetUniformdv(GLuint program, GLint location, GLdouble *params);
-    void glUniformMatrix4x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix4x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix3x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix3x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix2x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix2x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniform4dv(GLint location, GLsizei count, const GLdouble *value);
-    void glUniform3dv(GLint location, GLsizei count, const GLdouble *value);
-    void glUniform2dv(GLint location, GLsizei count, const GLdouble *value);
-    void glUniform1dv(GLint location, GLsizei count, const GLdouble *value);
-    void glUniform4d(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glUniform3d(GLint location, GLdouble x, GLdouble y, GLdouble z);
-    void glUniform2d(GLint location, GLdouble x, GLdouble y);
-    void glUniform1d(GLint location, GLdouble x);
-    void glDrawElementsIndirect(GLenum mode, GLenum type, const void *indirect);
-    void glDrawArraysIndirect(GLenum mode, const void *indirect);
-    void glBlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
-    void glBlendFunci(GLuint buf, GLenum src, GLenum dst);
-    void glBlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha);
-    void glBlendEquationi(GLuint buf, GLenum mode);
-    void glMinSampleShading(GLfloat value);
-
-    // OpenGL 4.1 core functions
-    void glGetDoublei_v(GLenum target, GLuint index, GLdouble *data);
-    void glGetFloati_v(GLenum target, GLuint index, GLfloat *data);
-    void glDepthRangeIndexed(GLuint index, GLdouble n, GLdouble f);
-    void glDepthRangeArrayv(GLuint first, GLsizei count, const GLdouble *v);
-    void glScissorIndexedv(GLuint index, const GLint *v);
-    void glScissorIndexed(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height);
-    void glScissorArrayv(GLuint first, GLsizei count, const GLint *v);
-    void glViewportIndexedfv(GLuint index, const GLfloat *v);
-    void glViewportIndexedf(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h);
-    void glViewportArrayv(GLuint first, GLsizei count, const GLfloat *v);
-    void glGetVertexAttribLdv(GLuint index, GLenum pname, GLdouble *params);
-    void glVertexAttribLPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer);
-    void glVertexAttribL4dv(GLuint index, const GLdouble *v);
-    void glVertexAttribL3dv(GLuint index, const GLdouble *v);
-    void glVertexAttribL2dv(GLuint index, const GLdouble *v);
-    void glVertexAttribL1dv(GLuint index, const GLdouble *v);
-    void glVertexAttribL4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glVertexAttribL3d(GLuint index, GLdouble x, GLdouble y, GLdouble z);
-    void glVertexAttribL2d(GLuint index, GLdouble x, GLdouble y);
-    void glVertexAttribL1d(GLuint index, GLdouble x);
-    void glGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void glValidateProgramPipeline(GLuint pipeline);
-    void glProgramUniformMatrix4x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix3x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix4x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix2x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix3x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix2x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix4x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix3x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix4x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix2x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix3x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix2x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniform4uiv(GLuint program, GLint location, GLsizei count, const GLuint *value);
-    void glProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
-    void glProgramUniform4dv(GLuint program, GLint location, GLsizei count, const GLdouble *value);
-    void glProgramUniform4d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3);
-    void glProgramUniform4fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-    void glProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
-    void glProgramUniform4iv(GLuint program, GLint location, GLsizei count, const GLint *value);
-    void glProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
-    void glProgramUniform3uiv(GLuint program, GLint location, GLsizei count, const GLuint *value);
-    void glProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2);
-    void glProgramUniform3dv(GLuint program, GLint location, GLsizei count, const GLdouble *value);
-    void glProgramUniform3d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2);
-    void glProgramUniform3fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-    void glProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
-    void glProgramUniform3iv(GLuint program, GLint location, GLsizei count, const GLint *value);
-    void glProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2);
-    void glProgramUniform2uiv(GLuint program, GLint location, GLsizei count, const GLuint *value);
-    void glProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1);
-    void glProgramUniform2dv(GLuint program, GLint location, GLsizei count, const GLdouble *value);
-    void glProgramUniform2d(GLuint program, GLint location, GLdouble v0, GLdouble v1);
-    void glProgramUniform2fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-    void glProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1);
-    void glProgramUniform2iv(GLuint program, GLint location, GLsizei count, const GLint *value);
-    void glProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1);
-    void glProgramUniform1uiv(GLuint program, GLint location, GLsizei count, const GLuint *value);
-    void glProgramUniform1ui(GLuint program, GLint location, GLuint v0);
-    void glProgramUniform1dv(GLuint program, GLint location, GLsizei count, const GLdouble *value);
-    void glProgramUniform1d(GLuint program, GLint location, GLdouble v0);
-    void glProgramUniform1fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-    void glProgramUniform1f(GLuint program, GLint location, GLfloat v0);
-    void glProgramUniform1iv(GLuint program, GLint location, GLsizei count, const GLint *value);
-    void glProgramUniform1i(GLuint program, GLint location, GLint v0);
-    void glGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params);
-    GLboolean glIsProgramPipeline(GLuint pipeline);
-    void glGenProgramPipelines(GLsizei n, GLuint *pipelines);
-    void glDeleteProgramPipelines(GLsizei n, const GLuint *pipelines);
-    void glBindProgramPipeline(GLuint pipeline);
-    GLuint glCreateShaderProgramv(GLenum type, GLsizei count, const GLchar* const *strings);
-    void glActiveShaderProgram(GLuint pipeline, GLuint program);
-    void glUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program);
-    void glProgramParameteri(GLuint program, GLenum pname, GLint value);
-    void glProgramBinary(GLuint program, GLenum binaryFormat, const void *binary, GLsizei length);
-    void glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, void *binary);
-    void glClearDepthf(GLfloat dd);
-    void glDepthRangef(GLfloat n, GLfloat f);
-    void glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision);
-    void glShaderBinary(GLsizei count, const GLuint *shaders, GLenum binaryformat, const void *binary, GLsizei length);
-    void glReleaseShaderCompiler();
-
-    // OpenGL 4.2 core functions
-    void glDrawTransformFeedbackStreamInstanced(GLenum mode, GLuint id, GLuint stream, GLsizei instancecount);
-    void glDrawTransformFeedbackInstanced(GLenum mode, GLuint id, GLsizei instancecount);
-    void glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
-    void glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);
-    void glTexStorage1D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width);
-    void glMemoryBarrier(GLbitfield barriers);
-    void glBindImageTexture(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format);
-    void glGetActiveAtomicCounterBufferiv(GLuint program, GLuint bufferIndex, GLenum pname, GLint *params);
-    void glGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params);
-    void glDrawElementsInstancedBaseVertexBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance);
-    void glDrawElementsInstancedBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLuint baseinstance);
-    void glDrawArraysInstancedBaseInstance(GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance);
-
-    // OpenGL 4.3 core functions
-    void glGetObjectPtrLabel(const void *ptr, GLsizei bufSize, GLsizei *length, GLchar *label);
-    void glObjectPtrLabel(const void *ptr, GLsizei length, const GLchar *label);
-    void glGetObjectLabel(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label);
-    void glObjectLabel(GLenum identifier, GLuint name, GLsizei length, const GLchar *label);
-    void glPopDebugGroup();
-    void glPushDebugGroup(GLenum source, GLuint id, GLsizei length, const GLchar *message);
-    GLuint glGetDebugMessageLog(GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog);
-    void glDebugMessageCallback(GLDEBUGPROC callback, const void *userParam);
-    void glDebugMessageInsert(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf);
-    void glDebugMessageControl(GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled);
-    void glVertexBindingDivisor(GLuint bindingindex, GLuint divisor);
-    void glVertexAttribBinding(GLuint attribindex, GLuint bindingindex);
-    void glVertexAttribLFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);
-    void glVertexAttribIFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);
-    void glVertexAttribFormat(GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset);
-    void glBindVertexBuffer(GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride);
-    void glTextureView(GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers);
-    void glTexStorage3DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
-    void glTexStorage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
-    void glTexBufferRange(GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size);
-    void glShaderStorageBlockBinding(GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding);
-    GLint glGetProgramResourceLocationIndex(GLuint program, GLenum programInterface, const GLchar *name);
-    GLint glGetProgramResourceLocation(GLuint program, GLenum programInterface, const GLchar *name);
-    void glGetProgramResourceiv(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params);
-    void glGetProgramResourceName(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name);
-    GLuint glGetProgramResourceIndex(GLuint program, GLenum programInterface, const GLchar *name);
-    void glGetProgramInterfaceiv(GLuint program, GLenum programInterface, GLenum pname, GLint *params);
-    void glMultiDrawElementsIndirect(GLenum mode, GLenum type, const void *indirect, GLsizei drawcount, GLsizei stride);
-    void glMultiDrawArraysIndirect(GLenum mode, const void *indirect, GLsizei drawcount, GLsizei stride);
-    void glInvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glInvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments);
-    void glInvalidateBufferData(GLuint buffer);
-    void glInvalidateBufferSubData(GLuint buffer, GLintptr offset, GLsizeiptr length);
-    void glInvalidateTexImage(GLuint texture, GLint level);
-    void glInvalidateTexSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth);
-    void glGetInternalformati64v(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint64 *params);
-    void glGetFramebufferParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glFramebufferParameteri(GLenum target, GLenum pname, GLint param);
-    void glCopyImageSubData(GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth);
-    void glDispatchComputeIndirect(GLintptr indirect);
-    void glDispatchCompute(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z);
-    void glClearBufferSubData(GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data);
-    void glClearBufferData(GLenum target, GLenum internalformat, GLenum format, GLenum type, const void *data);
-
-    // OpenGL 4.4 core functions
-    void glBindVertexBuffers(GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides);
-    void glBindImageTextures(GLuint first, GLsizei count, const GLuint *textures);
-    void glBindSamplers(GLuint first, GLsizei count, const GLuint *samplers);
-    void glBindTextures(GLuint first, GLsizei count, const GLuint *textures);
-    void glBindBuffersRange(GLenum target, GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizeiptr *sizes);
-    void glBindBuffersBase(GLenum target, GLuint first, GLsizei count, const GLuint *buffers);
-    void glClearTexSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *data);
-    void glClearTexImage(GLuint texture, GLint level, GLenum format, GLenum type, const void *data);
-    void glBufferStorage(GLenum target, GLsizeiptr size, const void *data, GLbitfield flags);
-
-    // OpenGL 1.0 deprecated functions
-    void glTranslatef(GLfloat x, GLfloat y, GLfloat z);
-    void glTranslated(GLdouble x, GLdouble y, GLdouble z);
-    void glScalef(GLfloat x, GLfloat y, GLfloat z);
-    void glScaled(GLdouble x, GLdouble y, GLdouble z);
-    void glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
-    void glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
-    void glPushMatrix();
-    void glPopMatrix();
-    void glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
-    void glMultMatrixd(const GLdouble *m);
-    void glMultMatrixf(const GLfloat *m);
-    void glMatrixMode(GLenum mode);
-    void glLoadMatrixd(const GLdouble *m);
-    void glLoadMatrixf(const GLfloat *m);
-    void glLoadIdentity();
-    void glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
-    GLboolean glIsList(GLuint list);
-    void glGetTexGeniv(GLenum coord, GLenum pname, GLint *params);
-    void glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params);
-    void glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params);
-    void glGetTexEnviv(GLenum target, GLenum pname, GLint *params);
-    void glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetPolygonStipple(GLubyte *mask);
-    void glGetPixelMapusv(GLenum map, GLushort *values);
-    void glGetPixelMapuiv(GLenum map, GLuint *values);
-    void glGetPixelMapfv(GLenum map, GLfloat *values);
-    void glGetMaterialiv(GLenum face, GLenum pname, GLint *params);
-    void glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params);
-    void glGetMapiv(GLenum target, GLenum query, GLint *v);
-    void glGetMapfv(GLenum target, GLenum query, GLfloat *v);
-    void glGetMapdv(GLenum target, GLenum query, GLdouble *v);
-    void glGetLightiv(GLenum light, GLenum pname, GLint *params);
-    void glGetLightfv(GLenum light, GLenum pname, GLfloat *params);
-    void glGetClipPlane(GLenum plane, GLdouble *equation);
-    void glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels);
-    void glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
-    void glPixelMapusv(GLenum map, GLsizei mapsize, const GLushort *values);
-    void glPixelMapuiv(GLenum map, GLsizei mapsize, const GLuint *values);
-    void glPixelMapfv(GLenum map, GLsizei mapsize, const GLfloat *values);
-    void glPixelTransferi(GLenum pname, GLint param);
-    void glPixelTransferf(GLenum pname, GLfloat param);
-    void glPixelZoom(GLfloat xfactor, GLfloat yfactor);
-    void glAlphaFunc(GLenum func, GLfloat ref);
-    void glEvalPoint2(GLint i, GLint j);
-    void glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
-    void glEvalPoint1(GLint i);
-    void glEvalMesh1(GLenum mode, GLint i1, GLint i2);
-    void glEvalCoord2fv(const GLfloat *u);
-    void glEvalCoord2f(GLfloat u, GLfloat v);
-    void glEvalCoord2dv(const GLdouble *u);
-    void glEvalCoord2d(GLdouble u, GLdouble v);
-    void glEvalCoord1fv(const GLfloat *u);
-    void glEvalCoord1f(GLfloat u);
-    void glEvalCoord1dv(const GLdouble *u);
-    void glEvalCoord1d(GLdouble u);
-    void glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
-    void glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
-    void glMapGrid1f(GLint un, GLfloat u1, GLfloat u2);
-    void glMapGrid1d(GLint un, GLdouble u1, GLdouble u2);
-    void glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);
-    void glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);
-    void glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);
-    void glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);
-    void glPushAttrib(GLbitfield mask);
-    void glPopAttrib();
-    void glAccum(GLenum op, GLfloat value);
-    void glIndexMask(GLuint mask);
-    void glClearIndex(GLfloat c);
-    void glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glPushName(GLuint name);
-    void glPopName();
-    void glPassThrough(GLfloat token);
-    void glLoadName(GLuint name);
-    void glInitNames();
-    GLint glRenderMode(GLenum mode);
-    void glSelectBuffer(GLsizei size, GLuint *buffer);
-    void glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer);
-    void glTexGeniv(GLenum coord, GLenum pname, const GLint *params);
-    void glTexGeni(GLenum coord, GLenum pname, GLint param);
-    void glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params);
-    void glTexGenf(GLenum coord, GLenum pname, GLfloat param);
-    void glTexGendv(GLenum coord, GLenum pname, const GLdouble *params);
-    void glTexGend(GLenum coord, GLenum pname, GLdouble param);
-    void glTexEnviv(GLenum target, GLenum pname, const GLint *params);
-    void glTexEnvi(GLenum target, GLenum pname, GLint param);
-    void glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glTexEnvf(GLenum target, GLenum pname, GLfloat param);
-    void glShadeModel(GLenum mode);
-    void glPolygonStipple(const GLubyte *mask);
-    void glMaterialiv(GLenum face, GLenum pname, const GLint *params);
-    void glMateriali(GLenum face, GLenum pname, GLint param);
-    void glMaterialfv(GLenum face, GLenum pname, const GLfloat *params);
-    void glMaterialf(GLenum face, GLenum pname, GLfloat param);
-    void glLineStipple(GLint factor, GLushort pattern);
-    void glLightModeliv(GLenum pname, const GLint *params);
-    void glLightModeli(GLenum pname, GLint param);
-    void glLightModelfv(GLenum pname, const GLfloat *params);
-    void glLightModelf(GLenum pname, GLfloat param);
-    void glLightiv(GLenum light, GLenum pname, const GLint *params);
-    void glLighti(GLenum light, GLenum pname, GLint param);
-    void glLightfv(GLenum light, GLenum pname, const GLfloat *params);
-    void glLightf(GLenum light, GLenum pname, GLfloat param);
-    void glFogiv(GLenum pname, const GLint *params);
-    void glFogi(GLenum pname, GLint param);
-    void glFogfv(GLenum pname, const GLfloat *params);
-    void glFogf(GLenum pname, GLfloat param);
-    void glColorMaterial(GLenum face, GLenum mode);
-    void glClipPlane(GLenum plane, const GLdouble *equation);
-    void glVertex4sv(const GLshort *v);
-    void glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w);
-    void glVertex4iv(const GLint *v);
-    void glVertex4i(GLint x, GLint y, GLint z, GLint w);
-    void glVertex4fv(const GLfloat *v);
-    void glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void glVertex4dv(const GLdouble *v);
-    void glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glVertex3sv(const GLshort *v);
-    void glVertex3s(GLshort x, GLshort y, GLshort z);
-    void glVertex3iv(const GLint *v);
-    void glVertex3i(GLint x, GLint y, GLint z);
-    void glVertex3fv(const GLfloat *v);
-    void glVertex3f(GLfloat x, GLfloat y, GLfloat z);
-    void glVertex3dv(const GLdouble *v);
-    void glVertex3d(GLdouble x, GLdouble y, GLdouble z);
-    void glVertex2sv(const GLshort *v);
-    void glVertex2s(GLshort x, GLshort y);
-    void glVertex2iv(const GLint *v);
-    void glVertex2i(GLint x, GLint y);
-    void glVertex2fv(const GLfloat *v);
-    void glVertex2f(GLfloat x, GLfloat y);
-    void glVertex2dv(const GLdouble *v);
-    void glVertex2d(GLdouble x, GLdouble y);
-    void glTexCoord4sv(const GLshort *v);
-    void glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q);
-    void glTexCoord4iv(const GLint *v);
-    void glTexCoord4i(GLint s, GLint t, GLint r, GLint q);
-    void glTexCoord4fv(const GLfloat *v);
-    void glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
-    void glTexCoord4dv(const GLdouble *v);
-    void glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q);
-    void glTexCoord3sv(const GLshort *v);
-    void glTexCoord3s(GLshort s, GLshort t, GLshort r);
-    void glTexCoord3iv(const GLint *v);
-    void glTexCoord3i(GLint s, GLint t, GLint r);
-    void glTexCoord3fv(const GLfloat *v);
-    void glTexCoord3f(GLfloat s, GLfloat t, GLfloat r);
-    void glTexCoord3dv(const GLdouble *v);
-    void glTexCoord3d(GLdouble s, GLdouble t, GLdouble r);
-    void glTexCoord2sv(const GLshort *v);
-    void glTexCoord2s(GLshort s, GLshort t);
-    void glTexCoord2iv(const GLint *v);
-    void glTexCoord2i(GLint s, GLint t);
-    void glTexCoord2fv(const GLfloat *v);
-    void glTexCoord2f(GLfloat s, GLfloat t);
-    void glTexCoord2dv(const GLdouble *v);
-    void glTexCoord2d(GLdouble s, GLdouble t);
-    void glTexCoord1sv(const GLshort *v);
-    void glTexCoord1s(GLshort s);
-    void glTexCoord1iv(const GLint *v);
-    void glTexCoord1i(GLint s);
-    void glTexCoord1fv(const GLfloat *v);
-    void glTexCoord1f(GLfloat s);
-    void glTexCoord1dv(const GLdouble *v);
-    void glTexCoord1d(GLdouble s);
-    void glRectsv(const GLshort *v1, const GLshort *v2);
-    void glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
-    void glRectiv(const GLint *v1, const GLint *v2);
-    void glRecti(GLint x1, GLint y1, GLint x2, GLint y2);
-    void glRectfv(const GLfloat *v1, const GLfloat *v2);
-    void glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
-    void glRectdv(const GLdouble *v1, const GLdouble *v2);
-    void glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
-    void glRasterPos4sv(const GLshort *v);
-    void glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w);
-    void glRasterPos4iv(const GLint *v);
-    void glRasterPos4i(GLint x, GLint y, GLint z, GLint w);
-    void glRasterPos4fv(const GLfloat *v);
-    void glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void glRasterPos4dv(const GLdouble *v);
-    void glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glRasterPos3sv(const GLshort *v);
-    void glRasterPos3s(GLshort x, GLshort y, GLshort z);
-    void glRasterPos3iv(const GLint *v);
-    void glRasterPos3i(GLint x, GLint y, GLint z);
-    void glRasterPos3fv(const GLfloat *v);
-    void glRasterPos3f(GLfloat x, GLfloat y, GLfloat z);
-    void glRasterPos3dv(const GLdouble *v);
-    void glRasterPos3d(GLdouble x, GLdouble y, GLdouble z);
-    void glRasterPos2sv(const GLshort *v);
-    void glRasterPos2s(GLshort x, GLshort y);
-    void glRasterPos2iv(const GLint *v);
-    void glRasterPos2i(GLint x, GLint y);
-    void glRasterPos2fv(const GLfloat *v);
-    void glRasterPos2f(GLfloat x, GLfloat y);
-    void glRasterPos2dv(const GLdouble *v);
-    void glRasterPos2d(GLdouble x, GLdouble y);
-    void glNormal3sv(const GLshort *v);
-    void glNormal3s(GLshort nx, GLshort ny, GLshort nz);
-    void glNormal3iv(const GLint *v);
-    void glNormal3i(GLint nx, GLint ny, GLint nz);
-    void glNormal3fv(const GLfloat *v);
-    void glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz);
-    void glNormal3dv(const GLdouble *v);
-    void glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz);
-    void glNormal3bv(const GLbyte *v);
-    void glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz);
-    void glIndexsv(const GLshort *c);
-    void glIndexs(GLshort c);
-    void glIndexiv(const GLint *c);
-    void glIndexi(GLint c);
-    void glIndexfv(const GLfloat *c);
-    void glIndexf(GLfloat c);
-    void glIndexdv(const GLdouble *c);
-    void glIndexd(GLdouble c);
-    void glEnd();
-    void glEdgeFlagv(const GLboolean *flag);
-    void glEdgeFlag(GLboolean flag);
-    void glColor4usv(const GLushort *v);
-    void glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha);
-    void glColor4uiv(const GLuint *v);
-    void glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha);
-    void glColor4ubv(const GLubyte *v);
-    void glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
-    void glColor4sv(const GLshort *v);
-    void glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha);
-    void glColor4iv(const GLint *v);
-    void glColor4i(GLint red, GLint green, GLint blue, GLint alpha);
-    void glColor4fv(const GLfloat *v);
-    void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glColor4dv(const GLdouble *v);
-    void glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
-    void glColor4bv(const GLbyte *v);
-    void glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
-    void glColor3usv(const GLushort *v);
-    void glColor3us(GLushort red, GLushort green, GLushort blue);
-    void glColor3uiv(const GLuint *v);
-    void glColor3ui(GLuint red, GLuint green, GLuint blue);
-    void glColor3ubv(const GLubyte *v);
-    void glColor3ub(GLubyte red, GLubyte green, GLubyte blue);
-    void glColor3sv(const GLshort *v);
-    void glColor3s(GLshort red, GLshort green, GLshort blue);
-    void glColor3iv(const GLint *v);
-    void glColor3i(GLint red, GLint green, GLint blue);
-    void glColor3fv(const GLfloat *v);
-    void glColor3f(GLfloat red, GLfloat green, GLfloat blue);
-    void glColor3dv(const GLdouble *v);
-    void glColor3d(GLdouble red, GLdouble green, GLdouble blue);
-    void glColor3bv(const GLbyte *v);
-    void glColor3b(GLbyte red, GLbyte green, GLbyte blue);
-    void glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap);
-    void glBegin(GLenum mode);
-    void glListBase(GLuint base);
-    GLuint glGenLists(GLsizei range);
-    void glDeleteLists(GLuint list, GLsizei range);
-    void glCallLists(GLsizei n, GLenum type, const void *lists);
-    void glCallList(GLuint list);
-    void glEndList();
-    void glNewList(GLuint list, GLenum mode);
-
-    // OpenGL 1.1 deprecated functions
-    void glPushClientAttrib(GLbitfield mask);
-    void glPopClientAttrib();
-    void glIndexubv(const GLubyte *c);
-    void glIndexub(GLubyte c);
-    void glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities);
-    GLboolean glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences);
-    void glVertexPointer(GLint size, GLenum type, GLsizei stride, const void *pointer);
-    void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const void *pointer);
-    void glNormalPointer(GLenum type, GLsizei stride, const void *pointer);
-    void glInterleavedArrays(GLenum format, GLsizei stride, const void *pointer);
-    void glGetPointerv(GLenum pname, void * *params);
-    void glIndexPointer(GLenum type, GLsizei stride, const void *pointer);
-    void glEnableClientState(GLenum array);
-    void glEdgeFlagPointer(GLsizei stride, const void *pointer);
-    void glDisableClientState(GLenum array);
-    void glColorPointer(GLint size, GLenum type, GLsizei stride, const void *pointer);
-    void glArrayElement(GLint i);
-
-    // OpenGL 1.2 deprecated functions
-    void glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void *table);
-    void glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
-    void glGetColorTable(GLenum target, GLenum format, GLenum type, void *table);
-    void glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const void *data);
-    void glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width);
-    void glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void *image);
-    void glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *image);
-    void glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params);
-    void glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glConvolutionParameteri(GLenum target, GLenum pname, GLint params);
-    void glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
-    void glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, void *image);
-    void glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetSeparableFilter(GLenum target, GLenum format, GLenum type, void *row, void *column, void *span);
-    void glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *row, const void *column);
-    void glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, void *values);
-    void glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, void *values);
-    void glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink);
-    void glMinmax(GLenum target, GLenum internalformat, GLboolean sink);
-    void glResetHistogram(GLenum target);
-    void glResetMinmax(GLenum target);
-
-    // OpenGL 1.3 deprecated functions
-    void glMultTransposeMatrixd(const GLdouble *m);
-    void glMultTransposeMatrixf(const GLfloat *m);
-    void glLoadTransposeMatrixd(const GLdouble *m);
-    void glLoadTransposeMatrixf(const GLfloat *m);
-    void glMultiTexCoord4sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);
-    void glMultiTexCoord4iv(GLenum target, const GLint *v);
-    void glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q);
-    void glMultiTexCoord4fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
-    void glMultiTexCoord4dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
-    void glMultiTexCoord3sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r);
-    void glMultiTexCoord3iv(GLenum target, const GLint *v);
-    void glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r);
-    void glMultiTexCoord3fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r);
-    void glMultiTexCoord3dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r);
-    void glMultiTexCoord2sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord2s(GLenum target, GLshort s, GLshort t);
-    void glMultiTexCoord2iv(GLenum target, const GLint *v);
-    void glMultiTexCoord2i(GLenum target, GLint s, GLint t);
-    void glMultiTexCoord2fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t);
-    void glMultiTexCoord2dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t);
-    void glMultiTexCoord1sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord1s(GLenum target, GLshort s);
-    void glMultiTexCoord1iv(GLenum target, const GLint *v);
-    void glMultiTexCoord1i(GLenum target, GLint s);
-    void glMultiTexCoord1fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord1f(GLenum target, GLfloat s);
-    void glMultiTexCoord1dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord1d(GLenum target, GLdouble s);
-    void glClientActiveTexture(GLenum texture);
-
-    // OpenGL 1.4 deprecated functions
-    void glWindowPos3sv(const GLshort *v);
-    void glWindowPos3s(GLshort x, GLshort y, GLshort z);
-    void glWindowPos3iv(const GLint *v);
-    void glWindowPos3i(GLint x, GLint y, GLint z);
-    void glWindowPos3fv(const GLfloat *v);
-    void glWindowPos3f(GLfloat x, GLfloat y, GLfloat z);
-    void glWindowPos3dv(const GLdouble *v);
-    void glWindowPos3d(GLdouble x, GLdouble y, GLdouble z);
-    void glWindowPos2sv(const GLshort *v);
-    void glWindowPos2s(GLshort x, GLshort y);
-    void glWindowPos2iv(const GLint *v);
-    void glWindowPos2i(GLint x, GLint y);
-    void glWindowPos2fv(const GLfloat *v);
-    void glWindowPos2f(GLfloat x, GLfloat y);
-    void glWindowPos2dv(const GLdouble *v);
-    void glWindowPos2d(GLdouble x, GLdouble y);
-    void glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const void *pointer);
-    void glSecondaryColor3usv(const GLushort *v);
-    void glSecondaryColor3us(GLushort red, GLushort green, GLushort blue);
-    void glSecondaryColor3uiv(const GLuint *v);
-    void glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue);
-    void glSecondaryColor3ubv(const GLubyte *v);
-    void glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue);
-    void glSecondaryColor3sv(const GLshort *v);
-    void glSecondaryColor3s(GLshort red, GLshort green, GLshort blue);
-    void glSecondaryColor3iv(const GLint *v);
-    void glSecondaryColor3i(GLint red, GLint green, GLint blue);
-    void glSecondaryColor3fv(const GLfloat *v);
-    void glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue);
-    void glSecondaryColor3dv(const GLdouble *v);
-    void glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue);
-    void glSecondaryColor3bv(const GLbyte *v);
-    void glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue);
-    void glFogCoordPointer(GLenum type, GLsizei stride, const void *pointer);
-    void glFogCoorddv(const GLdouble *coord);
-    void glFogCoordd(GLdouble coord);
-    void glFogCoordfv(const GLfloat *coord);
-    void glFogCoordf(GLfloat coord);
-
-    // OpenGL 1.5 deprecated functions
-
-    // OpenGL 2.0 deprecated functions
-
-    // OpenGL 2.1 deprecated functions
-
-    // OpenGL 3.0 deprecated functions
-
-    // OpenGL 3.1 deprecated functions
-
-    // OpenGL 3.2 deprecated functions
-
-    // OpenGL 3.3 deprecated functions
-    void glSecondaryColorP3uiv(GLenum type, const GLuint *color);
-    void glSecondaryColorP3ui(GLenum type, GLuint color);
-    void glColorP4uiv(GLenum type, const GLuint *color);
-    void glColorP4ui(GLenum type, GLuint color);
-    void glColorP3uiv(GLenum type, const GLuint *color);
-    void glColorP3ui(GLenum type, GLuint color);
-    void glNormalP3uiv(GLenum type, const GLuint *coords);
-    void glNormalP3ui(GLenum type, GLuint coords);
-    void glMultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint *coords);
-    void glMultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords);
-    void glMultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint *coords);
-    void glMultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords);
-    void glMultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint *coords);
-    void glMultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords);
-    void glMultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint *coords);
-    void glMultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords);
-    void glTexCoordP4uiv(GLenum type, const GLuint *coords);
-    void glTexCoordP4ui(GLenum type, GLuint coords);
-    void glTexCoordP3uiv(GLenum type, const GLuint *coords);
-    void glTexCoordP3ui(GLenum type, GLuint coords);
-    void glTexCoordP2uiv(GLenum type, const GLuint *coords);
-    void glTexCoordP2ui(GLenum type, GLuint coords);
-    void glTexCoordP1uiv(GLenum type, const GLuint *coords);
-    void glTexCoordP1ui(GLenum type, GLuint coords);
-    void glVertexP4uiv(GLenum type, const GLuint *value);
-    void glVertexP4ui(GLenum type, GLuint value);
-    void glVertexP3uiv(GLenum type, const GLuint *value);
-    void glVertexP3ui(GLenum type, GLuint value);
-    void glVertexP2uiv(GLenum type, const GLuint *value);
-    void glVertexP2ui(GLenum type, GLuint value);
-
-    // OpenGL 4.0 deprecated functions
-
-    // OpenGL 4.1 deprecated functions
-
-    // OpenGL 4.2 deprecated functions
-
-    // OpenGL 4.3 deprecated functions
-
-    // OpenGL 4.4 deprecated functions
-
-private:
-    friend class QOpenGLContext;
-
-    static bool isContextCompatible(QOpenGLContext *context);
-    static QOpenGLVersionProfile versionProfile();
-
-    QOpenGLFunctions_1_0_CoreBackend* d_1_0_Core;
-    QOpenGLFunctions_1_1_CoreBackend* d_1_1_Core;
-    QOpenGLFunctions_1_2_CoreBackend* d_1_2_Core;
-    QOpenGLFunctions_1_3_CoreBackend* d_1_3_Core;
-    QOpenGLFunctions_1_4_CoreBackend* d_1_4_Core;
-    QOpenGLFunctions_1_5_CoreBackend* d_1_5_Core;
-    QOpenGLFunctions_2_0_CoreBackend* d_2_0_Core;
-    QOpenGLFunctions_2_1_CoreBackend* d_2_1_Core;
-    QOpenGLFunctions_3_0_CoreBackend* d_3_0_Core;
-    QOpenGLFunctions_3_1_CoreBackend* d_3_1_Core;
-    QOpenGLFunctions_3_2_CoreBackend* d_3_2_Core;
-    QOpenGLFunctions_3_3_CoreBackend* d_3_3_Core;
-    QOpenGLFunctions_4_0_CoreBackend* d_4_0_Core;
-    QOpenGLFunctions_4_1_CoreBackend* d_4_1_Core;
-    QOpenGLFunctions_4_2_CoreBackend* d_4_2_Core;
-    QOpenGLFunctions_4_3_CoreBackend* d_4_3_Core;
-    QOpenGLFunctions_4_4_CoreBackend* d_4_4_Core;
-    QOpenGLFunctions_1_0_DeprecatedBackend* d_1_0_Deprecated;
-    QOpenGLFunctions_1_1_DeprecatedBackend* d_1_1_Deprecated;
-    QOpenGLFunctions_1_2_DeprecatedBackend* d_1_2_Deprecated;
-    QOpenGLFunctions_1_3_DeprecatedBackend* d_1_3_Deprecated;
-    QOpenGLFunctions_1_4_DeprecatedBackend* d_1_4_Deprecated;
-    QOpenGLFunctions_3_3_DeprecatedBackend* d_3_3_Deprecated;
-};
-
-// OpenGL 1.0 core functions
-inline void QOpenGLFunctions_4_4_Compatibility::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_0_Core->f.Viewport(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glDepthRange(GLdouble nearVal, GLdouble farVal)
-{
-    d_1_0_Core->f.DepthRange(nearVal, farVal);
-}
-
-inline GLboolean QOpenGLFunctions_4_4_Compatibility::glIsEnabled(GLenum cap)
-{
-    return d_1_0_Core->f.IsEnabled(cap);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetTexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetTexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, void *pixels)
-{
-    d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
-}
-
-inline const GLubyte * QOpenGLFunctions_4_4_Compatibility::glGetString(GLenum name)
-{
-    return d_1_0_Core->f.GetString(name);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetIntegerv(GLenum pname, GLint *data)
-{
-    d_1_0_Core->f.GetIntegerv(pname, data);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetFloatv(GLenum pname, GLfloat *data)
-{
-    d_1_0_Core->f.GetFloatv(pname, data);
-}
-
-inline GLenum QOpenGLFunctions_4_4_Compatibility::glGetError()
-{
-    return d_1_0_Core->f.GetError();
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetDoublev(GLenum pname, GLdouble *data)
-{
-    d_1_0_Core->f.GetDoublev(pname, data);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetBooleanv(GLenum pname, GLboolean *data)
-{
-    d_1_0_Core->f.GetBooleanv(pname, data);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels)
-{
-    d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glReadBuffer(GLenum src)
-{
-    d_1_0_Core->f.ReadBuffer(src);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glPixelStorei(GLenum pname, GLint param)
-{
-    d_1_0_Core->f.PixelStorei(pname, param);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glPixelStoref(GLenum pname, GLfloat param)
-{
-    d_1_0_Core->f.PixelStoref(pname, param);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glDepthFunc(GLenum func)
-{
-    d_1_0_Core->f.DepthFunc(func);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
-{
-    d_1_0_Core->f.StencilOp(fail, zfail, zpass);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glStencilFunc(GLenum func, GLint ref, GLuint mask)
-{
-    d_1_0_Core->f.StencilFunc(func, ref, mask);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glLogicOp(GLenum opcode)
-{
-    d_1_0_Core->f.LogicOp(opcode);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glBlendFunc(GLenum sfactor, GLenum dfactor)
-{
-    d_1_0_Core->f.BlendFunc(sfactor, dfactor);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glFlush()
-{
-    d_1_0_Core->f.Flush();
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glFinish()
-{
-    d_1_0_Core->f.Finish();
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glEnable(GLenum cap)
-{
-    d_1_0_Core->f.Enable(cap);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glDisable(GLenum cap)
-{
-    d_1_0_Core->f.Disable(cap);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glDepthMask(GLboolean flag)
-{
-    d_1_0_Core->f.DepthMask(flag);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
-{
-    d_1_0_Core->f.ColorMask(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glStencilMask(GLuint mask)
-{
-    d_1_0_Core->f.StencilMask(mask);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glClearDepth(GLdouble depth)
-{
-    d_1_0_Core->f.ClearDepth(depth);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glClearStencil(GLint s)
-{
-    d_1_0_Core->f.ClearStencil(s);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Core->f.ClearColor(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glClear(GLbitfield mask)
-{
-    d_1_0_Core->f.Clear(mask);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glDrawBuffer(GLenum buf)
-{
-    d_1_0_Core->f.DrawBuffer(buf);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels)
-{
-    d_1_0_Core->f.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels)
-{
-    d_1_0_Core->f.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_0_Core->f.TexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexParameteri(GLenum target, GLenum pname, GLint param)
-{
-    d_1_0_Core->f.TexParameteri(target, pname, param);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Core->f.TexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
-{
-    d_1_0_Core->f.TexParameterf(target, pname, param);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_0_Core->f.Scissor(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glPolygonMode(GLenum face, GLenum mode)
-{
-    d_1_0_Core->f.PolygonMode(face, mode);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glPointSize(GLfloat size)
-{
-    d_1_0_Core->f.PointSize(size);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glLineWidth(GLfloat width)
-{
-    d_1_0_Core->f.LineWidth(width);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glHint(GLenum target, GLenum mode)
-{
-    d_1_0_Core->f.Hint(target, mode);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glFrontFace(GLenum mode)
-{
-    d_1_0_Core->f.FrontFace(mode);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glCullFace(GLenum mode)
-{
-    d_1_0_Core->f.CullFace(mode);
-}
-
-
-// OpenGL 1.1 core functions
-inline GLboolean QOpenGLFunctions_4_4_Compatibility::glIsTexture(GLuint texture)
-{
-    return d_1_1_Core->f.IsTexture(texture);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGenTextures(GLsizei n, GLuint *textures)
-{
-    d_1_1_Core->f.GenTextures(n, textures);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glDeleteTextures(GLsizei n, const GLuint *textures)
-{
-    d_1_1_Core->f.DeleteTextures(n, textures);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glBindTexture(GLenum target, GLuint texture)
-{
-    d_1_1_Core->f.BindTexture(target, texture);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)
-{
-    d_1_1_Core->f.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels)
-{
-    d_1_1_Core->f.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_1_Core->f.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
-{
-    d_1_1_Core->f.CopyTexSubImage1D(target, level, xoffset, x, y, width);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
-{
-    d_1_1_Core->f.CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
-{
-    d_1_1_Core->f.CopyTexImage1D(target, level, internalformat, x, y, width, border);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glPolygonOffset(GLfloat factor, GLfloat units)
-{
-    d_1_1_Core->f.PolygonOffset(factor, units);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glDrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices)
-{
-    d_1_1_Core->f.DrawElements(mode, count, type, indices);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glDrawArrays(GLenum mode, GLint first, GLsizei count)
-{
-    d_1_1_Core->f.DrawArrays(mode, first, count);
-}
-
-
-// OpenGL 1.2 core functions
-inline void QOpenGLFunctions_4_4_Compatibility::glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_2_Core->f.BlendColor(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glBlendEquation(GLenum mode)
-{
-    d_1_2_Core->f.BlendEquation(mode);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_2_Core->f.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels)
-{
-    d_1_2_Core->f.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels)
-{
-    d_1_2_Core->f.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices)
-{
-    d_1_2_Core->f.DrawRangeElements(mode, start, end, count, type, indices);
-}
-
-
-// OpenGL 1.3 core functions
-inline void QOpenGLFunctions_4_4_Compatibility::glGetCompressedTexImage(GLenum target, GLint level, void *img)
-{
-    d_1_3_Core->f.GetCompressedTexImage(target, level, img);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data)
-{
-    d_1_3_Core->f.CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data)
-{
-    d_1_3_Core->f.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data)
-{
-    d_1_3_Core->f.CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glSampleCoverage(GLfloat value, GLboolean invert)
-{
-    d_1_3_Core->f.SampleCoverage(value, invert);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glActiveTexture(GLenum texture)
-{
-    d_1_3_Core->f.ActiveTexture(texture);
-}
-
-
-// OpenGL 1.4 core functions
-inline void QOpenGLFunctions_4_4_Compatibility::glPointParameteriv(GLenum pname, const GLint *params)
-{
-    d_1_4_Core->f.PointParameteriv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glPointParameteri(GLenum pname, GLint param)
-{
-    d_1_4_Core->f.PointParameteri(pname, param);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glPointParameterfv(GLenum pname, const GLfloat *params)
-{
-    d_1_4_Core->f.PointParameterfv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glPointParameterf(GLenum pname, GLfloat param)
-{
-    d_1_4_Core->f.PointParameterf(pname, param);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const void *const *indices, GLsizei drawcount)
-{
-    d_1_4_Core->f.MultiDrawElements(mode, count, type, indices, drawcount);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
-{
-    d_1_4_Core->f.MultiDrawArrays(mode, first, count, drawcount);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
-{
-    d_1_4_Core->f.BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
-}
-
-
-// OpenGL 1.5 core functions
-inline void QOpenGLFunctions_4_4_Compatibility::glGetBufferPointerv(GLenum target, GLenum pname, void * *params)
-{
-    d_1_5_Core->f.GetBufferPointerv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetBufferParameteriv(target, pname, params);
-}
-
-inline GLboolean QOpenGLFunctions_4_4_Compatibility::glUnmapBuffer(GLenum target)
-{
-    return d_1_5_Core->f.UnmapBuffer(target);
-}
-
-inline void * QOpenGLFunctions_4_4_Compatibility::glMapBuffer(GLenum target, GLenum access)
-{
-    return d_1_5_Core->f.MapBuffer(target, access);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, void *data)
-{
-    d_1_5_Core->f.GetBufferSubData(target, offset, size, data);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void *data)
-{
-    d_1_5_Core->f.BufferSubData(target, offset, size, data);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glBufferData(GLenum target, GLsizeiptr size, const void *data, GLenum usage)
-{
-    d_1_5_Core->f.BufferData(target, size, data, usage);
-}
-
-inline GLboolean QOpenGLFunctions_4_4_Compatibility::glIsBuffer(GLuint buffer)
-{
-    return d_1_5_Core->f.IsBuffer(buffer);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGenBuffers(GLsizei n, GLuint *buffers)
-{
-    d_1_5_Core->f.GenBuffers(n, buffers);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glDeleteBuffers(GLsizei n, const GLuint *buffers)
-{
-    d_1_5_Core->f.DeleteBuffers(n, buffers);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glBindBuffer(GLenum target, GLuint buffer)
-{
-    d_1_5_Core->f.BindBuffer(target, buffer);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
-{
-    d_1_5_Core->f.GetQueryObjectuiv(id, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetQueryObjectiv(id, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetQueryiv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetQueryiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glEndQuery(GLenum target)
-{
-    d_1_5_Core->f.EndQuery(target);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glBeginQuery(GLenum target, GLuint id)
-{
-    d_1_5_Core->f.BeginQuery(target, id);
-}
-
-inline GLboolean QOpenGLFunctions_4_4_Compatibility::glIsQuery(GLuint id)
-{
-    return d_1_5_Core->f.IsQuery(id);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glDeleteQueries(GLsizei n, const GLuint *ids)
-{
-    d_1_5_Core->f.DeleteQueries(n, ids);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGenQueries(GLsizei n, GLuint *ids)
-{
-    d_1_5_Core->f.GenQueries(n, ids);
-}
-
-
-// OpenGL 2.0 core functions
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer)
-{
-    d_2_0_Core->f.VertexAttribPointer(index, size, type, normalized, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib4usv(GLuint index, const GLushort *v)
-{
-    d_2_0_Core->f.VertexAttrib4usv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib4uiv(GLuint index, const GLuint *v)
-{
-    d_2_0_Core->f.VertexAttrib4uiv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib4ubv(GLuint index, const GLubyte *v)
-{
-    d_2_0_Core->f.VertexAttrib4ubv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib4sv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib4sv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
-{
-    d_2_0_Core->f.VertexAttrib4s(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib4iv(GLuint index, const GLint *v)
-{
-    d_2_0_Core->f.VertexAttrib4iv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib4fv(GLuint index, const GLfloat *v)
-{
-    d_2_0_Core->f.VertexAttrib4fv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    d_2_0_Core->f.VertexAttrib4f(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib4dv(GLuint index, const GLdouble *v)
-{
-    d_2_0_Core->f.VertexAttrib4dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_2_0_Core->f.VertexAttrib4d(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib4bv(GLuint index, const GLbyte *v)
-{
-    d_2_0_Core->f.VertexAttrib4bv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib4Nusv(GLuint index, const GLushort *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nusv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib4Nuiv(GLuint index, const GLuint *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nuiv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib4Nubv(GLuint index, const GLubyte *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nubv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
-{
-    d_2_0_Core->f.VertexAttrib4Nub(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib4Nsv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nsv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib4Niv(GLuint index, const GLint *v)
-{
-    d_2_0_Core->f.VertexAttrib4Niv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib4Nbv(GLuint index, const GLbyte *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nbv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib3sv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib3sv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
-{
-    d_2_0_Core->f.VertexAttrib3s(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib3fv(GLuint index, const GLfloat *v)
-{
-    d_2_0_Core->f.VertexAttrib3fv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
-{
-    d_2_0_Core->f.VertexAttrib3f(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib3dv(GLuint index, const GLdouble *v)
-{
-    d_2_0_Core->f.VertexAttrib3dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
-{
-    d_2_0_Core->f.VertexAttrib3d(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib2sv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib2sv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib2s(GLuint index, GLshort x, GLshort y)
-{
-    d_2_0_Core->f.VertexAttrib2s(index, x, y);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib2fv(GLuint index, const GLfloat *v)
-{
-    d_2_0_Core->f.VertexAttrib2fv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
-{
-    d_2_0_Core->f.VertexAttrib2f(index, x, y);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib2dv(GLuint index, const GLdouble *v)
-{
-    d_2_0_Core->f.VertexAttrib2dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
-{
-    d_2_0_Core->f.VertexAttrib2d(index, x, y);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib1sv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib1sv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib1s(GLuint index, GLshort x)
-{
-    d_2_0_Core->f.VertexAttrib1s(index, x);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib1fv(GLuint index, const GLfloat *v)
-{
-    d_2_0_Core->f.VertexAttrib1fv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib1f(GLuint index, GLfloat x)
-{
-    d_2_0_Core->f.VertexAttrib1f(index, x);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib1dv(GLuint index, const GLdouble *v)
-{
-    d_2_0_Core->f.VertexAttrib1dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib1d(GLuint index, GLdouble x)
-{
-    d_2_0_Core->f.VertexAttrib1d(index, x);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glValidateProgram(GLuint program)
-{
-    d_2_0_Core->f.ValidateProgram(program);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix3fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glUniform4iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform4iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glUniform3iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform3iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glUniform2iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform2iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glUniform1iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform1iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glUniform4fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform4fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glUniform3fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform3fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glUniform2fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform2fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glUniform1fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform1fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
-{
-    d_2_0_Core->f.Uniform4i(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glUniform3i(GLint location, GLint v0, GLint v1, GLint v2)
-{
-    d_2_0_Core->f.Uniform3i(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glUniform2i(GLint location, GLint v0, GLint v1)
-{
-    d_2_0_Core->f.Uniform2i(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glUniform1i(GLint location, GLint v0)
-{
-    d_2_0_Core->f.Uniform1i(location, v0);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
-{
-    d_2_0_Core->f.Uniform4f(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
-{
-    d_2_0_Core->f.Uniform3f(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glUniform2f(GLint location, GLfloat v0, GLfloat v1)
-{
-    d_2_0_Core->f.Uniform2f(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glUniform1f(GLint location, GLfloat v0)
-{
-    d_2_0_Core->f.Uniform1f(location, v0);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glUseProgram(GLuint program)
-{
-    d_2_0_Core->f.UseProgram(program);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glShaderSource(GLuint shader, GLsizei count, const GLchar *const *string, const GLint *length)
-{
-    d_2_0_Core->f.ShaderSource(shader, count, string, length);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glLinkProgram(GLuint program)
-{
-    d_2_0_Core->f.LinkProgram(program);
-}
-
-inline GLboolean QOpenGLFunctions_4_4_Compatibility::glIsShader(GLuint shader)
-{
-    return d_2_0_Core->f.IsShader(shader);
-}
-
-inline GLboolean QOpenGLFunctions_4_4_Compatibility::glIsProgram(GLuint program)
-{
-    return d_2_0_Core->f.IsProgram(program);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetVertexAttribPointerv(GLuint index, GLenum pname, void * *pointer)
-{
-    d_2_0_Core->f.GetVertexAttribPointerv(index, pname, pointer);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetVertexAttribiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
-{
-    d_2_0_Core->f.GetVertexAttribfv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
-{
-    d_2_0_Core->f.GetVertexAttribdv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetUniformiv(GLuint program, GLint location, GLint *params)
-{
-    d_2_0_Core->f.GetUniformiv(program, location, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetUniformfv(GLuint program, GLint location, GLfloat *params)
-{
-    d_2_0_Core->f.GetUniformfv(program, location, params);
-}
-
-inline GLint QOpenGLFunctions_4_4_Compatibility::glGetUniformLocation(GLuint program, const GLchar *name)
-{
-    return d_2_0_Core->f.GetUniformLocation(program, name);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
-{
-    d_2_0_Core->f.GetShaderSource(shader, bufSize, length, source);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-{
-    d_2_0_Core->f.GetShaderInfoLog(shader, bufSize, length, infoLog);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetShaderiv(GLuint shader, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetShaderiv(shader, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-{
-    d_2_0_Core->f.GetProgramInfoLog(program, bufSize, length, infoLog);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetProgramiv(GLuint program, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetProgramiv(program, pname, params);
-}
-
-inline GLint QOpenGLFunctions_4_4_Compatibility::glGetAttribLocation(GLuint program, const GLchar *name)
-{
-    return d_2_0_Core->f.GetAttribLocation(program, name);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders)
-{
-    d_2_0_Core->f.GetAttachedShaders(program, maxCount, count, shaders);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
-{
-    d_2_0_Core->f.GetActiveUniform(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
-{
-    d_2_0_Core->f.GetActiveAttrib(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glEnableVertexAttribArray(GLuint index)
-{
-    d_2_0_Core->f.EnableVertexAttribArray(index);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glDisableVertexAttribArray(GLuint index)
-{
-    d_2_0_Core->f.DisableVertexAttribArray(index);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glDetachShader(GLuint program, GLuint shader)
-{
-    d_2_0_Core->f.DetachShader(program, shader);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glDeleteShader(GLuint shader)
-{
-    d_2_0_Core->f.DeleteShader(shader);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glDeleteProgram(GLuint program)
-{
-    d_2_0_Core->f.DeleteProgram(program);
-}
-
-inline GLuint QOpenGLFunctions_4_4_Compatibility::glCreateShader(GLenum type)
-{
-    return d_2_0_Core->f.CreateShader(type);
-}
-
-inline GLuint QOpenGLFunctions_4_4_Compatibility::glCreateProgram()
-{
-    return d_2_0_Core->f.CreateProgram();
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glCompileShader(GLuint shader)
-{
-    d_2_0_Core->f.CompileShader(shader);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glBindAttribLocation(GLuint program, GLuint index, const GLchar *name)
-{
-    d_2_0_Core->f.BindAttribLocation(program, index, name);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glAttachShader(GLuint program, GLuint shader)
-{
-    d_2_0_Core->f.AttachShader(program, shader);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glStencilMaskSeparate(GLenum face, GLuint mask)
-{
-    d_2_0_Core->f.StencilMaskSeparate(face, mask);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
-{
-    d_2_0_Core->f.StencilFuncSeparate(face, func, ref, mask);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
-{
-    d_2_0_Core->f.StencilOpSeparate(face, sfail, dpfail, dppass);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glDrawBuffers(GLsizei n, const GLenum *bufs)
-{
-    d_2_0_Core->f.DrawBuffers(n, bufs);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
-{
-    d_2_0_Core->f.BlendEquationSeparate(modeRGB, modeAlpha);
-}
-
-
-// OpenGL 2.1 core functions
-inline void QOpenGLFunctions_4_4_Compatibility::glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix4x3fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix3x4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix4x2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix2x4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix3x2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix2x3fv(location, count, transpose, value);
-}
-
-
-// OpenGL 3.0 core functions
-inline GLboolean QOpenGLFunctions_4_4_Compatibility::glIsVertexArray(GLuint array)
-{
-    return d_3_0_Core->f.IsVertexArray(array);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGenVertexArrays(GLsizei n, GLuint *arrays)
-{
-    d_3_0_Core->f.GenVertexArrays(n, arrays);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glDeleteVertexArrays(GLsizei n, const GLuint *arrays)
-{
-    d_3_0_Core->f.DeleteVertexArrays(n, arrays);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glBindVertexArray(GLuint array)
-{
-    d_3_0_Core->f.BindVertexArray(array);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
-{
-    d_3_0_Core->f.FlushMappedBufferRange(target, offset, length);
-}
-
-inline void * QOpenGLFunctions_4_4_Compatibility::glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
-{
-    return d_3_0_Core->f.MapBufferRange(target, offset, length, access);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
-{
-    d_3_0_Core->f.FramebufferTextureLayer(target, attachment, texture, level, layer);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    d_3_0_Core->f.RenderbufferStorageMultisample(target, samples, internalformat, width, height);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
-{
-    d_3_0_Core->f.BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGenerateMipmap(GLenum target)
-{
-    d_3_0_Core->f.GenerateMipmap(target);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
-{
-    d_3_0_Core->f.FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
-{
-    d_3_0_Core->f.FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
-{
-    d_3_0_Core->f.FramebufferTexture2D(target, attachment, textarget, texture, level);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
-{
-    d_3_0_Core->f.FramebufferTexture1D(target, attachment, textarget, texture, level);
-}
-
-inline GLenum QOpenGLFunctions_4_4_Compatibility::glCheckFramebufferStatus(GLenum target)
-{
-    return d_3_0_Core->f.CheckFramebufferStatus(target);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGenFramebuffers(GLsizei n, GLuint *framebuffers)
-{
-    d_3_0_Core->f.GenFramebuffers(n, framebuffers);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
-{
-    d_3_0_Core->f.DeleteFramebuffers(n, framebuffers);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glBindFramebuffer(GLenum target, GLuint framebuffer)
-{
-    d_3_0_Core->f.BindFramebuffer(target, framebuffer);
-}
-
-inline GLboolean QOpenGLFunctions_4_4_Compatibility::glIsFramebuffer(GLuint framebuffer)
-{
-    return d_3_0_Core->f.IsFramebuffer(framebuffer);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetRenderbufferParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    d_3_0_Core->f.RenderbufferStorage(target, internalformat, width, height);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGenRenderbuffers(GLsizei n, GLuint *renderbuffers)
-{
-    d_3_0_Core->f.GenRenderbuffers(n, renderbuffers);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
-{
-    d_3_0_Core->f.DeleteRenderbuffers(n, renderbuffers);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glBindRenderbuffer(GLenum target, GLuint renderbuffer)
-{
-    d_3_0_Core->f.BindRenderbuffer(target, renderbuffer);
-}
-
-inline GLboolean QOpenGLFunctions_4_4_Compatibility::glIsRenderbuffer(GLuint renderbuffer)
-{
-    return d_3_0_Core->f.IsRenderbuffer(renderbuffer);
-}
-
-inline const GLubyte * QOpenGLFunctions_4_4_Compatibility::glGetStringi(GLenum name, GLuint index)
-{
-    return d_3_0_Core->f.GetStringi(name, index);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
-{
-    d_3_0_Core->f.ClearBufferfi(buffer, drawbuffer, depth, stencil);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
-{
-    d_3_0_Core->f.ClearBufferfv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
-{
-    d_3_0_Core->f.ClearBufferuiv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
-{
-    d_3_0_Core->f.ClearBufferiv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params)
-{
-    d_3_0_Core->f.GetTexParameterIuiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetTexParameterIiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params)
-{
-    d_3_0_Core->f.TexParameterIuiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexParameterIiv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_3_0_Core->f.TexParameterIiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glUniform4uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform4uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glUniform3uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform3uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glUniform2uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform2uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glUniform1uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform1uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
-{
-    d_3_0_Core->f.Uniform4ui(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
-{
-    d_3_0_Core->f.Uniform3ui(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glUniform2ui(GLint location, GLuint v0, GLuint v1)
-{
-    d_3_0_Core->f.Uniform2ui(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glUniform1ui(GLint location, GLuint v0)
-{
-    d_3_0_Core->f.Uniform1ui(location, v0);
-}
-
-inline GLint QOpenGLFunctions_4_4_Compatibility::glGetFragDataLocation(GLuint program, const GLchar *name)
-{
-    return d_3_0_Core->f.GetFragDataLocation(program, name);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name)
-{
-    d_3_0_Core->f.BindFragDataLocation(program, color, name);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetUniformuiv(GLuint program, GLint location, GLuint *params)
-{
-    d_3_0_Core->f.GetUniformuiv(program, location, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribI4usv(GLuint index, const GLushort *v)
-{
-    d_3_0_Core->f.VertexAttribI4usv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribI4ubv(GLuint index, const GLubyte *v)
-{
-    d_3_0_Core->f.VertexAttribI4ubv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribI4sv(GLuint index, const GLshort *v)
-{
-    d_3_0_Core->f.VertexAttribI4sv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribI4bv(GLuint index, const GLbyte *v)
-{
-    d_3_0_Core->f.VertexAttribI4bv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribI4uiv(GLuint index, const GLuint *v)
-{
-    d_3_0_Core->f.VertexAttribI4uiv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribI3uiv(GLuint index, const GLuint *v)
-{
-    d_3_0_Core->f.VertexAttribI3uiv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribI2uiv(GLuint index, const GLuint *v)
-{
-    d_3_0_Core->f.VertexAttribI2uiv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribI1uiv(GLuint index, const GLuint *v)
-{
-    d_3_0_Core->f.VertexAttribI1uiv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribI4iv(GLuint index, const GLint *v)
-{
-    d_3_0_Core->f.VertexAttribI4iv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribI3iv(GLuint index, const GLint *v)
-{
-    d_3_0_Core->f.VertexAttribI3iv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribI2iv(GLuint index, const GLint *v)
-{
-    d_3_0_Core->f.VertexAttribI2iv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribI1iv(GLuint index, const GLint *v)
-{
-    d_3_0_Core->f.VertexAttribI1iv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
-{
-    d_3_0_Core->f.VertexAttribI4ui(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z)
-{
-    d_3_0_Core->f.VertexAttribI3ui(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribI2ui(GLuint index, GLuint x, GLuint y)
-{
-    d_3_0_Core->f.VertexAttribI2ui(index, x, y);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribI1ui(GLuint index, GLuint x)
-{
-    d_3_0_Core->f.VertexAttribI1ui(index, x);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
-{
-    d_3_0_Core->f.VertexAttribI4i(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribI3i(GLuint index, GLint x, GLint y, GLint z)
-{
-    d_3_0_Core->f.VertexAttribI3i(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribI2i(GLuint index, GLint x, GLint y)
-{
-    d_3_0_Core->f.VertexAttribI2i(index, x, y);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribI1i(GLuint index, GLint x)
-{
-    d_3_0_Core->f.VertexAttribI1i(index, x);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
-{
-    d_3_0_Core->f.GetVertexAttribIuiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetVertexAttribIiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer)
-{
-    d_3_0_Core->f.VertexAttribIPointer(index, size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glEndConditionalRender()
-{
-    d_3_0_Core->f.EndConditionalRender();
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glBeginConditionalRender(GLuint id, GLenum mode)
-{
-    d_3_0_Core->f.BeginConditionalRender(id, mode);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glClampColor(GLenum target, GLenum clamp)
-{
-    d_3_0_Core->f.ClampColor(target, clamp);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
-{
-    d_3_0_Core->f.GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar *const *varyings, GLenum bufferMode)
-{
-    d_3_0_Core->f.TransformFeedbackVaryings(program, count, varyings, bufferMode);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
-{
-    d_3_0_Core->f.BindBufferBase(target, index, buffer);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
-{
-    d_3_0_Core->f.BindBufferRange(target, index, buffer, offset, size);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glEndTransformFeedback()
-{
-    d_3_0_Core->f.EndTransformFeedback();
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glBeginTransformFeedback(GLenum primitiveMode)
-{
-    d_3_0_Core->f.BeginTransformFeedback(primitiveMode);
-}
-
-inline GLboolean QOpenGLFunctions_4_4_Compatibility::glIsEnabledi(GLenum target, GLuint index)
-{
-    return d_3_0_Core->f.IsEnabledi(target, index);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glDisablei(GLenum target, GLuint index)
-{
-    d_3_0_Core->f.Disablei(target, index);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glEnablei(GLenum target, GLuint index)
-{
-    d_3_0_Core->f.Enablei(target, index);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetIntegeri_v(GLenum target, GLuint index, GLint *data)
-{
-    d_3_0_Core->f.GetIntegeri_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetBooleani_v(GLenum target, GLuint index, GLboolean *data)
-{
-    d_3_0_Core->f.GetBooleani_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
-{
-    d_3_0_Core->f.ColorMaski(index, r, g, b, a);
-}
-
-
-// OpenGL 3.1 core functions
-inline void QOpenGLFunctions_4_4_Compatibility::glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
-{
-    d_3_1_Core->f.UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
-{
-    d_3_1_Core->f.GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params)
-{
-    d_3_1_Core->f.GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
-}
-
-inline GLuint QOpenGLFunctions_4_4_Compatibility::glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName)
-{
-    return d_3_1_Core->f.GetUniformBlockIndex(program, uniformBlockName);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName)
-{
-    d_3_1_Core->f.GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params)
-{
-    d_3_1_Core->f.GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar *const *uniformNames, GLuint *uniformIndices)
-{
-    d_3_1_Core->f.GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
-{
-    d_3_1_Core->f.CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glPrimitiveRestartIndex(GLuint index)
-{
-    d_3_1_Core->f.PrimitiveRestartIndex(index);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer)
-{
-    d_3_1_Core->f.TexBuffer(target, internalformat, buffer);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount)
-{
-    d_3_1_Core->f.DrawElementsInstanced(mode, count, type, indices, instancecount);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount)
-{
-    d_3_1_Core->f.DrawArraysInstanced(mode, first, count, instancecount);
-}
-
-
-// OpenGL 3.2 core functions
-inline void QOpenGLFunctions_4_4_Compatibility::glSampleMaski(GLuint maskNumber, GLbitfield mask)
-{
-    d_3_2_Core->f.SampleMaski(maskNumber, mask);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val)
-{
-    d_3_2_Core->f.GetMultisamplefv(pname, index, val);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexImage3DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
-{
-    d_3_2_Core->f.TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexImage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
-{
-    d_3_2_Core->f.TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level)
-{
-    d_3_2_Core->f.FramebufferTexture(target, attachment, texture, level);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params)
-{
-    d_3_2_Core->f.GetBufferParameteri64v(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data)
-{
-    d_3_2_Core->f.GetInteger64i_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values)
-{
-    d_3_2_Core->f.GetSynciv(sync, pname, bufSize, length, values);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetInteger64v(GLenum pname, GLint64 *data)
-{
-    d_3_2_Core->f.GetInteger64v(pname, data);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
-{
-    d_3_2_Core->f.WaitSync(sync, flags, timeout);
-}
-
-inline GLenum QOpenGLFunctions_4_4_Compatibility::glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
-{
-    return d_3_2_Core->f.ClientWaitSync(sync, flags, timeout);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glDeleteSync(GLsync sync)
-{
-    d_3_2_Core->f.DeleteSync(sync);
-}
-
-inline GLboolean QOpenGLFunctions_4_4_Compatibility::glIsSync(GLsync sync)
-{
-    return d_3_2_Core->f.IsSync(sync);
-}
-
-inline GLsync QOpenGLFunctions_4_4_Compatibility::glFenceSync(GLenum condition, GLbitfield flags)
-{
-    return d_3_2_Core->f.FenceSync(condition, flags);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProvokingVertex(GLenum mode)
-{
-    d_3_2_Core->f.ProvokingVertex(mode);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count, GLenum type, const void *const *indices, GLsizei drawcount, const GLint *basevertex)
-{
-    d_3_2_Core->f.MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex)
-{
-    d_3_2_Core->f.DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex)
-{
-    d_3_2_Core->f.DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex)
-{
-    d_3_2_Core->f.DrawElementsBaseVertex(mode, count, type, indices, basevertex);
-}
-
-
-// OpenGL 3.3 core functions
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribP4uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP4uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP4ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribP3uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP3uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP3ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribP2uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP2uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP2ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribP1uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP1uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP1ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribDivisor(GLuint index, GLuint divisor)
-{
-    d_3_3_Core->f.VertexAttribDivisor(index, divisor);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params)
-{
-    d_3_3_Core->f.GetQueryObjectui64v(id, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params)
-{
-    d_3_3_Core->f.GetQueryObjecti64v(id, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glQueryCounter(GLuint id, GLenum target)
-{
-    d_3_3_Core->f.QueryCounter(id, target);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params)
-{
-    d_3_3_Core->f.GetSamplerParameterIuiv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params)
-{
-    d_3_3_Core->f.GetSamplerParameterfv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params)
-{
-    d_3_3_Core->f.GetSamplerParameterIiv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params)
-{
-    d_3_3_Core->f.GetSamplerParameteriv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param)
-{
-    d_3_3_Core->f.SamplerParameterIuiv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param)
-{
-    d_3_3_Core->f.SamplerParameterIiv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param)
-{
-    d_3_3_Core->f.SamplerParameterfv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
-{
-    d_3_3_Core->f.SamplerParameterf(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param)
-{
-    d_3_3_Core->f.SamplerParameteriv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glSamplerParameteri(GLuint sampler, GLenum pname, GLint param)
-{
-    d_3_3_Core->f.SamplerParameteri(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glBindSampler(GLuint unit, GLuint sampler)
-{
-    d_3_3_Core->f.BindSampler(unit, sampler);
-}
-
-inline GLboolean QOpenGLFunctions_4_4_Compatibility::glIsSampler(GLuint sampler)
-{
-    return d_3_3_Core->f.IsSampler(sampler);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glDeleteSamplers(GLsizei count, const GLuint *samplers)
-{
-    d_3_3_Core->f.DeleteSamplers(count, samplers);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGenSamplers(GLsizei count, GLuint *samplers)
-{
-    d_3_3_Core->f.GenSamplers(count, samplers);
-}
-
-inline GLint QOpenGLFunctions_4_4_Compatibility::glGetFragDataIndex(GLuint program, const GLchar *name)
-{
-    return d_3_3_Core->f.GetFragDataIndex(program, name);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glBindFragDataLocationIndexed(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name)
-{
-    d_3_3_Core->f.BindFragDataLocationIndexed(program, colorNumber, index, name);
-}
-
-
-// OpenGL 4.0 core functions
-inline void QOpenGLFunctions_4_4_Compatibility::glGetQueryIndexediv(GLenum target, GLuint index, GLenum pname, GLint *params)
-{
-    d_4_0_Core->f.GetQueryIndexediv(target, index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glEndQueryIndexed(GLenum target, GLuint index)
-{
-    d_4_0_Core->f.EndQueryIndexed(target, index);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glBeginQueryIndexed(GLenum target, GLuint index, GLuint id)
-{
-    d_4_0_Core->f.BeginQueryIndexed(target, index, id);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glDrawTransformFeedbackStream(GLenum mode, GLuint id, GLuint stream)
-{
-    d_4_0_Core->f.DrawTransformFeedbackStream(mode, id, stream);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glDrawTransformFeedback(GLenum mode, GLuint id)
-{
-    d_4_0_Core->f.DrawTransformFeedback(mode, id);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glResumeTransformFeedback()
-{
-    d_4_0_Core->f.ResumeTransformFeedback();
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glPauseTransformFeedback()
-{
-    d_4_0_Core->f.PauseTransformFeedback();
-}
-
-inline GLboolean QOpenGLFunctions_4_4_Compatibility::glIsTransformFeedback(GLuint id)
-{
-    return d_4_0_Core->f.IsTransformFeedback(id);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGenTransformFeedbacks(GLsizei n, GLuint *ids)
-{
-    d_4_0_Core->f.GenTransformFeedbacks(n, ids);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids)
-{
-    d_4_0_Core->f.DeleteTransformFeedbacks(n, ids);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glBindTransformFeedback(GLenum target, GLuint id)
-{
-    d_4_0_Core->f.BindTransformFeedback(target, id);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glPatchParameterfv(GLenum pname, const GLfloat *values)
-{
-    d_4_0_Core->f.PatchParameterfv(pname, values);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glPatchParameteri(GLenum pname, GLint value)
-{
-    d_4_0_Core->f.PatchParameteri(pname, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetProgramStageiv(GLuint program, GLenum shadertype, GLenum pname, GLint *values)
-{
-    d_4_0_Core->f.GetProgramStageiv(program, shadertype, pname, values);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetUniformSubroutineuiv(GLenum shadertype, GLint location, GLuint *params)
-{
-    d_4_0_Core->f.GetUniformSubroutineuiv(shadertype, location, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glUniformSubroutinesuiv(GLenum shadertype, GLsizei count, const GLuint *indices)
-{
-    d_4_0_Core->f.UniformSubroutinesuiv(shadertype, count, indices);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetActiveSubroutineName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
-{
-    d_4_0_Core->f.GetActiveSubroutineName(program, shadertype, index, bufsize, length, name);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetActiveSubroutineUniformName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
-{
-    d_4_0_Core->f.GetActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetActiveSubroutineUniformiv(GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values)
-{
-    d_4_0_Core->f.GetActiveSubroutineUniformiv(program, shadertype, index, pname, values);
-}
-
-inline GLuint QOpenGLFunctions_4_4_Compatibility::glGetSubroutineIndex(GLuint program, GLenum shadertype, const GLchar *name)
-{
-    return d_4_0_Core->f.GetSubroutineIndex(program, shadertype, name);
-}
-
-inline GLint QOpenGLFunctions_4_4_Compatibility::glGetSubroutineUniformLocation(GLuint program, GLenum shadertype, const GLchar *name)
-{
-    return d_4_0_Core->f.GetSubroutineUniformLocation(program, shadertype, name);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetUniformdv(GLuint program, GLint location, GLdouble *params)
-{
-    d_4_0_Core->f.GetUniformdv(program, location, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glUniformMatrix4x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix4x3dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glUniformMatrix4x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix4x2dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glUniformMatrix3x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix3x4dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glUniformMatrix3x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix3x2dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glUniformMatrix2x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix2x4dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glUniformMatrix2x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix2x3dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glUniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix4dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glUniformMatrix3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix3dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glUniformMatrix2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix2dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glUniform4dv(GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_0_Core->f.Uniform4dv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glUniform3dv(GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_0_Core->f.Uniform3dv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glUniform2dv(GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_0_Core->f.Uniform2dv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glUniform1dv(GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_0_Core->f.Uniform1dv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glUniform4d(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_4_0_Core->f.Uniform4d(location, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glUniform3d(GLint location, GLdouble x, GLdouble y, GLdouble z)
-{
-    d_4_0_Core->f.Uniform3d(location, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glUniform2d(GLint location, GLdouble x, GLdouble y)
-{
-    d_4_0_Core->f.Uniform2d(location, x, y);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glUniform1d(GLint location, GLdouble x)
-{
-    d_4_0_Core->f.Uniform1d(location, x);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glDrawElementsIndirect(GLenum mode, GLenum type, const void *indirect)
-{
-    d_4_0_Core->f.DrawElementsIndirect(mode, type, indirect);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glDrawArraysIndirect(GLenum mode, const void *indirect)
-{
-    d_4_0_Core->f.DrawArraysIndirect(mode, indirect);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glBlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
-{
-    d_4_0_Core->f.BlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glBlendFunci(GLuint buf, GLenum src, GLenum dst)
-{
-    d_4_0_Core->f.BlendFunci(buf, src, dst);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glBlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha)
-{
-    d_4_0_Core->f.BlendEquationSeparatei(buf, modeRGB, modeAlpha);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glBlendEquationi(GLuint buf, GLenum mode)
-{
-    d_4_0_Core->f.BlendEquationi(buf, mode);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMinSampleShading(GLfloat value)
-{
-    d_4_0_Core->f.MinSampleShading(value);
-}
-
-
-// OpenGL 4.1 core functions
-inline void QOpenGLFunctions_4_4_Compatibility::glGetDoublei_v(GLenum target, GLuint index, GLdouble *data)
-{
-    d_4_1_Core->f.GetDoublei_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetFloati_v(GLenum target, GLuint index, GLfloat *data)
-{
-    d_4_1_Core->f.GetFloati_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glDepthRangeIndexed(GLuint index, GLdouble n, GLdouble f)
-{
-    d_4_1_Core->f.DepthRangeIndexed(index, n, f);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glDepthRangeArrayv(GLuint first, GLsizei count, const GLdouble *v)
-{
-    d_4_1_Core->f.DepthRangeArrayv(first, count, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glScissorIndexedv(GLuint index, const GLint *v)
-{
-    d_4_1_Core->f.ScissorIndexedv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glScissorIndexed(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height)
-{
-    d_4_1_Core->f.ScissorIndexed(index, left, bottom, width, height);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glScissorArrayv(GLuint first, GLsizei count, const GLint *v)
-{
-    d_4_1_Core->f.ScissorArrayv(first, count, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glViewportIndexedfv(GLuint index, const GLfloat *v)
-{
-    d_4_1_Core->f.ViewportIndexedfv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glViewportIndexedf(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h)
-{
-    d_4_1_Core->f.ViewportIndexedf(index, x, y, w, h);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glViewportArrayv(GLuint first, GLsizei count, const GLfloat *v)
-{
-    d_4_1_Core->f.ViewportArrayv(first, count, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetVertexAttribLdv(GLuint index, GLenum pname, GLdouble *params)
-{
-    d_4_1_Core->f.GetVertexAttribLdv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribLPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer)
-{
-    d_4_1_Core->f.VertexAttribLPointer(index, size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribL4dv(GLuint index, const GLdouble *v)
-{
-    d_4_1_Core->f.VertexAttribL4dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribL3dv(GLuint index, const GLdouble *v)
-{
-    d_4_1_Core->f.VertexAttribL3dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribL2dv(GLuint index, const GLdouble *v)
-{
-    d_4_1_Core->f.VertexAttribL2dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribL1dv(GLuint index, const GLdouble *v)
-{
-    d_4_1_Core->f.VertexAttribL1dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribL4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_4_1_Core->f.VertexAttribL4d(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribL3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
-{
-    d_4_1_Core->f.VertexAttribL3d(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribL2d(GLuint index, GLdouble x, GLdouble y)
-{
-    d_4_1_Core->f.VertexAttribL2d(index, x, y);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribL1d(GLuint index, GLdouble x)
-{
-    d_4_1_Core->f.VertexAttribL1d(index, x);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-{
-    d_4_1_Core->f.GetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glValidateProgramPipeline(GLuint pipeline)
-{
-    d_4_1_Core->f.ValidateProgramPipeline(pipeline);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniformMatrix4x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4x3dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniformMatrix3x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3x4dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniformMatrix4x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4x2dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniformMatrix2x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2x4dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniformMatrix3x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3x2dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniformMatrix2x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2x3dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniformMatrix4x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4x3fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniformMatrix3x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3x4fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniformMatrix4x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4x2fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniformMatrix2x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2x4fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniformMatrix3x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3x2fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniformMatrix2x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2x3fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniformMatrix4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniformMatrix3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniformMatrix2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniformMatrix4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniformMatrix3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniformMatrix2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform4uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
-{
-    d_4_1_Core->f.ProgramUniform4uiv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
-{
-    d_4_1_Core->f.ProgramUniform4ui(program, location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform4dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniform4dv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform4d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3)
-{
-    d_4_1_Core->f.ProgramUniform4d(program, location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform4fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniform4fv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
-{
-    d_4_1_Core->f.ProgramUniform4f(program, location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform4iv(GLuint program, GLint location, GLsizei count, const GLint *value)
-{
-    d_4_1_Core->f.ProgramUniform4iv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
-{
-    d_4_1_Core->f.ProgramUniform4i(program, location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform3uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
-{
-    d_4_1_Core->f.ProgramUniform3uiv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2)
-{
-    d_4_1_Core->f.ProgramUniform3ui(program, location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform3dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniform3dv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform3d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2)
-{
-    d_4_1_Core->f.ProgramUniform3d(program, location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform3fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniform3fv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
-{
-    d_4_1_Core->f.ProgramUniform3f(program, location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform3iv(GLuint program, GLint location, GLsizei count, const GLint *value)
-{
-    d_4_1_Core->f.ProgramUniform3iv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2)
-{
-    d_4_1_Core->f.ProgramUniform3i(program, location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform2uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
-{
-    d_4_1_Core->f.ProgramUniform2uiv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1)
-{
-    d_4_1_Core->f.ProgramUniform2ui(program, location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform2dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniform2dv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform2d(GLuint program, GLint location, GLdouble v0, GLdouble v1)
-{
-    d_4_1_Core->f.ProgramUniform2d(program, location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform2fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniform2fv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1)
-{
-    d_4_1_Core->f.ProgramUniform2f(program, location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform2iv(GLuint program, GLint location, GLsizei count, const GLint *value)
-{
-    d_4_1_Core->f.ProgramUniform2iv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1)
-{
-    d_4_1_Core->f.ProgramUniform2i(program, location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform1uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
-{
-    d_4_1_Core->f.ProgramUniform1uiv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform1ui(GLuint program, GLint location, GLuint v0)
-{
-    d_4_1_Core->f.ProgramUniform1ui(program, location, v0);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform1dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniform1dv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform1d(GLuint program, GLint location, GLdouble v0)
-{
-    d_4_1_Core->f.ProgramUniform1d(program, location, v0);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform1fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniform1fv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform1f(GLuint program, GLint location, GLfloat v0)
-{
-    d_4_1_Core->f.ProgramUniform1f(program, location, v0);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform1iv(GLuint program, GLint location, GLsizei count, const GLint *value)
-{
-    d_4_1_Core->f.ProgramUniform1iv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform1i(GLuint program, GLint location, GLint v0)
-{
-    d_4_1_Core->f.ProgramUniform1i(program, location, v0);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params)
-{
-    d_4_1_Core->f.GetProgramPipelineiv(pipeline, pname, params);
-}
-
-inline GLboolean QOpenGLFunctions_4_4_Compatibility::glIsProgramPipeline(GLuint pipeline)
-{
-    return d_4_1_Core->f.IsProgramPipeline(pipeline);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGenProgramPipelines(GLsizei n, GLuint *pipelines)
-{
-    d_4_1_Core->f.GenProgramPipelines(n, pipelines);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glDeleteProgramPipelines(GLsizei n, const GLuint *pipelines)
-{
-    d_4_1_Core->f.DeleteProgramPipelines(n, pipelines);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glBindProgramPipeline(GLuint pipeline)
-{
-    d_4_1_Core->f.BindProgramPipeline(pipeline);
-}
-
-inline GLuint QOpenGLFunctions_4_4_Compatibility::glCreateShaderProgramv(GLenum type, GLsizei count, const GLchar *const *strings)
-{
-    return d_4_1_Core->f.CreateShaderProgramv(type, count, strings);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glActiveShaderProgram(GLuint pipeline, GLuint program)
-{
-    d_4_1_Core->f.ActiveShaderProgram(pipeline, program);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program)
-{
-    d_4_1_Core->f.UseProgramStages(pipeline, stages, program);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProgramParameteri(GLuint program, GLenum pname, GLint value)
-{
-    d_4_1_Core->f.ProgramParameteri(program, pname, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glProgramBinary(GLuint program, GLenum binaryFormat, const void *binary, GLsizei length)
-{
-    d_4_1_Core->f.ProgramBinary(program, binaryFormat, binary, length);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, void *binary)
-{
-    d_4_1_Core->f.GetProgramBinary(program, bufSize, length, binaryFormat, binary);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glClearDepthf(GLfloat dd)
-{
-    d_4_1_Core->f.ClearDepthf(dd);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glDepthRangef(GLfloat n, GLfloat f)
-{
-    d_4_1_Core->f.DepthRangef(n, f);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision)
-{
-    d_4_1_Core->f.GetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glShaderBinary(GLsizei count, const GLuint *shaders, GLenum binaryformat, const void *binary, GLsizei length)
-{
-    d_4_1_Core->f.ShaderBinary(count, shaders, binaryformat, binary, length);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glReleaseShaderCompiler()
-{
-    d_4_1_Core->f.ReleaseShaderCompiler();
-}
-
-
-// OpenGL 4.2 core functions
-inline void QOpenGLFunctions_4_4_Compatibility::glDrawTransformFeedbackStreamInstanced(GLenum mode, GLuint id, GLuint stream, GLsizei instancecount)
-{
-    d_4_2_Core->f.DrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glDrawTransformFeedbackInstanced(GLenum mode, GLuint id, GLsizei instancecount)
-{
-    d_4_2_Core->f.DrawTransformFeedbackInstanced(mode, id, instancecount);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
-{
-    d_4_2_Core->f.TexStorage3D(target, levels, internalformat, width, height, depth);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    d_4_2_Core->f.TexStorage2D(target, levels, internalformat, width, height);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexStorage1D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width)
-{
-    d_4_2_Core->f.TexStorage1D(target, levels, internalformat, width);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMemoryBarrier(GLbitfield barriers)
-{
-    d_4_2_Core->f.MemoryBarrier(barriers);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glBindImageTexture(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format)
-{
-    d_4_2_Core->f.BindImageTexture(unit, texture, level, layered, layer, access, format);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetActiveAtomicCounterBufferiv(GLuint program, GLuint bufferIndex, GLenum pname, GLint *params)
-{
-    d_4_2_Core->f.GetActiveAtomicCounterBufferiv(program, bufferIndex, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params)
-{
-    d_4_2_Core->f.GetInternalformativ(target, internalformat, pname, bufSize, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glDrawElementsInstancedBaseVertexBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance)
-{
-    d_4_2_Core->f.DrawElementsInstancedBaseVertexBaseInstance(mode, count, type, indices, instancecount, basevertex, baseinstance);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glDrawElementsInstancedBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLuint baseinstance)
-{
-    d_4_2_Core->f.DrawElementsInstancedBaseInstance(mode, count, type, indices, instancecount, baseinstance);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glDrawArraysInstancedBaseInstance(GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance)
-{
-    d_4_2_Core->f.DrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);
-}
-
-
-// OpenGL 4.3 core functions
-inline void QOpenGLFunctions_4_4_Compatibility::glGetObjectPtrLabel(const void *ptr, GLsizei bufSize, GLsizei *length, GLchar *label)
-{
-    d_4_3_Core->f.GetObjectPtrLabel(ptr, bufSize, length, label);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glObjectPtrLabel(const void *ptr, GLsizei length, const GLchar *label)
-{
-    d_4_3_Core->f.ObjectPtrLabel(ptr, length, label);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetObjectLabel(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label)
-{
-    d_4_3_Core->f.GetObjectLabel(identifier, name, bufSize, length, label);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glObjectLabel(GLenum identifier, GLuint name, GLsizei length, const GLchar *label)
-{
-    d_4_3_Core->f.ObjectLabel(identifier, name, length, label);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glPopDebugGroup()
-{
-    d_4_3_Core->f.PopDebugGroup();
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glPushDebugGroup(GLenum source, GLuint id, GLsizei length, const GLchar *message)
-{
-    d_4_3_Core->f.PushDebugGroup(source, id, length, message);
-}
-
-inline GLuint QOpenGLFunctions_4_4_Compatibility::glGetDebugMessageLog(GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog)
-{
-    return d_4_3_Core->f.GetDebugMessageLog(count, bufSize, sources, types, ids, severities, lengths, messageLog);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glDebugMessageCallback(GLDEBUGPROC callback, const void *userParam)
-{
-    d_4_3_Core->f.DebugMessageCallback(callback, userParam);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glDebugMessageInsert(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf)
-{
-    d_4_3_Core->f.DebugMessageInsert(source, type, id, severity, length, buf);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glDebugMessageControl(GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled)
-{
-    d_4_3_Core->f.DebugMessageControl(source, type, severity, count, ids, enabled);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexBindingDivisor(GLuint bindingindex, GLuint divisor)
-{
-    d_4_3_Core->f.VertexBindingDivisor(bindingindex, divisor);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribBinding(GLuint attribindex, GLuint bindingindex)
-{
-    d_4_3_Core->f.VertexAttribBinding(attribindex, bindingindex);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribLFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
-{
-    d_4_3_Core->f.VertexAttribLFormat(attribindex, size, type, relativeoffset);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribIFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
-{
-    d_4_3_Core->f.VertexAttribIFormat(attribindex, size, type, relativeoffset);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribFormat(GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset)
-{
-    d_4_3_Core->f.VertexAttribFormat(attribindex, size, type, normalized, relativeoffset);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glBindVertexBuffer(GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride)
-{
-    d_4_3_Core->f.BindVertexBuffer(bindingindex, buffer, offset, stride);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTextureView(GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers)
-{
-    d_4_3_Core->f.TextureView(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexStorage3DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
-{
-    d_4_3_Core->f.TexStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexStorage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
-{
-    d_4_3_Core->f.TexStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexBufferRange(GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size)
-{
-    d_4_3_Core->f.TexBufferRange(target, internalformat, buffer, offset, size);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glShaderStorageBlockBinding(GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding)
-{
-    d_4_3_Core->f.ShaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding);
-}
-
-inline GLint QOpenGLFunctions_4_4_Compatibility::glGetProgramResourceLocationIndex(GLuint program, GLenum programInterface, const GLchar *name)
-{
-    return d_4_3_Core->f.GetProgramResourceLocationIndex(program, programInterface, name);
-}
-
-inline GLint QOpenGLFunctions_4_4_Compatibility::glGetProgramResourceLocation(GLuint program, GLenum programInterface, const GLchar *name)
-{
-    return d_4_3_Core->f.GetProgramResourceLocation(program, programInterface, name);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetProgramResourceiv(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params)
-{
-    d_4_3_Core->f.GetProgramResourceiv(program, programInterface, index, propCount, props, bufSize, length, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetProgramResourceName(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name)
-{
-    d_4_3_Core->f.GetProgramResourceName(program, programInterface, index, bufSize, length, name);
-}
-
-inline GLuint QOpenGLFunctions_4_4_Compatibility::glGetProgramResourceIndex(GLuint program, GLenum programInterface, const GLchar *name)
-{
-    return d_4_3_Core->f.GetProgramResourceIndex(program, programInterface, name);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetProgramInterfaceiv(GLuint program, GLenum programInterface, GLenum pname, GLint *params)
-{
-    d_4_3_Core->f.GetProgramInterfaceiv(program, programInterface, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMultiDrawElementsIndirect(GLenum mode, GLenum type, const void *indirect, GLsizei drawcount, GLsizei stride)
-{
-    d_4_3_Core->f.MultiDrawElementsIndirect(mode, type, indirect, drawcount, stride);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMultiDrawArraysIndirect(GLenum mode, const void *indirect, GLsizei drawcount, GLsizei stride)
-{
-    d_4_3_Core->f.MultiDrawArraysIndirect(mode, indirect, drawcount, stride);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glInvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_4_3_Core->f.InvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glInvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments)
-{
-    d_4_3_Core->f.InvalidateFramebuffer(target, numAttachments, attachments);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glInvalidateBufferData(GLuint buffer)
-{
-    d_4_3_Core->f.InvalidateBufferData(buffer);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glInvalidateBufferSubData(GLuint buffer, GLintptr offset, GLsizeiptr length)
-{
-    d_4_3_Core->f.InvalidateBufferSubData(buffer, offset, length);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glInvalidateTexImage(GLuint texture, GLint level)
-{
-    d_4_3_Core->f.InvalidateTexImage(texture, level);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glInvalidateTexSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth)
-{
-    d_4_3_Core->f.InvalidateTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetInternalformati64v(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint64 *params)
-{
-    d_4_3_Core->f.GetInternalformati64v(target, internalformat, pname, bufSize, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetFramebufferParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_4_3_Core->f.GetFramebufferParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glFramebufferParameteri(GLenum target, GLenum pname, GLint param)
-{
-    d_4_3_Core->f.FramebufferParameteri(target, pname, param);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glCopyImageSubData(GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth)
-{
-    d_4_3_Core->f.CopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glDispatchComputeIndirect(GLintptr indirect)
-{
-    d_4_3_Core->f.DispatchComputeIndirect(indirect);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glDispatchCompute(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z)
-{
-    d_4_3_Core->f.DispatchCompute(num_groups_x, num_groups_y, num_groups_z);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glClearBufferSubData(GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data)
-{
-    d_4_3_Core->f.ClearBufferSubData(target, internalformat, offset, size, format, type, data);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glClearBufferData(GLenum target, GLenum internalformat, GLenum format, GLenum type, const void *data)
-{
-    d_4_3_Core->f.ClearBufferData(target, internalformat, format, type, data);
-}
-
-
-// OpenGL 4.4 core functions
-inline void QOpenGLFunctions_4_4_Compatibility::glBindVertexBuffers(GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides)
-{
-    d_4_4_Core->f.BindVertexBuffers(first, count, buffers, offsets, strides);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glBindImageTextures(GLuint first, GLsizei count, const GLuint *textures)
-{
-    d_4_4_Core->f.BindImageTextures(first, count, textures);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glBindSamplers(GLuint first, GLsizei count, const GLuint *samplers)
-{
-    d_4_4_Core->f.BindSamplers(first, count, samplers);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glBindTextures(GLuint first, GLsizei count, const GLuint *textures)
-{
-    d_4_4_Core->f.BindTextures(first, count, textures);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glBindBuffersRange(GLenum target, GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizeiptr *sizes)
-{
-    d_4_4_Core->f.BindBuffersRange(target, first, count, buffers, offsets, sizes);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glBindBuffersBase(GLenum target, GLuint first, GLsizei count, const GLuint *buffers)
-{
-    d_4_4_Core->f.BindBuffersBase(target, first, count, buffers);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glClearTexSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *data)
-{
-    d_4_4_Core->f.ClearTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glClearTexImage(GLuint texture, GLint level, GLenum format, GLenum type, const void *data)
-{
-    d_4_4_Core->f.ClearTexImage(texture, level, format, type, data);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glBufferStorage(GLenum target, GLsizeiptr size, const void *data, GLbitfield flags)
-{
-    d_4_4_Core->f.BufferStorage(target, size, data, flags);
-}
-
-
-// OpenGL 1.0 deprecated functions
-inline void QOpenGLFunctions_4_4_Compatibility::glTranslatef(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Translatef(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTranslated(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Translated(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glScalef(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Scalef(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glScaled(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Scaled(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Rotatef(angle, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Rotated(angle, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glPushMatrix()
-{
-    d_1_0_Deprecated->f.PushMatrix();
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glPopMatrix()
-{
-    d_1_0_Deprecated->f.PopMatrix();
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
-{
-    d_1_0_Deprecated->f.Ortho(left, right, bottom, top, zNear, zFar);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMultMatrixd(const GLdouble *m)
-{
-    d_1_0_Deprecated->f.MultMatrixd(m);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMultMatrixf(const GLfloat *m)
-{
-    d_1_0_Deprecated->f.MultMatrixf(m);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMatrixMode(GLenum mode)
-{
-    d_1_0_Deprecated->f.MatrixMode(mode);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glLoadMatrixd(const GLdouble *m)
-{
-    d_1_0_Deprecated->f.LoadMatrixd(m);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glLoadMatrixf(const GLfloat *m)
-{
-    d_1_0_Deprecated->f.LoadMatrixf(m);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glLoadIdentity()
-{
-    d_1_0_Deprecated->f.LoadIdentity();
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
-{
-    d_1_0_Deprecated->f.Frustum(left, right, bottom, top, zNear, zFar);
-}
-
-inline GLboolean QOpenGLFunctions_4_4_Compatibility::glIsList(GLuint list)
-{
-    return d_1_0_Deprecated->f.IsList(list);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetTexGeniv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetTexGenfv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
-{
-    d_1_0_Deprecated->f.GetTexGendv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetTexEnviv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetTexEnviv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetTexEnvfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetPolygonStipple(GLubyte *mask)
-{
-    d_1_0_Deprecated->f.GetPolygonStipple(mask);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetPixelMapusv(GLenum map, GLushort *values)
-{
-    d_1_0_Deprecated->f.GetPixelMapusv(map, values);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetPixelMapuiv(GLenum map, GLuint *values)
-{
-    d_1_0_Deprecated->f.GetPixelMapuiv(map, values);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetPixelMapfv(GLenum map, GLfloat *values)
-{
-    d_1_0_Deprecated->f.GetPixelMapfv(map, values);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetMaterialiv(GLenum face, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetMaterialiv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetMaterialfv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetMapiv(GLenum target, GLenum query, GLint *v)
-{
-    d_1_0_Deprecated->f.GetMapiv(target, query, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetMapfv(GLenum target, GLenum query, GLfloat *v)
-{
-    d_1_0_Deprecated->f.GetMapfv(target, query, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetMapdv(GLenum target, GLenum query, GLdouble *v)
-{
-    d_1_0_Deprecated->f.GetMapdv(target, query, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetLightiv(GLenum light, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetLightiv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetLightfv(GLenum light, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetLightfv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetClipPlane(GLenum plane, GLdouble *equation)
-{
-    d_1_0_Deprecated->f.GetClipPlane(plane, equation);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)
-{
-    d_1_0_Deprecated->f.DrawPixels(width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
-{
-    d_1_0_Deprecated->f.CopyPixels(x, y, width, height, type);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glPixelMapusv(GLenum map, GLsizei mapsize, const GLushort *values)
-{
-    d_1_0_Deprecated->f.PixelMapusv(map, mapsize, values);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glPixelMapuiv(GLenum map, GLsizei mapsize, const GLuint *values)
-{
-    d_1_0_Deprecated->f.PixelMapuiv(map, mapsize, values);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glPixelMapfv(GLenum map, GLsizei mapsize, const GLfloat *values)
-{
-    d_1_0_Deprecated->f.PixelMapfv(map, mapsize, values);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glPixelTransferi(GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.PixelTransferi(pname, param);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glPixelTransferf(GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.PixelTransferf(pname, param);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glPixelZoom(GLfloat xfactor, GLfloat yfactor)
-{
-    d_1_0_Deprecated->f.PixelZoom(xfactor, yfactor);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glAlphaFunc(GLenum func, GLfloat ref)
-{
-    d_1_0_Deprecated->f.AlphaFunc(func, ref);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glEvalPoint2(GLint i, GLint j)
-{
-    d_1_0_Deprecated->f.EvalPoint2(i, j);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
-{
-    d_1_0_Deprecated->f.EvalMesh2(mode, i1, i2, j1, j2);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glEvalPoint1(GLint i)
-{
-    d_1_0_Deprecated->f.EvalPoint1(i);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glEvalMesh1(GLenum mode, GLint i1, GLint i2)
-{
-    d_1_0_Deprecated->f.EvalMesh1(mode, i1, i2);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glEvalCoord2fv(const GLfloat *u)
-{
-    d_1_0_Deprecated->f.EvalCoord2fv(u);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glEvalCoord2f(GLfloat u, GLfloat v)
-{
-    d_1_0_Deprecated->f.EvalCoord2f(u, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glEvalCoord2dv(const GLdouble *u)
-{
-    d_1_0_Deprecated->f.EvalCoord2dv(u);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glEvalCoord2d(GLdouble u, GLdouble v)
-{
-    d_1_0_Deprecated->f.EvalCoord2d(u, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glEvalCoord1fv(const GLfloat *u)
-{
-    d_1_0_Deprecated->f.EvalCoord1fv(u);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glEvalCoord1f(GLfloat u)
-{
-    d_1_0_Deprecated->f.EvalCoord1f(u);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glEvalCoord1dv(const GLdouble *u)
-{
-    d_1_0_Deprecated->f.EvalCoord1dv(u);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glEvalCoord1d(GLdouble u)
-{
-    d_1_0_Deprecated->f.EvalCoord1d(u);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
-{
-    d_1_0_Deprecated->f.MapGrid2f(un, u1, u2, vn, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
-{
-    d_1_0_Deprecated->f.MapGrid2d(un, u1, u2, vn, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
-{
-    d_1_0_Deprecated->f.MapGrid1f(un, u1, u2);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
-{
-    d_1_0_Deprecated->f.MapGrid1d(un, u1, u2);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
-{
-    d_1_0_Deprecated->f.Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
-{
-    d_1_0_Deprecated->f.Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
-{
-    d_1_0_Deprecated->f.Map1f(target, u1, u2, stride, order, points);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
-{
-    d_1_0_Deprecated->f.Map1d(target, u1, u2, stride, order, points);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glPushAttrib(GLbitfield mask)
-{
-    d_1_0_Deprecated->f.PushAttrib(mask);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glPopAttrib()
-{
-    d_1_0_Deprecated->f.PopAttrib();
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glAccum(GLenum op, GLfloat value)
-{
-    d_1_0_Deprecated->f.Accum(op, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glIndexMask(GLuint mask)
-{
-    d_1_0_Deprecated->f.IndexMask(mask);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glClearIndex(GLfloat c)
-{
-    d_1_0_Deprecated->f.ClearIndex(c);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Deprecated->f.ClearAccum(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glPushName(GLuint name)
-{
-    d_1_0_Deprecated->f.PushName(name);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glPopName()
-{
-    d_1_0_Deprecated->f.PopName();
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glPassThrough(GLfloat token)
-{
-    d_1_0_Deprecated->f.PassThrough(token);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glLoadName(GLuint name)
-{
-    d_1_0_Deprecated->f.LoadName(name);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glInitNames()
-{
-    d_1_0_Deprecated->f.InitNames();
-}
-
-inline GLint QOpenGLFunctions_4_4_Compatibility::glRenderMode(GLenum mode)
-{
-    return d_1_0_Deprecated->f.RenderMode(mode);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glSelectBuffer(GLsizei size, GLuint *buffer)
-{
-    d_1_0_Deprecated->f.SelectBuffer(size, buffer);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
-{
-    d_1_0_Deprecated->f.FeedbackBuffer(size, type, buffer);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexGeniv(GLenum coord, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.TexGeniv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexGeni(GLenum coord, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.TexGeni(coord, pname, param);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.TexGenfv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexGenf(GLenum coord, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.TexGenf(coord, pname, param);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
-{
-    d_1_0_Deprecated->f.TexGendv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexGend(GLenum coord, GLenum pname, GLdouble param)
-{
-    d_1_0_Deprecated->f.TexGend(coord, pname, param);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexEnviv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.TexEnviv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexEnvi(GLenum target, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.TexEnvi(target, pname, param);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.TexEnvfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexEnvf(GLenum target, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.TexEnvf(target, pname, param);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glShadeModel(GLenum mode)
-{
-    d_1_0_Deprecated->f.ShadeModel(mode);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glPolygonStipple(const GLubyte *mask)
-{
-    d_1_0_Deprecated->f.PolygonStipple(mask);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMaterialiv(GLenum face, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.Materialiv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMateriali(GLenum face, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.Materiali(face, pname, param);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.Materialfv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMaterialf(GLenum face, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.Materialf(face, pname, param);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glLineStipple(GLint factor, GLushort pattern)
-{
-    d_1_0_Deprecated->f.LineStipple(factor, pattern);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glLightModeliv(GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.LightModeliv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glLightModeli(GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.LightModeli(pname, param);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glLightModelfv(GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.LightModelfv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glLightModelf(GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.LightModelf(pname, param);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glLightiv(GLenum light, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.Lightiv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glLighti(GLenum light, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.Lighti(light, pname, param);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glLightfv(GLenum light, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.Lightfv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glLightf(GLenum light, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.Lightf(light, pname, param);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glFogiv(GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.Fogiv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glFogi(GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.Fogi(pname, param);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glFogfv(GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.Fogfv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glFogf(GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.Fogf(pname, param);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glColorMaterial(GLenum face, GLenum mode)
-{
-    d_1_0_Deprecated->f.ColorMaterial(face, mode);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glClipPlane(GLenum plane, const GLdouble *equation)
-{
-    d_1_0_Deprecated->f.ClipPlane(plane, equation);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertex4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Vertex4sv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
-{
-    d_1_0_Deprecated->f.Vertex4s(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertex4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Vertex4iv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertex4i(GLint x, GLint y, GLint z, GLint w)
-{
-    d_1_0_Deprecated->f.Vertex4i(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertex4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Vertex4fv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    d_1_0_Deprecated->f.Vertex4f(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertex4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Vertex4dv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_1_0_Deprecated->f.Vertex4d(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertex3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Vertex3sv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertex3s(GLshort x, GLshort y, GLshort z)
-{
-    d_1_0_Deprecated->f.Vertex3s(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertex3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Vertex3iv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertex3i(GLint x, GLint y, GLint z)
-{
-    d_1_0_Deprecated->f.Vertex3i(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertex3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Vertex3fv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertex3f(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Vertex3f(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertex3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Vertex3dv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertex3d(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Vertex3d(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertex2sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Vertex2sv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertex2s(GLshort x, GLshort y)
-{
-    d_1_0_Deprecated->f.Vertex2s(x, y);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertex2iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Vertex2iv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertex2i(GLint x, GLint y)
-{
-    d_1_0_Deprecated->f.Vertex2i(x, y);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertex2fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Vertex2fv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertex2f(GLfloat x, GLfloat y)
-{
-    d_1_0_Deprecated->f.Vertex2f(x, y);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertex2dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Vertex2dv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertex2d(GLdouble x, GLdouble y)
-{
-    d_1_0_Deprecated->f.Vertex2d(x, y);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord4sv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
-{
-    d_1_0_Deprecated->f.TexCoord4s(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord4iv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
-{
-    d_1_0_Deprecated->f.TexCoord4i(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord4fv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
-{
-    d_1_0_Deprecated->f.TexCoord4f(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord4dv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
-{
-    d_1_0_Deprecated->f.TexCoord4d(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord3sv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord3s(GLshort s, GLshort t, GLshort r)
-{
-    d_1_0_Deprecated->f.TexCoord3s(s, t, r);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord3iv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord3i(GLint s, GLint t, GLint r)
-{
-    d_1_0_Deprecated->f.TexCoord3i(s, t, r);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord3fv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
-{
-    d_1_0_Deprecated->f.TexCoord3f(s, t, r);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord3dv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
-{
-    d_1_0_Deprecated->f.TexCoord3d(s, t, r);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord2sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord2sv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord2s(GLshort s, GLshort t)
-{
-    d_1_0_Deprecated->f.TexCoord2s(s, t);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord2iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord2iv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord2i(GLint s, GLint t)
-{
-    d_1_0_Deprecated->f.TexCoord2i(s, t);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord2fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord2fv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord2f(GLfloat s, GLfloat t)
-{
-    d_1_0_Deprecated->f.TexCoord2f(s, t);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord2dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord2dv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord2d(GLdouble s, GLdouble t)
-{
-    d_1_0_Deprecated->f.TexCoord2d(s, t);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord1sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord1sv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord1s(GLshort s)
-{
-    d_1_0_Deprecated->f.TexCoord1s(s);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord1iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord1iv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord1i(GLint s)
-{
-    d_1_0_Deprecated->f.TexCoord1i(s);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord1fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord1fv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord1f(GLfloat s)
-{
-    d_1_0_Deprecated->f.TexCoord1f(s);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord1dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord1dv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord1d(GLdouble s)
-{
-    d_1_0_Deprecated->f.TexCoord1d(s);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glRectsv(const GLshort *v1, const GLshort *v2)
-{
-    d_1_0_Deprecated->f.Rectsv(v1, v2);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
-{
-    d_1_0_Deprecated->f.Rects(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glRectiv(const GLint *v1, const GLint *v2)
-{
-    d_1_0_Deprecated->f.Rectiv(v1, v2);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
-{
-    d_1_0_Deprecated->f.Recti(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glRectfv(const GLfloat *v1, const GLfloat *v2)
-{
-    d_1_0_Deprecated->f.Rectfv(v1, v2);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
-{
-    d_1_0_Deprecated->f.Rectf(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glRectdv(const GLdouble *v1, const GLdouble *v2)
-{
-    d_1_0_Deprecated->f.Rectdv(v1, v2);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
-{
-    d_1_0_Deprecated->f.Rectd(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glRasterPos4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.RasterPos4sv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
-{
-    d_1_0_Deprecated->f.RasterPos4s(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glRasterPos4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.RasterPos4iv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
-{
-    d_1_0_Deprecated->f.RasterPos4i(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glRasterPos4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.RasterPos4fv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    d_1_0_Deprecated->f.RasterPos4f(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glRasterPos4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.RasterPos4dv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_1_0_Deprecated->f.RasterPos4d(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glRasterPos3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.RasterPos3sv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glRasterPos3s(GLshort x, GLshort y, GLshort z)
-{
-    d_1_0_Deprecated->f.RasterPos3s(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glRasterPos3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.RasterPos3iv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glRasterPos3i(GLint x, GLint y, GLint z)
-{
-    d_1_0_Deprecated->f.RasterPos3i(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glRasterPos3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.RasterPos3fv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.RasterPos3f(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glRasterPos3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.RasterPos3dv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.RasterPos3d(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glRasterPos2sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.RasterPos2sv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glRasterPos2s(GLshort x, GLshort y)
-{
-    d_1_0_Deprecated->f.RasterPos2s(x, y);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glRasterPos2iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.RasterPos2iv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glRasterPos2i(GLint x, GLint y)
-{
-    d_1_0_Deprecated->f.RasterPos2i(x, y);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glRasterPos2fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.RasterPos2fv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glRasterPos2f(GLfloat x, GLfloat y)
-{
-    d_1_0_Deprecated->f.RasterPos2f(x, y);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glRasterPos2dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.RasterPos2dv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glRasterPos2d(GLdouble x, GLdouble y)
-{
-    d_1_0_Deprecated->f.RasterPos2d(x, y);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glNormal3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Normal3sv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glNormal3s(GLshort nx, GLshort ny, GLshort nz)
-{
-    d_1_0_Deprecated->f.Normal3s(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glNormal3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Normal3iv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glNormal3i(GLint nx, GLint ny, GLint nz)
-{
-    d_1_0_Deprecated->f.Normal3i(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glNormal3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Normal3fv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
-{
-    d_1_0_Deprecated->f.Normal3f(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glNormal3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Normal3dv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
-{
-    d_1_0_Deprecated->f.Normal3d(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glNormal3bv(const GLbyte *v)
-{
-    d_1_0_Deprecated->f.Normal3bv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
-{
-    d_1_0_Deprecated->f.Normal3b(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glIndexsv(const GLshort *c)
-{
-    d_1_0_Deprecated->f.Indexsv(c);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glIndexs(GLshort c)
-{
-    d_1_0_Deprecated->f.Indexs(c);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glIndexiv(const GLint *c)
-{
-    d_1_0_Deprecated->f.Indexiv(c);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glIndexi(GLint c)
-{
-    d_1_0_Deprecated->f.Indexi(c);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glIndexfv(const GLfloat *c)
-{
-    d_1_0_Deprecated->f.Indexfv(c);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glIndexf(GLfloat c)
-{
-    d_1_0_Deprecated->f.Indexf(c);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glIndexdv(const GLdouble *c)
-{
-    d_1_0_Deprecated->f.Indexdv(c);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glIndexd(GLdouble c)
-{
-    d_1_0_Deprecated->f.Indexd(c);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glEnd()
-{
-    d_1_0_Deprecated->f.End();
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glEdgeFlagv(const GLboolean *flag)
-{
-    d_1_0_Deprecated->f.EdgeFlagv(flag);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glEdgeFlag(GLboolean flag)
-{
-    d_1_0_Deprecated->f.EdgeFlag(flag);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glColor4usv(const GLushort *v)
-{
-    d_1_0_Deprecated->f.Color4usv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
-{
-    d_1_0_Deprecated->f.Color4us(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glColor4uiv(const GLuint *v)
-{
-    d_1_0_Deprecated->f.Color4uiv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
-{
-    d_1_0_Deprecated->f.Color4ui(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glColor4ubv(const GLubyte *v)
-{
-    d_1_0_Deprecated->f.Color4ubv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
-{
-    d_1_0_Deprecated->f.Color4ub(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glColor4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Color4sv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
-{
-    d_1_0_Deprecated->f.Color4s(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glColor4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Color4iv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
-{
-    d_1_0_Deprecated->f.Color4i(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glColor4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Color4fv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Deprecated->f.Color4f(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glColor4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Color4dv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
-{
-    d_1_0_Deprecated->f.Color4d(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glColor4bv(const GLbyte *v)
-{
-    d_1_0_Deprecated->f.Color4bv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
-{
-    d_1_0_Deprecated->f.Color4b(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glColor3usv(const GLushort *v)
-{
-    d_1_0_Deprecated->f.Color3usv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glColor3us(GLushort red, GLushort green, GLushort blue)
-{
-    d_1_0_Deprecated->f.Color3us(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glColor3uiv(const GLuint *v)
-{
-    d_1_0_Deprecated->f.Color3uiv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glColor3ui(GLuint red, GLuint green, GLuint blue)
-{
-    d_1_0_Deprecated->f.Color3ui(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glColor3ubv(const GLubyte *v)
-{
-    d_1_0_Deprecated->f.Color3ubv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
-{
-    d_1_0_Deprecated->f.Color3ub(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glColor3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Color3sv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glColor3s(GLshort red, GLshort green, GLshort blue)
-{
-    d_1_0_Deprecated->f.Color3s(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glColor3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Color3iv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glColor3i(GLint red, GLint green, GLint blue)
-{
-    d_1_0_Deprecated->f.Color3i(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glColor3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Color3fv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glColor3f(GLfloat red, GLfloat green, GLfloat blue)
-{
-    d_1_0_Deprecated->f.Color3f(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glColor3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Color3dv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glColor3d(GLdouble red, GLdouble green, GLdouble blue)
-{
-    d_1_0_Deprecated->f.Color3d(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glColor3bv(const GLbyte *v)
-{
-    d_1_0_Deprecated->f.Color3bv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glColor3b(GLbyte red, GLbyte green, GLbyte blue)
-{
-    d_1_0_Deprecated->f.Color3b(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
-{
-    d_1_0_Deprecated->f.Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glBegin(GLenum mode)
-{
-    d_1_0_Deprecated->f.Begin(mode);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glListBase(GLuint base)
-{
-    d_1_0_Deprecated->f.ListBase(base);
-}
-
-inline GLuint QOpenGLFunctions_4_4_Compatibility::glGenLists(GLsizei range)
-{
-    return d_1_0_Deprecated->f.GenLists(range);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glDeleteLists(GLuint list, GLsizei range)
-{
-    d_1_0_Deprecated->f.DeleteLists(list, range);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glCallLists(GLsizei n, GLenum type, const void *lists)
-{
-    d_1_0_Deprecated->f.CallLists(n, type, lists);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glCallList(GLuint list)
-{
-    d_1_0_Deprecated->f.CallList(list);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glEndList()
-{
-    d_1_0_Deprecated->f.EndList();
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glNewList(GLuint list, GLenum mode)
-{
-    d_1_0_Deprecated->f.NewList(list, mode);
-}
-
-
-// OpenGL 1.1 deprecated functions
-inline void QOpenGLFunctions_4_4_Compatibility::glPushClientAttrib(GLbitfield mask)
-{
-    d_1_1_Deprecated->f.PushClientAttrib(mask);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glPopClientAttrib()
-{
-    d_1_1_Deprecated->f.PopClientAttrib();
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glIndexubv(const GLubyte *c)
-{
-    d_1_1_Deprecated->f.Indexubv(c);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glIndexub(GLubyte c)
-{
-    d_1_1_Deprecated->f.Indexub(c);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities)
-{
-    d_1_1_Deprecated->f.PrioritizeTextures(n, textures, priorities);
-}
-
-inline GLboolean QOpenGLFunctions_4_4_Compatibility::glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
-{
-    return d_1_1_Deprecated->f.AreTexturesResident(n, textures, residences);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
-{
-    d_1_1_Deprecated->f.VertexPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
-{
-    d_1_1_Deprecated->f.TexCoordPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glNormalPointer(GLenum type, GLsizei stride, const void *pointer)
-{
-    d_1_1_Deprecated->f.NormalPointer(type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glInterleavedArrays(GLenum format, GLsizei stride, const void *pointer)
-{
-    d_1_1_Deprecated->f.InterleavedArrays(format, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetPointerv(GLenum pname, void * *params)
-{
-    d_1_1_Deprecated->f.GetPointerv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glIndexPointer(GLenum type, GLsizei stride, const void *pointer)
-{
-    d_1_1_Deprecated->f.IndexPointer(type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glEnableClientState(GLenum array)
-{
-    d_1_1_Deprecated->f.EnableClientState(array);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glEdgeFlagPointer(GLsizei stride, const void *pointer)
-{
-    d_1_1_Deprecated->f.EdgeFlagPointer(stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glDisableClientState(GLenum array)
-{
-    d_1_1_Deprecated->f.DisableClientState(array);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glColorPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
-{
-    d_1_1_Deprecated->f.ColorPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glArrayElement(GLint i)
-{
-    d_1_1_Deprecated->f.ArrayElement(i);
-}
-
-
-// OpenGL 1.2 deprecated functions
-inline void QOpenGLFunctions_4_4_Compatibility::glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void *table)
-{
-    d_1_2_Deprecated->f.ColorTable(target, internalformat, width, format, type, table);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_2_Deprecated->f.ColorTableParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_2_Deprecated->f.ColorTableParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
-{
-    d_1_2_Deprecated->f.CopyColorTable(target, internalformat, x, y, width);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetColorTable(GLenum target, GLenum format, GLenum type, void *table)
-{
-    d_1_2_Deprecated->f.GetColorTable(target, format, type, table);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetColorTableParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetColorTableParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const void *data)
-{
-    d_1_2_Deprecated->f.ColorSubTable(target, start, count, format, type, data);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
-{
-    d_1_2_Deprecated->f.CopyColorSubTable(target, start, x, y, width);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void *image)
-{
-    d_1_2_Deprecated->f.ConvolutionFilter1D(target, internalformat, width, format, type, image);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *image)
-{
-    d_1_2_Deprecated->f.ConvolutionFilter2D(target, internalformat, width, height, format, type, image);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameterf(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glConvolutionParameteri(GLenum target, GLenum pname, GLint params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameteri(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
-{
-    d_1_2_Deprecated->f.CopyConvolutionFilter1D(target, internalformat, x, y, width);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_2_Deprecated->f.CopyConvolutionFilter2D(target, internalformat, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, void *image)
-{
-    d_1_2_Deprecated->f.GetConvolutionFilter(target, format, type, image);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetConvolutionParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetConvolutionParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetSeparableFilter(GLenum target, GLenum format, GLenum type, void *row, void *column, void *span)
-{
-    d_1_2_Deprecated->f.GetSeparableFilter(target, format, type, row, column, span);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *row, const void *column)
-{
-    d_1_2_Deprecated->f.SeparableFilter2D(target, internalformat, width, height, format, type, row, column);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, void *values)
-{
-    d_1_2_Deprecated->f.GetHistogram(target, reset, format, type, values);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetHistogramParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetHistogramParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, void *values)
-{
-    d_1_2_Deprecated->f.GetMinmax(target, reset, format, type, values);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetMinmaxParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetMinmaxParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
-{
-    d_1_2_Deprecated->f.Histogram(target, width, internalformat, sink);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMinmax(GLenum target, GLenum internalformat, GLboolean sink)
-{
-    d_1_2_Deprecated->f.Minmax(target, internalformat, sink);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glResetHistogram(GLenum target)
-{
-    d_1_2_Deprecated->f.ResetHistogram(target);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glResetMinmax(GLenum target)
-{
-    d_1_2_Deprecated->f.ResetMinmax(target);
-}
-
-
-// OpenGL 1.3 deprecated functions
-inline void QOpenGLFunctions_4_4_Compatibility::glMultTransposeMatrixd(const GLdouble *m)
-{
-    d_1_3_Deprecated->f.MultTransposeMatrixd(m);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMultTransposeMatrixf(const GLfloat *m)
-{
-    d_1_3_Deprecated->f.MultTransposeMatrixf(m);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glLoadTransposeMatrixd(const GLdouble *m)
-{
-    d_1_3_Deprecated->f.LoadTransposeMatrixd(m);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glLoadTransposeMatrixf(const GLfloat *m)
-{
-    d_1_3_Deprecated->f.LoadTransposeMatrixf(m);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord4sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4sv(target, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4s(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord4iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4iv(target, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4i(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord4fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4fv(target, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4f(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord4dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4dv(target, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4d(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord3sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3sv(target, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3s(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord3iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3iv(target, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3i(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord3fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3fv(target, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3f(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord3dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3dv(target, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3d(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord2sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2sv(target, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord2s(GLenum target, GLshort s, GLshort t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2s(target, s, t);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord2iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2iv(target, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord2i(GLenum target, GLint s, GLint t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2i(target, s, t);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord2fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2fv(target, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2f(target, s, t);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord2dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2dv(target, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2d(target, s, t);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord1sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1sv(target, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord1s(GLenum target, GLshort s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1s(target, s);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord1iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1iv(target, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord1i(GLenum target, GLint s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1i(target, s);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord1fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1fv(target, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord1f(GLenum target, GLfloat s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1f(target, s);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord1dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1dv(target, v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord1d(GLenum target, GLdouble s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1d(target, s);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glClientActiveTexture(GLenum texture)
-{
-    d_1_3_Deprecated->f.ClientActiveTexture(texture);
-}
-
-
-// OpenGL 1.4 deprecated functions
-inline void QOpenGLFunctions_4_4_Compatibility::glWindowPos3sv(const GLshort *v)
-{
-    d_1_4_Deprecated->f.WindowPos3sv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glWindowPos3s(GLshort x, GLshort y, GLshort z)
-{
-    d_1_4_Deprecated->f.WindowPos3s(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glWindowPos3iv(const GLint *v)
-{
-    d_1_4_Deprecated->f.WindowPos3iv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glWindowPos3i(GLint x, GLint y, GLint z)
-{
-    d_1_4_Deprecated->f.WindowPos3i(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glWindowPos3fv(const GLfloat *v)
-{
-    d_1_4_Deprecated->f.WindowPos3fv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glWindowPos3f(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_4_Deprecated->f.WindowPos3f(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glWindowPos3dv(const GLdouble *v)
-{
-    d_1_4_Deprecated->f.WindowPos3dv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glWindowPos3d(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_4_Deprecated->f.WindowPos3d(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glWindowPos2sv(const GLshort *v)
-{
-    d_1_4_Deprecated->f.WindowPos2sv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glWindowPos2s(GLshort x, GLshort y)
-{
-    d_1_4_Deprecated->f.WindowPos2s(x, y);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glWindowPos2iv(const GLint *v)
-{
-    d_1_4_Deprecated->f.WindowPos2iv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glWindowPos2i(GLint x, GLint y)
-{
-    d_1_4_Deprecated->f.WindowPos2i(x, y);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glWindowPos2fv(const GLfloat *v)
-{
-    d_1_4_Deprecated->f.WindowPos2fv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glWindowPos2f(GLfloat x, GLfloat y)
-{
-    d_1_4_Deprecated->f.WindowPos2f(x, y);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glWindowPos2dv(const GLdouble *v)
-{
-    d_1_4_Deprecated->f.WindowPos2dv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glWindowPos2d(GLdouble x, GLdouble y)
-{
-    d_1_4_Deprecated->f.WindowPos2d(x, y);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
-{
-    d_1_4_Deprecated->f.SecondaryColorPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glSecondaryColor3usv(const GLushort *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3usv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glSecondaryColor3us(GLushort red, GLushort green, GLushort blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3us(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glSecondaryColor3uiv(const GLuint *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3uiv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3ui(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glSecondaryColor3ubv(const GLubyte *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3ubv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3ub(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glSecondaryColor3sv(const GLshort *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3sv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glSecondaryColor3s(GLshort red, GLshort green, GLshort blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3s(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glSecondaryColor3iv(const GLint *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3iv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glSecondaryColor3i(GLint red, GLint green, GLint blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3i(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glSecondaryColor3fv(const GLfloat *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3fv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3f(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glSecondaryColor3dv(const GLdouble *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3dv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3d(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glSecondaryColor3bv(const GLbyte *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3bv(v);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3b(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glFogCoordPointer(GLenum type, GLsizei stride, const void *pointer)
-{
-    d_1_4_Deprecated->f.FogCoordPointer(type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glFogCoorddv(const GLdouble *coord)
-{
-    d_1_4_Deprecated->f.FogCoorddv(coord);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glFogCoordd(GLdouble coord)
-{
-    d_1_4_Deprecated->f.FogCoordd(coord);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glFogCoordfv(const GLfloat *coord)
-{
-    d_1_4_Deprecated->f.FogCoordfv(coord);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glFogCoordf(GLfloat coord)
-{
-    d_1_4_Deprecated->f.FogCoordf(coord);
-}
-
-
-// OpenGL 1.5 deprecated functions
-
-// OpenGL 2.0 deprecated functions
-
-// OpenGL 2.1 deprecated functions
-
-// OpenGL 3.0 deprecated functions
-
-// OpenGL 3.1 deprecated functions
-
-// OpenGL 3.2 deprecated functions
-
-// OpenGL 3.3 deprecated functions
-inline void QOpenGLFunctions_4_4_Compatibility::glSecondaryColorP3uiv(GLenum type, const GLuint *color)
-{
-    d_3_3_Deprecated->f.SecondaryColorP3uiv(type, color);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glSecondaryColorP3ui(GLenum type, GLuint color)
-{
-    d_3_3_Deprecated->f.SecondaryColorP3ui(type, color);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glColorP4uiv(GLenum type, const GLuint *color)
-{
-    d_3_3_Deprecated->f.ColorP4uiv(type, color);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glColorP4ui(GLenum type, GLuint color)
-{
-    d_3_3_Deprecated->f.ColorP4ui(type, color);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glColorP3uiv(GLenum type, const GLuint *color)
-{
-    d_3_3_Deprecated->f.ColorP3uiv(type, color);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glColorP3ui(GLenum type, GLuint color)
-{
-    d_3_3_Deprecated->f.ColorP3ui(type, color);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glNormalP3uiv(GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.NormalP3uiv(type, coords);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glNormalP3ui(GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.NormalP3ui(type, coords);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP4uiv(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP4ui(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP3uiv(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP3ui(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP2uiv(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP2ui(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP1uiv(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP1ui(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexCoordP4uiv(GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.TexCoordP4uiv(type, coords);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexCoordP4ui(GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.TexCoordP4ui(type, coords);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexCoordP3uiv(GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.TexCoordP3uiv(type, coords);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexCoordP3ui(GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.TexCoordP3ui(type, coords);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexCoordP2uiv(GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.TexCoordP2uiv(type, coords);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexCoordP2ui(GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.TexCoordP2ui(type, coords);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexCoordP1uiv(GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.TexCoordP1uiv(type, coords);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glTexCoordP1ui(GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.TexCoordP1ui(type, coords);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexP4uiv(GLenum type, const GLuint *value)
-{
-    d_3_3_Deprecated->f.VertexP4uiv(type, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexP4ui(GLenum type, GLuint value)
-{
-    d_3_3_Deprecated->f.VertexP4ui(type, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexP3uiv(GLenum type, const GLuint *value)
-{
-    d_3_3_Deprecated->f.VertexP3uiv(type, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexP3ui(GLenum type, GLuint value)
-{
-    d_3_3_Deprecated->f.VertexP3ui(type, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexP2uiv(GLenum type, const GLuint *value)
-{
-    d_3_3_Deprecated->f.VertexP2uiv(type, value);
-}
-
-inline void QOpenGLFunctions_4_4_Compatibility::glVertexP2ui(GLenum type, GLuint value)
-{
-    d_3_3_Deprecated->f.VertexP2ui(type, value);
-}
-
-
-// OpenGL 4.0 deprecated functions
-
-// OpenGL 4.1 deprecated functions
-
-// OpenGL 4.2 deprecated functions
-
-// OpenGL 4.3 deprecated functions
-
-// OpenGL 4.4 deprecated functions
-
-
-QT_END_NAMESPACE
-
-#ifdef Q_OS_WIN
-#pragma pop_macro("MemoryBarrier")
-#endif
-
-#endif // QT_NO_OPENGL && !QT_OPENGL_ES_2
-
-#endif
diff --git a/src/gui/opengl/qopenglfunctions_4_4_core.cpp b/src/gui/opengl/qopenglfunctions_4_4_core.cpp
deleted file mode 100644
index 6169c7f455..0000000000
--- a/src/gui/opengl/qopenglfunctions_4_4_core.cpp
+++ /dev/null
@@ -1,269 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2015 Klaralvdalens Datakonsult AB (KDAB)
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#include "qopenglfunctions_4_4_core.h"
-#include "qopenglcontext.h"
-
-QT_BEGIN_NAMESPACE
-
-/*!
-    \class QOpenGLFunctions_4_4_Core
-    \inmodule QtGui
-    \since 5.5
-    \wrapper
-    \brief The QOpenGLFunctions_4_4_Core class provides all functions for OpenGL 4.4 core profile.
-
-    This class is a wrapper for functions from OpenGL 4.4 core profile.
-    See reference pages on \l {http://www.opengl.org/sdk/docs/}{opengl.org}
-    for function documentation.
-
-    \sa QAbstractOpenGLFunctions
-*/
-
-QOpenGLFunctions_4_4_Core::QOpenGLFunctions_4_4_Core()
- : QAbstractOpenGLFunctions()
- , d_1_0_Core(nullptr)
- , d_1_1_Core(nullptr)
- , d_1_2_Core(nullptr)
- , d_1_3_Core(nullptr)
- , d_1_4_Core(nullptr)
- , d_1_5_Core(nullptr)
- , d_2_0_Core(nullptr)
- , d_2_1_Core(nullptr)
- , d_3_0_Core(nullptr)
- , d_3_1_Core(nullptr)
- , d_3_2_Core(nullptr)
- , d_3_3_Core(nullptr)
- , d_4_0_Core(nullptr)
- , d_4_1_Core(nullptr)
- , d_4_2_Core(nullptr)
- , d_4_3_Core(nullptr)
- , d_4_4_Core(nullptr)
-{
-}
-
-QOpenGLFunctions_4_4_Core::~QOpenGLFunctions_4_4_Core()
-{
-    if (d_1_0_Core) {
-        d_1_0_Core->refs.deref();
-        Q_ASSERT(d_1_0_Core->refs.loadRelaxed());
-    }
-    if (d_1_1_Core) {
-        d_1_1_Core->refs.deref();
-        Q_ASSERT(d_1_1_Core->refs.loadRelaxed());
-    }
-    if (d_1_2_Core) {
-        d_1_2_Core->refs.deref();
-        Q_ASSERT(d_1_2_Core->refs.loadRelaxed());
-    }
-    if (d_1_3_Core) {
-        d_1_3_Core->refs.deref();
-        Q_ASSERT(d_1_3_Core->refs.loadRelaxed());
-    }
-    if (d_1_4_Core) {
-        d_1_4_Core->refs.deref();
-        Q_ASSERT(d_1_4_Core->refs.loadRelaxed());
-    }
-    if (d_1_5_Core) {
-        d_1_5_Core->refs.deref();
-        Q_ASSERT(d_1_5_Core->refs.loadRelaxed());
-    }
-    if (d_2_0_Core) {
-        d_2_0_Core->refs.deref();
-        Q_ASSERT(d_2_0_Core->refs.loadRelaxed());
-    }
-    if (d_2_1_Core) {
-        d_2_1_Core->refs.deref();
-        Q_ASSERT(d_2_1_Core->refs.loadRelaxed());
-    }
-    if (d_3_0_Core) {
-        d_3_0_Core->refs.deref();
-        Q_ASSERT(d_3_0_Core->refs.loadRelaxed());
-    }
-    if (d_3_1_Core) {
-        d_3_1_Core->refs.deref();
-        Q_ASSERT(d_3_1_Core->refs.loadRelaxed());
-    }
-    if (d_3_2_Core) {
-        d_3_2_Core->refs.deref();
-        Q_ASSERT(d_3_2_Core->refs.loadRelaxed());
-    }
-    if (d_3_3_Core) {
-        d_3_3_Core->refs.deref();
-        Q_ASSERT(d_3_3_Core->refs.loadRelaxed());
-    }
-    if (d_4_0_Core) {
-        d_4_0_Core->refs.deref();
-        Q_ASSERT(d_4_0_Core->refs.loadRelaxed());
-    }
-    if (d_4_1_Core) {
-        d_4_1_Core->refs.deref();
-        Q_ASSERT(d_4_1_Core->refs.loadRelaxed());
-    }
-    if (d_4_2_Core) {
-        d_4_2_Core->refs.deref();
-        Q_ASSERT(d_4_2_Core->refs.loadRelaxed());
-    }
-    if (d_4_3_Core) {
-        d_4_3_Core->refs.deref();
-        Q_ASSERT(d_4_3_Core->refs.loadRelaxed());
-    }
-    if (d_4_4_Core) {
-        d_4_4_Core->refs.deref();
-        Q_ASSERT(d_4_4_Core->refs.loadRelaxed());
-    }
-}
-
-bool QOpenGLFunctions_4_4_Core::initializeOpenGLFunctions()
-{
-    if ( isInitialized() )
-        return true;
-
-    QOpenGLContext* context = QOpenGLContext::currentContext();
-
-    // If owned by a context object make sure it is current.
-    // Also check that current context is capable of resolving all needed functions
-    if (((owningContext() && owningContext() == context) || !owningContext())
-        && QOpenGLFunctions_4_4_Core::isContextCompatible(context))
-    {
-        // Associate with private implementation, creating if necessary
-        // Function pointers in the backends are resolved at creation time
-        QOpenGLVersionFunctionsBackend* d = nullptr;
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        d_1_3_Core = static_cast<QOpenGLFunctions_1_3_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        d_1_4_Core = static_cast<QOpenGLFunctions_1_4_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        d_1_5_Core = static_cast<QOpenGLFunctions_1_5_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        d_2_0_Core = static_cast<QOpenGLFunctions_2_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        d_2_1_Core = static_cast<QOpenGLFunctions_2_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        d_3_0_Core = static_cast<QOpenGLFunctions_3_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
-        d_3_1_Core = static_cast<QOpenGLFunctions_3_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
-        d_3_2_Core = static_cast<QOpenGLFunctions_3_2_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_CoreBackend::versionStatus());
-        d_3_3_Core = static_cast<QOpenGLFunctions_3_3_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_0_CoreBackend::versionStatus());
-        d_4_0_Core = static_cast<QOpenGLFunctions_4_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_1_CoreBackend::versionStatus());
-        d_4_1_Core = static_cast<QOpenGLFunctions_4_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_2_CoreBackend::versionStatus());
-        d_4_2_Core = static_cast<QOpenGLFunctions_4_2_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_3_CoreBackend::versionStatus());
-        d_4_3_Core = static_cast<QOpenGLFunctions_4_3_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_4_CoreBackend::versionStatus());
-        d_4_4_Core = static_cast<QOpenGLFunctions_4_4_CoreBackend*>(d);
-        d->refs.ref();
-
-        QAbstractOpenGLFunctions::initializeOpenGLFunctions();
-    }
-    return isInitialized();
-}
-
-bool QOpenGLFunctions_4_4_Core::isContextCompatible(QOpenGLContext *context)
-{
-    Q_ASSERT(context);
-    QSurfaceFormat f = context->format();
-    const QPair<int, int> v = qMakePair(f.majorVersion(), f.minorVersion());
-    if (v < qMakePair(4, 4))
-        return false;
-
-    return true;
-}
-
-QOpenGLVersionProfile QOpenGLFunctions_4_4_Core::versionProfile()
-{
-    QOpenGLVersionProfile v;
-    v.setVersion(4, 4);
-    v.setProfile(QSurfaceFormat::CoreProfile);
-    return v;
-}
-
-QT_END_NAMESPACE
diff --git a/src/gui/opengl/qopenglfunctions_4_4_core.h b/src/gui/opengl/qopenglfunctions_4_4_core.h
deleted file mode 100644
index 1ad6f40214..0000000000
--- a/src/gui/opengl/qopenglfunctions_4_4_core.h
+++ /dev/null
@@ -1,3430 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2015 Klaralvdalens Datakonsult AB (KDAB)
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#ifndef QOPENGLVERSIONFUNCTIONS_4_4_CORE_H
-#define QOPENGLVERSIONFUNCTIONS_4_4_CORE_H
-
-#include <QtGui/qtguiglobal.h>
-
-#if !defined(QT_NO_OPENGL) && !defined(QT_OPENGL_ES_2)
-
-#include <QtGui/QOpenGLVersionFunctions>
-#include <QtGui/qopenglcontext.h>
-
-// MemoryBarrier is a macro on some architectures on Windows
-#ifdef Q_OS_WIN
-#pragma push_macro("MemoryBarrier")
-#undef MemoryBarrier
-#endif
-
-QT_BEGIN_NAMESPACE
-
-class Q_GUI_EXPORT QOpenGLFunctions_4_4_Core : public QAbstractOpenGLFunctions
-{
-public:
-    QOpenGLFunctions_4_4_Core();
-    ~QOpenGLFunctions_4_4_Core();
-
-    bool initializeOpenGLFunctions() override;
-
-    // OpenGL 1.0 core functions
-    void glViewport(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glDepthRange(GLdouble nearVal, GLdouble farVal);
-    GLboolean glIsEnabled(GLenum cap);
-    void glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params);
-    void glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params);
-    void glGetTexParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, void *pixels);
-    const GLubyte * glGetString(GLenum name);
-    void glGetIntegerv(GLenum pname, GLint *data);
-    void glGetFloatv(GLenum pname, GLfloat *data);
-    GLenum glGetError();
-    void glGetDoublev(GLenum pname, GLdouble *data);
-    void glGetBooleanv(GLenum pname, GLboolean *data);
-    void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels);
-    void glReadBuffer(GLenum src);
-    void glPixelStorei(GLenum pname, GLint param);
-    void glPixelStoref(GLenum pname, GLfloat param);
-    void glDepthFunc(GLenum func);
-    void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass);
-    void glStencilFunc(GLenum func, GLint ref, GLuint mask);
-    void glLogicOp(GLenum opcode);
-    void glBlendFunc(GLenum sfactor, GLenum dfactor);
-    void glFlush();
-    void glFinish();
-    void glEnable(GLenum cap);
-    void glDisable(GLenum cap);
-    void glDepthMask(GLboolean flag);
-    void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
-    void glStencilMask(GLuint mask);
-    void glClearDepth(GLdouble depth);
-    void glClearStencil(GLint s);
-    void glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glClear(GLbitfield mask);
-    void glDrawBuffer(GLenum buf);
-    void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels);
-    void glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels);
-    void glTexParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glTexParameteri(GLenum target, GLenum pname, GLint param);
-    void glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glTexParameterf(GLenum target, GLenum pname, GLfloat param);
-    void glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glPolygonMode(GLenum face, GLenum mode);
-    void glPointSize(GLfloat size);
-    void glLineWidth(GLfloat width);
-    void glHint(GLenum target, GLenum mode);
-    void glFrontFace(GLenum mode);
-    void glCullFace(GLenum mode);
-
-    // OpenGL 1.1 core functions
-    GLboolean glIsTexture(GLuint texture);
-    void glGenTextures(GLsizei n, GLuint *textures);
-    void glDeleteTextures(GLsizei n, const GLuint *textures);
-    void glBindTexture(GLenum target, GLuint texture);
-    void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels);
-    void glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels);
-    void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
-    void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
-    void glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
-    void glPolygonOffset(GLfloat factor, GLfloat units);
-    void glDrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices);
-    void glDrawArrays(GLenum mode, GLint first, GLsizei count);
-
-    // OpenGL 1.2 core functions
-    void glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glBlendEquation(GLenum mode);
-    void glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels);
-    void glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels);
-    void glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices);
-
-    // OpenGL 1.3 core functions
-    void glGetCompressedTexImage(GLenum target, GLint level, void *img);
-    void glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data);
-    void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data);
-    void glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data);
-    void glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data);
-    void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data);
-    void glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data);
-    void glSampleCoverage(GLfloat value, GLboolean invert);
-    void glActiveTexture(GLenum texture);
-
-    // OpenGL 1.4 core functions
-    void glPointParameteriv(GLenum pname, const GLint *params);
-    void glPointParameteri(GLenum pname, GLint param);
-    void glPointParameterfv(GLenum pname, const GLfloat *params);
-    void glPointParameterf(GLenum pname, GLfloat param);
-    void glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const void *const *indices, GLsizei drawcount);
-    void glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount);
-    void glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
-
-    // OpenGL 1.5 core functions
-    void glGetBufferPointerv(GLenum target, GLenum pname, void * *params);
-    void glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params);
-    GLboolean glUnmapBuffer(GLenum target);
-    void * glMapBuffer(GLenum target, GLenum access);
-    void glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, void *data);
-    void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void *data);
-    void glBufferData(GLenum target, GLsizeiptr size, const void *data, GLenum usage);
-    GLboolean glIsBuffer(GLuint buffer);
-    void glGenBuffers(GLsizei n, GLuint *buffers);
-    void glDeleteBuffers(GLsizei n, const GLuint *buffers);
-    void glBindBuffer(GLenum target, GLuint buffer);
-    void glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params);
-    void glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params);
-    void glGetQueryiv(GLenum target, GLenum pname, GLint *params);
-    void glEndQuery(GLenum target);
-    void glBeginQuery(GLenum target, GLuint id);
-    GLboolean glIsQuery(GLuint id);
-    void glDeleteQueries(GLsizei n, const GLuint *ids);
-    void glGenQueries(GLsizei n, GLuint *ids);
-
-    // OpenGL 2.0 core functions
-    void glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer);
-    void glVertexAttrib4usv(GLuint index, const GLushort *v);
-    void glVertexAttrib4uiv(GLuint index, const GLuint *v);
-    void glVertexAttrib4ubv(GLuint index, const GLubyte *v);
-    void glVertexAttrib4sv(GLuint index, const GLshort *v);
-    void glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
-    void glVertexAttrib4iv(GLuint index, const GLint *v);
-    void glVertexAttrib4fv(GLuint index, const GLfloat *v);
-    void glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void glVertexAttrib4dv(GLuint index, const GLdouble *v);
-    void glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glVertexAttrib4bv(GLuint index, const GLbyte *v);
-    void glVertexAttrib4Nusv(GLuint index, const GLushort *v);
-    void glVertexAttrib4Nuiv(GLuint index, const GLuint *v);
-    void glVertexAttrib4Nubv(GLuint index, const GLubyte *v);
-    void glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
-    void glVertexAttrib4Nsv(GLuint index, const GLshort *v);
-    void glVertexAttrib4Niv(GLuint index, const GLint *v);
-    void glVertexAttrib4Nbv(GLuint index, const GLbyte *v);
-    void glVertexAttrib3sv(GLuint index, const GLshort *v);
-    void glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z);
-    void glVertexAttrib3fv(GLuint index, const GLfloat *v);
-    void glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z);
-    void glVertexAttrib3dv(GLuint index, const GLdouble *v);
-    void glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z);
-    void glVertexAttrib2sv(GLuint index, const GLshort *v);
-    void glVertexAttrib2s(GLuint index, GLshort x, GLshort y);
-    void glVertexAttrib2fv(GLuint index, const GLfloat *v);
-    void glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y);
-    void glVertexAttrib2dv(GLuint index, const GLdouble *v);
-    void glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y);
-    void glVertexAttrib1sv(GLuint index, const GLshort *v);
-    void glVertexAttrib1s(GLuint index, GLshort x);
-    void glVertexAttrib1fv(GLuint index, const GLfloat *v);
-    void glVertexAttrib1f(GLuint index, GLfloat x);
-    void glVertexAttrib1dv(GLuint index, const GLdouble *v);
-    void glVertexAttrib1d(GLuint index, GLdouble x);
-    void glValidateProgram(GLuint program);
-    void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniform4iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform3iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform2iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform1iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform4fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform3fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform2fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform1fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
-    void glUniform3i(GLint location, GLint v0, GLint v1, GLint v2);
-    void glUniform2i(GLint location, GLint v0, GLint v1);
-    void glUniform1i(GLint location, GLint v0);
-    void glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
-    void glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
-    void glUniform2f(GLint location, GLfloat v0, GLfloat v1);
-    void glUniform1f(GLint location, GLfloat v0);
-    void glUseProgram(GLuint program);
-    void glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length);
-    void glLinkProgram(GLuint program);
-    GLboolean glIsShader(GLuint shader);
-    GLboolean glIsProgram(GLuint program);
-    void glGetVertexAttribPointerv(GLuint index, GLenum pname, void * *pointer);
-    void glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params);
-    void glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params);
-    void glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params);
-    void glGetUniformiv(GLuint program, GLint location, GLint *params);
-    void glGetUniformfv(GLuint program, GLint location, GLfloat *params);
-    GLint glGetUniformLocation(GLuint program, const GLchar *name);
-    void glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source);
-    void glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void glGetShaderiv(GLuint shader, GLenum pname, GLint *params);
-    void glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void glGetProgramiv(GLuint program, GLenum pname, GLint *params);
-    GLint glGetAttribLocation(GLuint program, const GLchar *name);
-    void glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders);
-    void glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
-    void glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
-    void glEnableVertexAttribArray(GLuint index);
-    void glDisableVertexAttribArray(GLuint index);
-    void glDetachShader(GLuint program, GLuint shader);
-    void glDeleteShader(GLuint shader);
-    void glDeleteProgram(GLuint program);
-    GLuint glCreateShader(GLenum type);
-    GLuint glCreateProgram();
-    void glCompileShader(GLuint shader);
-    void glBindAttribLocation(GLuint program, GLuint index, const GLchar *name);
-    void glAttachShader(GLuint program, GLuint shader);
-    void glStencilMaskSeparate(GLenum face, GLuint mask);
-    void glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask);
-    void glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);
-    void glDrawBuffers(GLsizei n, const GLenum *bufs);
-    void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha);
-
-    // OpenGL 2.1 core functions
-    void glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-
-    // OpenGL 3.0 core functions
-    GLboolean glIsVertexArray(GLuint array);
-    void glGenVertexArrays(GLsizei n, GLuint *arrays);
-    void glDeleteVertexArrays(GLsizei n, const GLuint *arrays);
-    void glBindVertexArray(GLuint array);
-    void glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length);
-    void * glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
-    void glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
-    void glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
-    void glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
-    void glGenerateMipmap(GLenum target);
-    void glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params);
-    void glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
-    void glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset);
-    void glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
-    void glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
-    GLenum glCheckFramebufferStatus(GLenum target);
-    void glGenFramebuffers(GLsizei n, GLuint *framebuffers);
-    void glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers);
-    void glBindFramebuffer(GLenum target, GLuint framebuffer);
-    GLboolean glIsFramebuffer(GLuint framebuffer);
-    void glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
-    void glGenRenderbuffers(GLsizei n, GLuint *renderbuffers);
-    void glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers);
-    void glBindRenderbuffer(GLenum target, GLuint renderbuffer);
-    GLboolean glIsRenderbuffer(GLuint renderbuffer);
-    const GLubyte * glGetStringi(GLenum name, GLuint index);
-    void glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
-    void glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value);
-    void glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value);
-    void glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value);
-    void glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params);
-    void glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params);
-    void glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params);
-    void glTexParameterIiv(GLenum target, GLenum pname, const GLint *params);
-    void glUniform4uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform3uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform2uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform1uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
-    void glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2);
-    void glUniform2ui(GLint location, GLuint v0, GLuint v1);
-    void glUniform1ui(GLint location, GLuint v0);
-    GLint glGetFragDataLocation(GLuint program, const GLchar *name);
-    void glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name);
-    void glGetUniformuiv(GLuint program, GLint location, GLuint *params);
-    void glVertexAttribI4usv(GLuint index, const GLushort *v);
-    void glVertexAttribI4ubv(GLuint index, const GLubyte *v);
-    void glVertexAttribI4sv(GLuint index, const GLshort *v);
-    void glVertexAttribI4bv(GLuint index, const GLbyte *v);
-    void glVertexAttribI4uiv(GLuint index, const GLuint *v);
-    void glVertexAttribI3uiv(GLuint index, const GLuint *v);
-    void glVertexAttribI2uiv(GLuint index, const GLuint *v);
-    void glVertexAttribI1uiv(GLuint index, const GLuint *v);
-    void glVertexAttribI4iv(GLuint index, const GLint *v);
-    void glVertexAttribI3iv(GLuint index, const GLint *v);
-    void glVertexAttribI2iv(GLuint index, const GLint *v);
-    void glVertexAttribI1iv(GLuint index, const GLint *v);
-    void glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
-    void glVertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z);
-    void glVertexAttribI2ui(GLuint index, GLuint x, GLuint y);
-    void glVertexAttribI1ui(GLuint index, GLuint x);
-    void glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w);
-    void glVertexAttribI3i(GLuint index, GLint x, GLint y, GLint z);
-    void glVertexAttribI2i(GLuint index, GLint x, GLint y);
-    void glVertexAttribI1i(GLuint index, GLint x);
-    void glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params);
-    void glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params);
-    void glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer);
-    void glEndConditionalRender();
-    void glBeginConditionalRender(GLuint id, GLenum mode);
-    void glClampColor(GLenum target, GLenum clamp);
-    void glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name);
-    void glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode);
-    void glBindBufferBase(GLenum target, GLuint index, GLuint buffer);
-    void glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
-    void glEndTransformFeedback();
-    void glBeginTransformFeedback(GLenum primitiveMode);
-    GLboolean glIsEnabledi(GLenum target, GLuint index);
-    void glDisablei(GLenum target, GLuint index);
-    void glEnablei(GLenum target, GLuint index);
-    void glGetIntegeri_v(GLenum target, GLuint index, GLint *data);
-    void glGetBooleani_v(GLenum target, GLuint index, GLboolean *data);
-    void glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a);
-
-    // OpenGL 3.1 core functions
-    void glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);
-    void glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName);
-    void glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params);
-    GLuint glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName);
-    void glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName);
-    void glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params);
-    void glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar *const *uniformNames, GLuint *uniformIndices);
-    void glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
-    void glPrimitiveRestartIndex(GLuint index);
-    void glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer);
-    void glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount);
-    void glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount);
-
-    // OpenGL 3.2 core functions
-    void glSampleMaski(GLuint maskNumber, GLbitfield mask);
-    void glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val);
-    void glTexImage3DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
-    void glTexImage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
-    void glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level);
-    void glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params);
-    void glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data);
-    void glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values);
-    void glGetInteger64v(GLenum pname, GLint64 *data);
-    void glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout);
-    GLenum glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout);
-    void glDeleteSync(GLsync sync);
-    GLboolean glIsSync(GLsync sync);
-    GLsync glFenceSync(GLenum condition, GLbitfield flags);
-    void glProvokingVertex(GLenum mode);
-    void glMultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count, GLenum type, const void *const *indices, GLsizei drawcount, const GLint *basevertex);
-    void glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex);
-    void glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex);
-    void glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex);
-
-    // OpenGL 3.3 core functions
-    void glVertexAttribP4uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glVertexAttribP3uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glVertexAttribP2uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glVertexAttribP1uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glVertexAttribDivisor(GLuint index, GLuint divisor);
-    void glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params);
-    void glGetQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params);
-    void glQueryCounter(GLuint id, GLenum target);
-    void glGetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params);
-    void glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params);
-    void glGetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params);
-    void glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params);
-    void glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param);
-    void glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param);
-    void glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param);
-    void glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param);
-    void glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param);
-    void glSamplerParameteri(GLuint sampler, GLenum pname, GLint param);
-    void glBindSampler(GLuint unit, GLuint sampler);
-    GLboolean glIsSampler(GLuint sampler);
-    void glDeleteSamplers(GLsizei count, const GLuint *samplers);
-    void glGenSamplers(GLsizei count, GLuint *samplers);
-    GLint glGetFragDataIndex(GLuint program, const GLchar *name);
-    void glBindFragDataLocationIndexed(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name);
-
-    // OpenGL 4.0 core functions
-    void glGetQueryIndexediv(GLenum target, GLuint index, GLenum pname, GLint *params);
-    void glEndQueryIndexed(GLenum target, GLuint index);
-    void glBeginQueryIndexed(GLenum target, GLuint index, GLuint id);
-    void glDrawTransformFeedbackStream(GLenum mode, GLuint id, GLuint stream);
-    void glDrawTransformFeedback(GLenum mode, GLuint id);
-    void glResumeTransformFeedback();
-    void glPauseTransformFeedback();
-    GLboolean glIsTransformFeedback(GLuint id);
-    void glGenTransformFeedbacks(GLsizei n, GLuint *ids);
-    void glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids);
-    void glBindTransformFeedback(GLenum target, GLuint id);
-    void glPatchParameterfv(GLenum pname, const GLfloat *values);
-    void glPatchParameteri(GLenum pname, GLint value);
-    void glGetProgramStageiv(GLuint program, GLenum shadertype, GLenum pname, GLint *values);
-    void glGetUniformSubroutineuiv(GLenum shadertype, GLint location, GLuint *params);
-    void glUniformSubroutinesuiv(GLenum shadertype, GLsizei count, const GLuint *indices);
-    void glGetActiveSubroutineName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name);
-    void glGetActiveSubroutineUniformName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name);
-    void glGetActiveSubroutineUniformiv(GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values);
-    GLuint glGetSubroutineIndex(GLuint program, GLenum shadertype, const GLchar *name);
-    GLint glGetSubroutineUniformLocation(GLuint program, GLenum shadertype, const GLchar *name);
-    void glGetUniformdv(GLuint program, GLint location, GLdouble *params);
-    void glUniformMatrix4x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix4x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix3x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix3x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix2x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix2x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniform4dv(GLint location, GLsizei count, const GLdouble *value);
-    void glUniform3dv(GLint location, GLsizei count, const GLdouble *value);
-    void glUniform2dv(GLint location, GLsizei count, const GLdouble *value);
-    void glUniform1dv(GLint location, GLsizei count, const GLdouble *value);
-    void glUniform4d(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glUniform3d(GLint location, GLdouble x, GLdouble y, GLdouble z);
-    void glUniform2d(GLint location, GLdouble x, GLdouble y);
-    void glUniform1d(GLint location, GLdouble x);
-    void glDrawElementsIndirect(GLenum mode, GLenum type, const void *indirect);
-    void glDrawArraysIndirect(GLenum mode, const void *indirect);
-    void glBlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
-    void glBlendFunci(GLuint buf, GLenum src, GLenum dst);
-    void glBlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha);
-    void glBlendEquationi(GLuint buf, GLenum mode);
-    void glMinSampleShading(GLfloat value);
-
-    // OpenGL 4.1 core functions
-    void glGetDoublei_v(GLenum target, GLuint index, GLdouble *data);
-    void glGetFloati_v(GLenum target, GLuint index, GLfloat *data);
-    void glDepthRangeIndexed(GLuint index, GLdouble n, GLdouble f);
-    void glDepthRangeArrayv(GLuint first, GLsizei count, const GLdouble *v);
-    void glScissorIndexedv(GLuint index, const GLint *v);
-    void glScissorIndexed(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height);
-    void glScissorArrayv(GLuint first, GLsizei count, const GLint *v);
-    void glViewportIndexedfv(GLuint index, const GLfloat *v);
-    void glViewportIndexedf(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h);
-    void glViewportArrayv(GLuint first, GLsizei count, const GLfloat *v);
-    void glGetVertexAttribLdv(GLuint index, GLenum pname, GLdouble *params);
-    void glVertexAttribLPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer);
-    void glVertexAttribL4dv(GLuint index, const GLdouble *v);
-    void glVertexAttribL3dv(GLuint index, const GLdouble *v);
-    void glVertexAttribL2dv(GLuint index, const GLdouble *v);
-    void glVertexAttribL1dv(GLuint index, const GLdouble *v);
-    void glVertexAttribL4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glVertexAttribL3d(GLuint index, GLdouble x, GLdouble y, GLdouble z);
-    void glVertexAttribL2d(GLuint index, GLdouble x, GLdouble y);
-    void glVertexAttribL1d(GLuint index, GLdouble x);
-    void glGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void glValidateProgramPipeline(GLuint pipeline);
-    void glProgramUniformMatrix4x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix3x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix4x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix2x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix3x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix2x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix4x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix3x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix4x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix2x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix3x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix2x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniform4uiv(GLuint program, GLint location, GLsizei count, const GLuint *value);
-    void glProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
-    void glProgramUniform4dv(GLuint program, GLint location, GLsizei count, const GLdouble *value);
-    void glProgramUniform4d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3);
-    void glProgramUniform4fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-    void glProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
-    void glProgramUniform4iv(GLuint program, GLint location, GLsizei count, const GLint *value);
-    void glProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
-    void glProgramUniform3uiv(GLuint program, GLint location, GLsizei count, const GLuint *value);
-    void glProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2);
-    void glProgramUniform3dv(GLuint program, GLint location, GLsizei count, const GLdouble *value);
-    void glProgramUniform3d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2);
-    void glProgramUniform3fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-    void glProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
-    void glProgramUniform3iv(GLuint program, GLint location, GLsizei count, const GLint *value);
-    void glProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2);
-    void glProgramUniform2uiv(GLuint program, GLint location, GLsizei count, const GLuint *value);
-    void glProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1);
-    void glProgramUniform2dv(GLuint program, GLint location, GLsizei count, const GLdouble *value);
-    void glProgramUniform2d(GLuint program, GLint location, GLdouble v0, GLdouble v1);
-    void glProgramUniform2fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-    void glProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1);
-    void glProgramUniform2iv(GLuint program, GLint location, GLsizei count, const GLint *value);
-    void glProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1);
-    void glProgramUniform1uiv(GLuint program, GLint location, GLsizei count, const GLuint *value);
-    void glProgramUniform1ui(GLuint program, GLint location, GLuint v0);
-    void glProgramUniform1dv(GLuint program, GLint location, GLsizei count, const GLdouble *value);
-    void glProgramUniform1d(GLuint program, GLint location, GLdouble v0);
-    void glProgramUniform1fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-    void glProgramUniform1f(GLuint program, GLint location, GLfloat v0);
-    void glProgramUniform1iv(GLuint program, GLint location, GLsizei count, const GLint *value);
-    void glProgramUniform1i(GLuint program, GLint location, GLint v0);
-    void glGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params);
-    GLboolean glIsProgramPipeline(GLuint pipeline);
-    void glGenProgramPipelines(GLsizei n, GLuint *pipelines);
-    void glDeleteProgramPipelines(GLsizei n, const GLuint *pipelines);
-    void glBindProgramPipeline(GLuint pipeline);
-    GLuint glCreateShaderProgramv(GLenum type, GLsizei count, const GLchar* const *strings);
-    void glActiveShaderProgram(GLuint pipeline, GLuint program);
-    void glUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program);
-    void glProgramParameteri(GLuint program, GLenum pname, GLint value);
-    void glProgramBinary(GLuint program, GLenum binaryFormat, const void *binary, GLsizei length);
-    void glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, void *binary);
-    void glClearDepthf(GLfloat dd);
-    void glDepthRangef(GLfloat n, GLfloat f);
-    void glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision);
-    void glShaderBinary(GLsizei count, const GLuint *shaders, GLenum binaryformat, const void *binary, GLsizei length);
-    void glReleaseShaderCompiler();
-
-    // OpenGL 4.2 core functions
-    void glDrawTransformFeedbackStreamInstanced(GLenum mode, GLuint id, GLuint stream, GLsizei instancecount);
-    void glDrawTransformFeedbackInstanced(GLenum mode, GLuint id, GLsizei instancecount);
-    void glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
-    void glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);
-    void glTexStorage1D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width);
-    void glMemoryBarrier(GLbitfield barriers);
-    void glBindImageTexture(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format);
-    void glGetActiveAtomicCounterBufferiv(GLuint program, GLuint bufferIndex, GLenum pname, GLint *params);
-    void glGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params);
-    void glDrawElementsInstancedBaseVertexBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance);
-    void glDrawElementsInstancedBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLuint baseinstance);
-    void glDrawArraysInstancedBaseInstance(GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance);
-
-    // OpenGL 4.3 core functions
-    void glGetObjectPtrLabel(const void *ptr, GLsizei bufSize, GLsizei *length, GLchar *label);
-    void glObjectPtrLabel(const void *ptr, GLsizei length, const GLchar *label);
-    void glGetObjectLabel(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label);
-    void glObjectLabel(GLenum identifier, GLuint name, GLsizei length, const GLchar *label);
-    void glPopDebugGroup();
-    void glPushDebugGroup(GLenum source, GLuint id, GLsizei length, const GLchar *message);
-    GLuint glGetDebugMessageLog(GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog);
-    void glDebugMessageCallback(GLDEBUGPROC callback, const void *userParam);
-    void glDebugMessageInsert(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf);
-    void glDebugMessageControl(GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled);
-    void glVertexBindingDivisor(GLuint bindingindex, GLuint divisor);
-    void glVertexAttribBinding(GLuint attribindex, GLuint bindingindex);
-    void glVertexAttribLFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);
-    void glVertexAttribIFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);
-    void glVertexAttribFormat(GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset);
-    void glBindVertexBuffer(GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride);
-    void glTextureView(GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers);
-    void glTexStorage3DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
-    void glTexStorage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
-    void glTexBufferRange(GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size);
-    void glShaderStorageBlockBinding(GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding);
-    GLint glGetProgramResourceLocationIndex(GLuint program, GLenum programInterface, const GLchar *name);
-    GLint glGetProgramResourceLocation(GLuint program, GLenum programInterface, const GLchar *name);
-    void glGetProgramResourceiv(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params);
-    void glGetProgramResourceName(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name);
-    GLuint glGetProgramResourceIndex(GLuint program, GLenum programInterface, const GLchar *name);
-    void glGetProgramInterfaceiv(GLuint program, GLenum programInterface, GLenum pname, GLint *params);
-    void glMultiDrawElementsIndirect(GLenum mode, GLenum type, const void *indirect, GLsizei drawcount, GLsizei stride);
-    void glMultiDrawArraysIndirect(GLenum mode, const void *indirect, GLsizei drawcount, GLsizei stride);
-    void glInvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glInvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments);
-    void glInvalidateBufferData(GLuint buffer);
-    void glInvalidateBufferSubData(GLuint buffer, GLintptr offset, GLsizeiptr length);
-    void glInvalidateTexImage(GLuint texture, GLint level);
-    void glInvalidateTexSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth);
-    void glGetInternalformati64v(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint64 *params);
-    void glGetFramebufferParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glFramebufferParameteri(GLenum target, GLenum pname, GLint param);
-    void glCopyImageSubData(GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth);
-    void glDispatchComputeIndirect(GLintptr indirect);
-    void glDispatchCompute(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z);
-    void glClearBufferSubData(GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data);
-    void glClearBufferData(GLenum target, GLenum internalformat, GLenum format, GLenum type, const void *data);
-
-    // OpenGL 4.4 core functions
-    void glBindVertexBuffers(GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides);
-    void glBindImageTextures(GLuint first, GLsizei count, const GLuint *textures);
-    void glBindSamplers(GLuint first, GLsizei count, const GLuint *samplers);
-    void glBindTextures(GLuint first, GLsizei count, const GLuint *textures);
-    void glBindBuffersRange(GLenum target, GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizeiptr *sizes);
-    void glBindBuffersBase(GLenum target, GLuint first, GLsizei count, const GLuint *buffers);
-    void glClearTexSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *data);
-    void glClearTexImage(GLuint texture, GLint level, GLenum format, GLenum type, const void *data);
-    void glBufferStorage(GLenum target, GLsizeiptr size, const void *data, GLbitfield flags);
-
-private:
-    friend class QOpenGLContext;
-
-    static bool isContextCompatible(QOpenGLContext *context);
-    static QOpenGLVersionProfile versionProfile();
-
-    QOpenGLFunctions_1_0_CoreBackend* d_1_0_Core;
-    QOpenGLFunctions_1_1_CoreBackend* d_1_1_Core;
-    QOpenGLFunctions_1_2_CoreBackend* d_1_2_Core;
-    QOpenGLFunctions_1_3_CoreBackend* d_1_3_Core;
-    QOpenGLFunctions_1_4_CoreBackend* d_1_4_Core;
-    QOpenGLFunctions_1_5_CoreBackend* d_1_5_Core;
-    QOpenGLFunctions_2_0_CoreBackend* d_2_0_Core;
-    QOpenGLFunctions_2_1_CoreBackend* d_2_1_Core;
-    QOpenGLFunctions_3_0_CoreBackend* d_3_0_Core;
-    QOpenGLFunctions_3_1_CoreBackend* d_3_1_Core;
-    QOpenGLFunctions_3_2_CoreBackend* d_3_2_Core;
-    QOpenGLFunctions_3_3_CoreBackend* d_3_3_Core;
-    QOpenGLFunctions_4_0_CoreBackend* d_4_0_Core;
-    QOpenGLFunctions_4_1_CoreBackend* d_4_1_Core;
-    QOpenGLFunctions_4_2_CoreBackend* d_4_2_Core;
-    QOpenGLFunctions_4_3_CoreBackend* d_4_3_Core;
-    QOpenGLFunctions_4_4_CoreBackend* d_4_4_Core;
-};
-
-// OpenGL 1.0 core functions
-inline void QOpenGLFunctions_4_4_Core::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_0_Core->f.Viewport(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glDepthRange(GLdouble nearVal, GLdouble farVal)
-{
-    d_1_0_Core->f.DepthRange(nearVal, farVal);
-}
-
-inline GLboolean QOpenGLFunctions_4_4_Core::glIsEnabled(GLenum cap)
-{
-    return d_1_0_Core->f.IsEnabled(cap);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetTexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetTexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, void *pixels)
-{
-    d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
-}
-
-inline const GLubyte * QOpenGLFunctions_4_4_Core::glGetString(GLenum name)
-{
-    return d_1_0_Core->f.GetString(name);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetIntegerv(GLenum pname, GLint *data)
-{
-    d_1_0_Core->f.GetIntegerv(pname, data);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetFloatv(GLenum pname, GLfloat *data)
-{
-    d_1_0_Core->f.GetFloatv(pname, data);
-}
-
-inline GLenum QOpenGLFunctions_4_4_Core::glGetError()
-{
-    return d_1_0_Core->f.GetError();
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetDoublev(GLenum pname, GLdouble *data)
-{
-    d_1_0_Core->f.GetDoublev(pname, data);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetBooleanv(GLenum pname, GLboolean *data)
-{
-    d_1_0_Core->f.GetBooleanv(pname, data);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels)
-{
-    d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glReadBuffer(GLenum src)
-{
-    d_1_0_Core->f.ReadBuffer(src);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glPixelStorei(GLenum pname, GLint param)
-{
-    d_1_0_Core->f.PixelStorei(pname, param);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glPixelStoref(GLenum pname, GLfloat param)
-{
-    d_1_0_Core->f.PixelStoref(pname, param);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glDepthFunc(GLenum func)
-{
-    d_1_0_Core->f.DepthFunc(func);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
-{
-    d_1_0_Core->f.StencilOp(fail, zfail, zpass);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glStencilFunc(GLenum func, GLint ref, GLuint mask)
-{
-    d_1_0_Core->f.StencilFunc(func, ref, mask);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glLogicOp(GLenum opcode)
-{
-    d_1_0_Core->f.LogicOp(opcode);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glBlendFunc(GLenum sfactor, GLenum dfactor)
-{
-    d_1_0_Core->f.BlendFunc(sfactor, dfactor);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glFlush()
-{
-    d_1_0_Core->f.Flush();
-}
-
-inline void QOpenGLFunctions_4_4_Core::glFinish()
-{
-    d_1_0_Core->f.Finish();
-}
-
-inline void QOpenGLFunctions_4_4_Core::glEnable(GLenum cap)
-{
-    d_1_0_Core->f.Enable(cap);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glDisable(GLenum cap)
-{
-    d_1_0_Core->f.Disable(cap);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glDepthMask(GLboolean flag)
-{
-    d_1_0_Core->f.DepthMask(flag);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
-{
-    d_1_0_Core->f.ColorMask(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glStencilMask(GLuint mask)
-{
-    d_1_0_Core->f.StencilMask(mask);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glClearDepth(GLdouble depth)
-{
-    d_1_0_Core->f.ClearDepth(depth);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glClearStencil(GLint s)
-{
-    d_1_0_Core->f.ClearStencil(s);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Core->f.ClearColor(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glClear(GLbitfield mask)
-{
-    d_1_0_Core->f.Clear(mask);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glDrawBuffer(GLenum buf)
-{
-    d_1_0_Core->f.DrawBuffer(buf);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels)
-{
-    d_1_0_Core->f.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels)
-{
-    d_1_0_Core->f.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_0_Core->f.TexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glTexParameteri(GLenum target, GLenum pname, GLint param)
-{
-    d_1_0_Core->f.TexParameteri(target, pname, param);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Core->f.TexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
-{
-    d_1_0_Core->f.TexParameterf(target, pname, param);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_0_Core->f.Scissor(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glPolygonMode(GLenum face, GLenum mode)
-{
-    d_1_0_Core->f.PolygonMode(face, mode);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glPointSize(GLfloat size)
-{
-    d_1_0_Core->f.PointSize(size);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glLineWidth(GLfloat width)
-{
-    d_1_0_Core->f.LineWidth(width);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glHint(GLenum target, GLenum mode)
-{
-    d_1_0_Core->f.Hint(target, mode);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glFrontFace(GLenum mode)
-{
-    d_1_0_Core->f.FrontFace(mode);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glCullFace(GLenum mode)
-{
-    d_1_0_Core->f.CullFace(mode);
-}
-
-
-// OpenGL 1.1 core functions
-inline GLboolean QOpenGLFunctions_4_4_Core::glIsTexture(GLuint texture)
-{
-    return d_1_1_Core->f.IsTexture(texture);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGenTextures(GLsizei n, GLuint *textures)
-{
-    d_1_1_Core->f.GenTextures(n, textures);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glDeleteTextures(GLsizei n, const GLuint *textures)
-{
-    d_1_1_Core->f.DeleteTextures(n, textures);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glBindTexture(GLenum target, GLuint texture)
-{
-    d_1_1_Core->f.BindTexture(target, texture);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)
-{
-    d_1_1_Core->f.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels)
-{
-    d_1_1_Core->f.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_1_Core->f.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
-{
-    d_1_1_Core->f.CopyTexSubImage1D(target, level, xoffset, x, y, width);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
-{
-    d_1_1_Core->f.CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
-{
-    d_1_1_Core->f.CopyTexImage1D(target, level, internalformat, x, y, width, border);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glPolygonOffset(GLfloat factor, GLfloat units)
-{
-    d_1_1_Core->f.PolygonOffset(factor, units);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glDrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices)
-{
-    d_1_1_Core->f.DrawElements(mode, count, type, indices);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glDrawArrays(GLenum mode, GLint first, GLsizei count)
-{
-    d_1_1_Core->f.DrawArrays(mode, first, count);
-}
-
-
-// OpenGL 1.2 core functions
-inline void QOpenGLFunctions_4_4_Core::glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_2_Core->f.BlendColor(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glBlendEquation(GLenum mode)
-{
-    d_1_2_Core->f.BlendEquation(mode);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_2_Core->f.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels)
-{
-    d_1_2_Core->f.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels)
-{
-    d_1_2_Core->f.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices)
-{
-    d_1_2_Core->f.DrawRangeElements(mode, start, end, count, type, indices);
-}
-
-
-// OpenGL 1.3 core functions
-inline void QOpenGLFunctions_4_4_Core::glGetCompressedTexImage(GLenum target, GLint level, void *img)
-{
-    d_1_3_Core->f.GetCompressedTexImage(target, level, img);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data)
-{
-    d_1_3_Core->f.CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data)
-{
-    d_1_3_Core->f.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data)
-{
-    d_1_3_Core->f.CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glSampleCoverage(GLfloat value, GLboolean invert)
-{
-    d_1_3_Core->f.SampleCoverage(value, invert);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glActiveTexture(GLenum texture)
-{
-    d_1_3_Core->f.ActiveTexture(texture);
-}
-
-
-// OpenGL 1.4 core functions
-inline void QOpenGLFunctions_4_4_Core::glPointParameteriv(GLenum pname, const GLint *params)
-{
-    d_1_4_Core->f.PointParameteriv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glPointParameteri(GLenum pname, GLint param)
-{
-    d_1_4_Core->f.PointParameteri(pname, param);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glPointParameterfv(GLenum pname, const GLfloat *params)
-{
-    d_1_4_Core->f.PointParameterfv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glPointParameterf(GLenum pname, GLfloat param)
-{
-    d_1_4_Core->f.PointParameterf(pname, param);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const void *const *indices, GLsizei drawcount)
-{
-    d_1_4_Core->f.MultiDrawElements(mode, count, type, indices, drawcount);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
-{
-    d_1_4_Core->f.MultiDrawArrays(mode, first, count, drawcount);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
-{
-    d_1_4_Core->f.BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
-}
-
-
-// OpenGL 1.5 core functions
-inline void QOpenGLFunctions_4_4_Core::glGetBufferPointerv(GLenum target, GLenum pname, void * *params)
-{
-    d_1_5_Core->f.GetBufferPointerv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetBufferParameteriv(target, pname, params);
-}
-
-inline GLboolean QOpenGLFunctions_4_4_Core::glUnmapBuffer(GLenum target)
-{
-    return d_1_5_Core->f.UnmapBuffer(target);
-}
-
-inline void * QOpenGLFunctions_4_4_Core::glMapBuffer(GLenum target, GLenum access)
-{
-    return d_1_5_Core->f.MapBuffer(target, access);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, void *data)
-{
-    d_1_5_Core->f.GetBufferSubData(target, offset, size, data);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void *data)
-{
-    d_1_5_Core->f.BufferSubData(target, offset, size, data);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glBufferData(GLenum target, GLsizeiptr size, const void *data, GLenum usage)
-{
-    d_1_5_Core->f.BufferData(target, size, data, usage);
-}
-
-inline GLboolean QOpenGLFunctions_4_4_Core::glIsBuffer(GLuint buffer)
-{
-    return d_1_5_Core->f.IsBuffer(buffer);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGenBuffers(GLsizei n, GLuint *buffers)
-{
-    d_1_5_Core->f.GenBuffers(n, buffers);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glDeleteBuffers(GLsizei n, const GLuint *buffers)
-{
-    d_1_5_Core->f.DeleteBuffers(n, buffers);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glBindBuffer(GLenum target, GLuint buffer)
-{
-    d_1_5_Core->f.BindBuffer(target, buffer);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
-{
-    d_1_5_Core->f.GetQueryObjectuiv(id, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetQueryObjectiv(id, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetQueryiv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetQueryiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glEndQuery(GLenum target)
-{
-    d_1_5_Core->f.EndQuery(target);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glBeginQuery(GLenum target, GLuint id)
-{
-    d_1_5_Core->f.BeginQuery(target, id);
-}
-
-inline GLboolean QOpenGLFunctions_4_4_Core::glIsQuery(GLuint id)
-{
-    return d_1_5_Core->f.IsQuery(id);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glDeleteQueries(GLsizei n, const GLuint *ids)
-{
-    d_1_5_Core->f.DeleteQueries(n, ids);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGenQueries(GLsizei n, GLuint *ids)
-{
-    d_1_5_Core->f.GenQueries(n, ids);
-}
-
-
-// OpenGL 2.0 core functions
-inline void QOpenGLFunctions_4_4_Core::glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer)
-{
-    d_2_0_Core->f.VertexAttribPointer(index, size, type, normalized, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttrib4usv(GLuint index, const GLushort *v)
-{
-    d_2_0_Core->f.VertexAttrib4usv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttrib4uiv(GLuint index, const GLuint *v)
-{
-    d_2_0_Core->f.VertexAttrib4uiv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttrib4ubv(GLuint index, const GLubyte *v)
-{
-    d_2_0_Core->f.VertexAttrib4ubv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttrib4sv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib4sv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
-{
-    d_2_0_Core->f.VertexAttrib4s(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttrib4iv(GLuint index, const GLint *v)
-{
-    d_2_0_Core->f.VertexAttrib4iv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttrib4fv(GLuint index, const GLfloat *v)
-{
-    d_2_0_Core->f.VertexAttrib4fv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    d_2_0_Core->f.VertexAttrib4f(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttrib4dv(GLuint index, const GLdouble *v)
-{
-    d_2_0_Core->f.VertexAttrib4dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_2_0_Core->f.VertexAttrib4d(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttrib4bv(GLuint index, const GLbyte *v)
-{
-    d_2_0_Core->f.VertexAttrib4bv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttrib4Nusv(GLuint index, const GLushort *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nusv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttrib4Nuiv(GLuint index, const GLuint *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nuiv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttrib4Nubv(GLuint index, const GLubyte *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nubv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
-{
-    d_2_0_Core->f.VertexAttrib4Nub(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttrib4Nsv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nsv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttrib4Niv(GLuint index, const GLint *v)
-{
-    d_2_0_Core->f.VertexAttrib4Niv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttrib4Nbv(GLuint index, const GLbyte *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nbv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttrib3sv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib3sv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
-{
-    d_2_0_Core->f.VertexAttrib3s(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttrib3fv(GLuint index, const GLfloat *v)
-{
-    d_2_0_Core->f.VertexAttrib3fv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
-{
-    d_2_0_Core->f.VertexAttrib3f(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttrib3dv(GLuint index, const GLdouble *v)
-{
-    d_2_0_Core->f.VertexAttrib3dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
-{
-    d_2_0_Core->f.VertexAttrib3d(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttrib2sv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib2sv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttrib2s(GLuint index, GLshort x, GLshort y)
-{
-    d_2_0_Core->f.VertexAttrib2s(index, x, y);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttrib2fv(GLuint index, const GLfloat *v)
-{
-    d_2_0_Core->f.VertexAttrib2fv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
-{
-    d_2_0_Core->f.VertexAttrib2f(index, x, y);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttrib2dv(GLuint index, const GLdouble *v)
-{
-    d_2_0_Core->f.VertexAttrib2dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
-{
-    d_2_0_Core->f.VertexAttrib2d(index, x, y);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttrib1sv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib1sv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttrib1s(GLuint index, GLshort x)
-{
-    d_2_0_Core->f.VertexAttrib1s(index, x);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttrib1fv(GLuint index, const GLfloat *v)
-{
-    d_2_0_Core->f.VertexAttrib1fv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttrib1f(GLuint index, GLfloat x)
-{
-    d_2_0_Core->f.VertexAttrib1f(index, x);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttrib1dv(GLuint index, const GLdouble *v)
-{
-    d_2_0_Core->f.VertexAttrib1dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttrib1d(GLuint index, GLdouble x)
-{
-    d_2_0_Core->f.VertexAttrib1d(index, x);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glValidateProgram(GLuint program)
-{
-    d_2_0_Core->f.ValidateProgram(program);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix3fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glUniform4iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform4iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glUniform3iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform3iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glUniform2iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform2iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glUniform1iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform1iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glUniform4fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform4fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glUniform3fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform3fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glUniform2fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform2fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glUniform1fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform1fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
-{
-    d_2_0_Core->f.Uniform4i(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glUniform3i(GLint location, GLint v0, GLint v1, GLint v2)
-{
-    d_2_0_Core->f.Uniform3i(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glUniform2i(GLint location, GLint v0, GLint v1)
-{
-    d_2_0_Core->f.Uniform2i(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glUniform1i(GLint location, GLint v0)
-{
-    d_2_0_Core->f.Uniform1i(location, v0);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
-{
-    d_2_0_Core->f.Uniform4f(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
-{
-    d_2_0_Core->f.Uniform3f(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glUniform2f(GLint location, GLfloat v0, GLfloat v1)
-{
-    d_2_0_Core->f.Uniform2f(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glUniform1f(GLint location, GLfloat v0)
-{
-    d_2_0_Core->f.Uniform1f(location, v0);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glUseProgram(GLuint program)
-{
-    d_2_0_Core->f.UseProgram(program);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glShaderSource(GLuint shader, GLsizei count, const GLchar *const *string, const GLint *length)
-{
-    d_2_0_Core->f.ShaderSource(shader, count, string, length);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glLinkProgram(GLuint program)
-{
-    d_2_0_Core->f.LinkProgram(program);
-}
-
-inline GLboolean QOpenGLFunctions_4_4_Core::glIsShader(GLuint shader)
-{
-    return d_2_0_Core->f.IsShader(shader);
-}
-
-inline GLboolean QOpenGLFunctions_4_4_Core::glIsProgram(GLuint program)
-{
-    return d_2_0_Core->f.IsProgram(program);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetVertexAttribPointerv(GLuint index, GLenum pname, void * *pointer)
-{
-    d_2_0_Core->f.GetVertexAttribPointerv(index, pname, pointer);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetVertexAttribiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
-{
-    d_2_0_Core->f.GetVertexAttribfv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
-{
-    d_2_0_Core->f.GetVertexAttribdv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetUniformiv(GLuint program, GLint location, GLint *params)
-{
-    d_2_0_Core->f.GetUniformiv(program, location, params);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetUniformfv(GLuint program, GLint location, GLfloat *params)
-{
-    d_2_0_Core->f.GetUniformfv(program, location, params);
-}
-
-inline GLint QOpenGLFunctions_4_4_Core::glGetUniformLocation(GLuint program, const GLchar *name)
-{
-    return d_2_0_Core->f.GetUniformLocation(program, name);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
-{
-    d_2_0_Core->f.GetShaderSource(shader, bufSize, length, source);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-{
-    d_2_0_Core->f.GetShaderInfoLog(shader, bufSize, length, infoLog);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetShaderiv(GLuint shader, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetShaderiv(shader, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-{
-    d_2_0_Core->f.GetProgramInfoLog(program, bufSize, length, infoLog);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetProgramiv(GLuint program, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetProgramiv(program, pname, params);
-}
-
-inline GLint QOpenGLFunctions_4_4_Core::glGetAttribLocation(GLuint program, const GLchar *name)
-{
-    return d_2_0_Core->f.GetAttribLocation(program, name);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders)
-{
-    d_2_0_Core->f.GetAttachedShaders(program, maxCount, count, shaders);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
-{
-    d_2_0_Core->f.GetActiveUniform(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
-{
-    d_2_0_Core->f.GetActiveAttrib(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glEnableVertexAttribArray(GLuint index)
-{
-    d_2_0_Core->f.EnableVertexAttribArray(index);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glDisableVertexAttribArray(GLuint index)
-{
-    d_2_0_Core->f.DisableVertexAttribArray(index);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glDetachShader(GLuint program, GLuint shader)
-{
-    d_2_0_Core->f.DetachShader(program, shader);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glDeleteShader(GLuint shader)
-{
-    d_2_0_Core->f.DeleteShader(shader);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glDeleteProgram(GLuint program)
-{
-    d_2_0_Core->f.DeleteProgram(program);
-}
-
-inline GLuint QOpenGLFunctions_4_4_Core::glCreateShader(GLenum type)
-{
-    return d_2_0_Core->f.CreateShader(type);
-}
-
-inline GLuint QOpenGLFunctions_4_4_Core::glCreateProgram()
-{
-    return d_2_0_Core->f.CreateProgram();
-}
-
-inline void QOpenGLFunctions_4_4_Core::glCompileShader(GLuint shader)
-{
-    d_2_0_Core->f.CompileShader(shader);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glBindAttribLocation(GLuint program, GLuint index, const GLchar *name)
-{
-    d_2_0_Core->f.BindAttribLocation(program, index, name);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glAttachShader(GLuint program, GLuint shader)
-{
-    d_2_0_Core->f.AttachShader(program, shader);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glStencilMaskSeparate(GLenum face, GLuint mask)
-{
-    d_2_0_Core->f.StencilMaskSeparate(face, mask);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
-{
-    d_2_0_Core->f.StencilFuncSeparate(face, func, ref, mask);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
-{
-    d_2_0_Core->f.StencilOpSeparate(face, sfail, dpfail, dppass);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glDrawBuffers(GLsizei n, const GLenum *bufs)
-{
-    d_2_0_Core->f.DrawBuffers(n, bufs);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
-{
-    d_2_0_Core->f.BlendEquationSeparate(modeRGB, modeAlpha);
-}
-
-
-// OpenGL 2.1 core functions
-inline void QOpenGLFunctions_4_4_Core::glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix4x3fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix3x4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix4x2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix2x4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix3x2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix2x3fv(location, count, transpose, value);
-}
-
-
-// OpenGL 3.0 core functions
-inline GLboolean QOpenGLFunctions_4_4_Core::glIsVertexArray(GLuint array)
-{
-    return d_3_0_Core->f.IsVertexArray(array);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGenVertexArrays(GLsizei n, GLuint *arrays)
-{
-    d_3_0_Core->f.GenVertexArrays(n, arrays);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glDeleteVertexArrays(GLsizei n, const GLuint *arrays)
-{
-    d_3_0_Core->f.DeleteVertexArrays(n, arrays);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glBindVertexArray(GLuint array)
-{
-    d_3_0_Core->f.BindVertexArray(array);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
-{
-    d_3_0_Core->f.FlushMappedBufferRange(target, offset, length);
-}
-
-inline void * QOpenGLFunctions_4_4_Core::glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
-{
-    return d_3_0_Core->f.MapBufferRange(target, offset, length, access);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
-{
-    d_3_0_Core->f.FramebufferTextureLayer(target, attachment, texture, level, layer);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    d_3_0_Core->f.RenderbufferStorageMultisample(target, samples, internalformat, width, height);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
-{
-    d_3_0_Core->f.BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGenerateMipmap(GLenum target)
-{
-    d_3_0_Core->f.GenerateMipmap(target);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
-{
-    d_3_0_Core->f.FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
-{
-    d_3_0_Core->f.FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
-{
-    d_3_0_Core->f.FramebufferTexture2D(target, attachment, textarget, texture, level);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
-{
-    d_3_0_Core->f.FramebufferTexture1D(target, attachment, textarget, texture, level);
-}
-
-inline GLenum QOpenGLFunctions_4_4_Core::glCheckFramebufferStatus(GLenum target)
-{
-    return d_3_0_Core->f.CheckFramebufferStatus(target);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGenFramebuffers(GLsizei n, GLuint *framebuffers)
-{
-    d_3_0_Core->f.GenFramebuffers(n, framebuffers);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
-{
-    d_3_0_Core->f.DeleteFramebuffers(n, framebuffers);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glBindFramebuffer(GLenum target, GLuint framebuffer)
-{
-    d_3_0_Core->f.BindFramebuffer(target, framebuffer);
-}
-
-inline GLboolean QOpenGLFunctions_4_4_Core::glIsFramebuffer(GLuint framebuffer)
-{
-    return d_3_0_Core->f.IsFramebuffer(framebuffer);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetRenderbufferParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    d_3_0_Core->f.RenderbufferStorage(target, internalformat, width, height);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGenRenderbuffers(GLsizei n, GLuint *renderbuffers)
-{
-    d_3_0_Core->f.GenRenderbuffers(n, renderbuffers);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
-{
-    d_3_0_Core->f.DeleteRenderbuffers(n, renderbuffers);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glBindRenderbuffer(GLenum target, GLuint renderbuffer)
-{
-    d_3_0_Core->f.BindRenderbuffer(target, renderbuffer);
-}
-
-inline GLboolean QOpenGLFunctions_4_4_Core::glIsRenderbuffer(GLuint renderbuffer)
-{
-    return d_3_0_Core->f.IsRenderbuffer(renderbuffer);
-}
-
-inline const GLubyte * QOpenGLFunctions_4_4_Core::glGetStringi(GLenum name, GLuint index)
-{
-    return d_3_0_Core->f.GetStringi(name, index);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
-{
-    d_3_0_Core->f.ClearBufferfi(buffer, drawbuffer, depth, stencil);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
-{
-    d_3_0_Core->f.ClearBufferfv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
-{
-    d_3_0_Core->f.ClearBufferuiv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
-{
-    d_3_0_Core->f.ClearBufferiv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params)
-{
-    d_3_0_Core->f.GetTexParameterIuiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetTexParameterIiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params)
-{
-    d_3_0_Core->f.TexParameterIuiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glTexParameterIiv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_3_0_Core->f.TexParameterIiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glUniform4uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform4uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glUniform3uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform3uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glUniform2uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform2uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glUniform1uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform1uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
-{
-    d_3_0_Core->f.Uniform4ui(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
-{
-    d_3_0_Core->f.Uniform3ui(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glUniform2ui(GLint location, GLuint v0, GLuint v1)
-{
-    d_3_0_Core->f.Uniform2ui(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glUniform1ui(GLint location, GLuint v0)
-{
-    d_3_0_Core->f.Uniform1ui(location, v0);
-}
-
-inline GLint QOpenGLFunctions_4_4_Core::glGetFragDataLocation(GLuint program, const GLchar *name)
-{
-    return d_3_0_Core->f.GetFragDataLocation(program, name);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name)
-{
-    d_3_0_Core->f.BindFragDataLocation(program, color, name);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetUniformuiv(GLuint program, GLint location, GLuint *params)
-{
-    d_3_0_Core->f.GetUniformuiv(program, location, params);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttribI4usv(GLuint index, const GLushort *v)
-{
-    d_3_0_Core->f.VertexAttribI4usv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttribI4ubv(GLuint index, const GLubyte *v)
-{
-    d_3_0_Core->f.VertexAttribI4ubv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttribI4sv(GLuint index, const GLshort *v)
-{
-    d_3_0_Core->f.VertexAttribI4sv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttribI4bv(GLuint index, const GLbyte *v)
-{
-    d_3_0_Core->f.VertexAttribI4bv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttribI4uiv(GLuint index, const GLuint *v)
-{
-    d_3_0_Core->f.VertexAttribI4uiv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttribI3uiv(GLuint index, const GLuint *v)
-{
-    d_3_0_Core->f.VertexAttribI3uiv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttribI2uiv(GLuint index, const GLuint *v)
-{
-    d_3_0_Core->f.VertexAttribI2uiv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttribI1uiv(GLuint index, const GLuint *v)
-{
-    d_3_0_Core->f.VertexAttribI1uiv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttribI4iv(GLuint index, const GLint *v)
-{
-    d_3_0_Core->f.VertexAttribI4iv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttribI3iv(GLuint index, const GLint *v)
-{
-    d_3_0_Core->f.VertexAttribI3iv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttribI2iv(GLuint index, const GLint *v)
-{
-    d_3_0_Core->f.VertexAttribI2iv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttribI1iv(GLuint index, const GLint *v)
-{
-    d_3_0_Core->f.VertexAttribI1iv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
-{
-    d_3_0_Core->f.VertexAttribI4ui(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z)
-{
-    d_3_0_Core->f.VertexAttribI3ui(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttribI2ui(GLuint index, GLuint x, GLuint y)
-{
-    d_3_0_Core->f.VertexAttribI2ui(index, x, y);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttribI1ui(GLuint index, GLuint x)
-{
-    d_3_0_Core->f.VertexAttribI1ui(index, x);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
-{
-    d_3_0_Core->f.VertexAttribI4i(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttribI3i(GLuint index, GLint x, GLint y, GLint z)
-{
-    d_3_0_Core->f.VertexAttribI3i(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttribI2i(GLuint index, GLint x, GLint y)
-{
-    d_3_0_Core->f.VertexAttribI2i(index, x, y);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttribI1i(GLuint index, GLint x)
-{
-    d_3_0_Core->f.VertexAttribI1i(index, x);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
-{
-    d_3_0_Core->f.GetVertexAttribIuiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetVertexAttribIiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer)
-{
-    d_3_0_Core->f.VertexAttribIPointer(index, size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glEndConditionalRender()
-{
-    d_3_0_Core->f.EndConditionalRender();
-}
-
-inline void QOpenGLFunctions_4_4_Core::glBeginConditionalRender(GLuint id, GLenum mode)
-{
-    d_3_0_Core->f.BeginConditionalRender(id, mode);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glClampColor(GLenum target, GLenum clamp)
-{
-    d_3_0_Core->f.ClampColor(target, clamp);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
-{
-    d_3_0_Core->f.GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar *const *varyings, GLenum bufferMode)
-{
-    d_3_0_Core->f.TransformFeedbackVaryings(program, count, varyings, bufferMode);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
-{
-    d_3_0_Core->f.BindBufferBase(target, index, buffer);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
-{
-    d_3_0_Core->f.BindBufferRange(target, index, buffer, offset, size);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glEndTransformFeedback()
-{
-    d_3_0_Core->f.EndTransformFeedback();
-}
-
-inline void QOpenGLFunctions_4_4_Core::glBeginTransformFeedback(GLenum primitiveMode)
-{
-    d_3_0_Core->f.BeginTransformFeedback(primitiveMode);
-}
-
-inline GLboolean QOpenGLFunctions_4_4_Core::glIsEnabledi(GLenum target, GLuint index)
-{
-    return d_3_0_Core->f.IsEnabledi(target, index);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glDisablei(GLenum target, GLuint index)
-{
-    d_3_0_Core->f.Disablei(target, index);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glEnablei(GLenum target, GLuint index)
-{
-    d_3_0_Core->f.Enablei(target, index);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetIntegeri_v(GLenum target, GLuint index, GLint *data)
-{
-    d_3_0_Core->f.GetIntegeri_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetBooleani_v(GLenum target, GLuint index, GLboolean *data)
-{
-    d_3_0_Core->f.GetBooleani_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
-{
-    d_3_0_Core->f.ColorMaski(index, r, g, b, a);
-}
-
-
-// OpenGL 3.1 core functions
-inline void QOpenGLFunctions_4_4_Core::glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
-{
-    d_3_1_Core->f.UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
-{
-    d_3_1_Core->f.GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params)
-{
-    d_3_1_Core->f.GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
-}
-
-inline GLuint QOpenGLFunctions_4_4_Core::glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName)
-{
-    return d_3_1_Core->f.GetUniformBlockIndex(program, uniformBlockName);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName)
-{
-    d_3_1_Core->f.GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params)
-{
-    d_3_1_Core->f.GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar *const *uniformNames, GLuint *uniformIndices)
-{
-    d_3_1_Core->f.GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
-{
-    d_3_1_Core->f.CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glPrimitiveRestartIndex(GLuint index)
-{
-    d_3_1_Core->f.PrimitiveRestartIndex(index);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer)
-{
-    d_3_1_Core->f.TexBuffer(target, internalformat, buffer);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount)
-{
-    d_3_1_Core->f.DrawElementsInstanced(mode, count, type, indices, instancecount);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount)
-{
-    d_3_1_Core->f.DrawArraysInstanced(mode, first, count, instancecount);
-}
-
-
-// OpenGL 3.2 core functions
-inline void QOpenGLFunctions_4_4_Core::glSampleMaski(GLuint maskNumber, GLbitfield mask)
-{
-    d_3_2_Core->f.SampleMaski(maskNumber, mask);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val)
-{
-    d_3_2_Core->f.GetMultisamplefv(pname, index, val);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glTexImage3DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
-{
-    d_3_2_Core->f.TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glTexImage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
-{
-    d_3_2_Core->f.TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level)
-{
-    d_3_2_Core->f.FramebufferTexture(target, attachment, texture, level);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params)
-{
-    d_3_2_Core->f.GetBufferParameteri64v(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data)
-{
-    d_3_2_Core->f.GetInteger64i_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values)
-{
-    d_3_2_Core->f.GetSynciv(sync, pname, bufSize, length, values);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetInteger64v(GLenum pname, GLint64 *data)
-{
-    d_3_2_Core->f.GetInteger64v(pname, data);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
-{
-    d_3_2_Core->f.WaitSync(sync, flags, timeout);
-}
-
-inline GLenum QOpenGLFunctions_4_4_Core::glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
-{
-    return d_3_2_Core->f.ClientWaitSync(sync, flags, timeout);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glDeleteSync(GLsync sync)
-{
-    d_3_2_Core->f.DeleteSync(sync);
-}
-
-inline GLboolean QOpenGLFunctions_4_4_Core::glIsSync(GLsync sync)
-{
-    return d_3_2_Core->f.IsSync(sync);
-}
-
-inline GLsync QOpenGLFunctions_4_4_Core::glFenceSync(GLenum condition, GLbitfield flags)
-{
-    return d_3_2_Core->f.FenceSync(condition, flags);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProvokingVertex(GLenum mode)
-{
-    d_3_2_Core->f.ProvokingVertex(mode);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glMultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count, GLenum type, const void *const *indices, GLsizei drawcount, const GLint *basevertex)
-{
-    d_3_2_Core->f.MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex)
-{
-    d_3_2_Core->f.DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex)
-{
-    d_3_2_Core->f.DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex)
-{
-    d_3_2_Core->f.DrawElementsBaseVertex(mode, count, type, indices, basevertex);
-}
-
-
-// OpenGL 3.3 core functions
-inline void QOpenGLFunctions_4_4_Core::glVertexAttribP4uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP4uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP4ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttribP3uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP3uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP3ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttribP2uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP2uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP2ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttribP1uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP1uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP1ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttribDivisor(GLuint index, GLuint divisor)
-{
-    d_3_3_Core->f.VertexAttribDivisor(index, divisor);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params)
-{
-    d_3_3_Core->f.GetQueryObjectui64v(id, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params)
-{
-    d_3_3_Core->f.GetQueryObjecti64v(id, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glQueryCounter(GLuint id, GLenum target)
-{
-    d_3_3_Core->f.QueryCounter(id, target);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params)
-{
-    d_3_3_Core->f.GetSamplerParameterIuiv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params)
-{
-    d_3_3_Core->f.GetSamplerParameterfv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params)
-{
-    d_3_3_Core->f.GetSamplerParameterIiv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params)
-{
-    d_3_3_Core->f.GetSamplerParameteriv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param)
-{
-    d_3_3_Core->f.SamplerParameterIuiv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param)
-{
-    d_3_3_Core->f.SamplerParameterIiv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param)
-{
-    d_3_3_Core->f.SamplerParameterfv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
-{
-    d_3_3_Core->f.SamplerParameterf(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param)
-{
-    d_3_3_Core->f.SamplerParameteriv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glSamplerParameteri(GLuint sampler, GLenum pname, GLint param)
-{
-    d_3_3_Core->f.SamplerParameteri(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glBindSampler(GLuint unit, GLuint sampler)
-{
-    d_3_3_Core->f.BindSampler(unit, sampler);
-}
-
-inline GLboolean QOpenGLFunctions_4_4_Core::glIsSampler(GLuint sampler)
-{
-    return d_3_3_Core->f.IsSampler(sampler);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glDeleteSamplers(GLsizei count, const GLuint *samplers)
-{
-    d_3_3_Core->f.DeleteSamplers(count, samplers);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGenSamplers(GLsizei count, GLuint *samplers)
-{
-    d_3_3_Core->f.GenSamplers(count, samplers);
-}
-
-inline GLint QOpenGLFunctions_4_4_Core::glGetFragDataIndex(GLuint program, const GLchar *name)
-{
-    return d_3_3_Core->f.GetFragDataIndex(program, name);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glBindFragDataLocationIndexed(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name)
-{
-    d_3_3_Core->f.BindFragDataLocationIndexed(program, colorNumber, index, name);
-}
-
-
-// OpenGL 4.0 core functions
-inline void QOpenGLFunctions_4_4_Core::glGetQueryIndexediv(GLenum target, GLuint index, GLenum pname, GLint *params)
-{
-    d_4_0_Core->f.GetQueryIndexediv(target, index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glEndQueryIndexed(GLenum target, GLuint index)
-{
-    d_4_0_Core->f.EndQueryIndexed(target, index);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glBeginQueryIndexed(GLenum target, GLuint index, GLuint id)
-{
-    d_4_0_Core->f.BeginQueryIndexed(target, index, id);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glDrawTransformFeedbackStream(GLenum mode, GLuint id, GLuint stream)
-{
-    d_4_0_Core->f.DrawTransformFeedbackStream(mode, id, stream);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glDrawTransformFeedback(GLenum mode, GLuint id)
-{
-    d_4_0_Core->f.DrawTransformFeedback(mode, id);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glResumeTransformFeedback()
-{
-    d_4_0_Core->f.ResumeTransformFeedback();
-}
-
-inline void QOpenGLFunctions_4_4_Core::glPauseTransformFeedback()
-{
-    d_4_0_Core->f.PauseTransformFeedback();
-}
-
-inline GLboolean QOpenGLFunctions_4_4_Core::glIsTransformFeedback(GLuint id)
-{
-    return d_4_0_Core->f.IsTransformFeedback(id);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGenTransformFeedbacks(GLsizei n, GLuint *ids)
-{
-    d_4_0_Core->f.GenTransformFeedbacks(n, ids);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids)
-{
-    d_4_0_Core->f.DeleteTransformFeedbacks(n, ids);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glBindTransformFeedback(GLenum target, GLuint id)
-{
-    d_4_0_Core->f.BindTransformFeedback(target, id);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glPatchParameterfv(GLenum pname, const GLfloat *values)
-{
-    d_4_0_Core->f.PatchParameterfv(pname, values);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glPatchParameteri(GLenum pname, GLint value)
-{
-    d_4_0_Core->f.PatchParameteri(pname, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetProgramStageiv(GLuint program, GLenum shadertype, GLenum pname, GLint *values)
-{
-    d_4_0_Core->f.GetProgramStageiv(program, shadertype, pname, values);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetUniformSubroutineuiv(GLenum shadertype, GLint location, GLuint *params)
-{
-    d_4_0_Core->f.GetUniformSubroutineuiv(shadertype, location, params);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glUniformSubroutinesuiv(GLenum shadertype, GLsizei count, const GLuint *indices)
-{
-    d_4_0_Core->f.UniformSubroutinesuiv(shadertype, count, indices);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetActiveSubroutineName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
-{
-    d_4_0_Core->f.GetActiveSubroutineName(program, shadertype, index, bufsize, length, name);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetActiveSubroutineUniformName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
-{
-    d_4_0_Core->f.GetActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetActiveSubroutineUniformiv(GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values)
-{
-    d_4_0_Core->f.GetActiveSubroutineUniformiv(program, shadertype, index, pname, values);
-}
-
-inline GLuint QOpenGLFunctions_4_4_Core::glGetSubroutineIndex(GLuint program, GLenum shadertype, const GLchar *name)
-{
-    return d_4_0_Core->f.GetSubroutineIndex(program, shadertype, name);
-}
-
-inline GLint QOpenGLFunctions_4_4_Core::glGetSubroutineUniformLocation(GLuint program, GLenum shadertype, const GLchar *name)
-{
-    return d_4_0_Core->f.GetSubroutineUniformLocation(program, shadertype, name);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetUniformdv(GLuint program, GLint location, GLdouble *params)
-{
-    d_4_0_Core->f.GetUniformdv(program, location, params);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glUniformMatrix4x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix4x3dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glUniformMatrix4x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix4x2dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glUniformMatrix3x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix3x4dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glUniformMatrix3x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix3x2dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glUniformMatrix2x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix2x4dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glUniformMatrix2x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix2x3dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glUniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix4dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glUniformMatrix3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix3dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glUniformMatrix2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix2dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glUniform4dv(GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_0_Core->f.Uniform4dv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glUniform3dv(GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_0_Core->f.Uniform3dv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glUniform2dv(GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_0_Core->f.Uniform2dv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glUniform1dv(GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_0_Core->f.Uniform1dv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glUniform4d(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_4_0_Core->f.Uniform4d(location, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glUniform3d(GLint location, GLdouble x, GLdouble y, GLdouble z)
-{
-    d_4_0_Core->f.Uniform3d(location, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glUniform2d(GLint location, GLdouble x, GLdouble y)
-{
-    d_4_0_Core->f.Uniform2d(location, x, y);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glUniform1d(GLint location, GLdouble x)
-{
-    d_4_0_Core->f.Uniform1d(location, x);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glDrawElementsIndirect(GLenum mode, GLenum type, const void *indirect)
-{
-    d_4_0_Core->f.DrawElementsIndirect(mode, type, indirect);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glDrawArraysIndirect(GLenum mode, const void *indirect)
-{
-    d_4_0_Core->f.DrawArraysIndirect(mode, indirect);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glBlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
-{
-    d_4_0_Core->f.BlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glBlendFunci(GLuint buf, GLenum src, GLenum dst)
-{
-    d_4_0_Core->f.BlendFunci(buf, src, dst);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glBlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha)
-{
-    d_4_0_Core->f.BlendEquationSeparatei(buf, modeRGB, modeAlpha);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glBlendEquationi(GLuint buf, GLenum mode)
-{
-    d_4_0_Core->f.BlendEquationi(buf, mode);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glMinSampleShading(GLfloat value)
-{
-    d_4_0_Core->f.MinSampleShading(value);
-}
-
-
-// OpenGL 4.1 core functions
-inline void QOpenGLFunctions_4_4_Core::glGetDoublei_v(GLenum target, GLuint index, GLdouble *data)
-{
-    d_4_1_Core->f.GetDoublei_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetFloati_v(GLenum target, GLuint index, GLfloat *data)
-{
-    d_4_1_Core->f.GetFloati_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glDepthRangeIndexed(GLuint index, GLdouble n, GLdouble f)
-{
-    d_4_1_Core->f.DepthRangeIndexed(index, n, f);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glDepthRangeArrayv(GLuint first, GLsizei count, const GLdouble *v)
-{
-    d_4_1_Core->f.DepthRangeArrayv(first, count, v);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glScissorIndexedv(GLuint index, const GLint *v)
-{
-    d_4_1_Core->f.ScissorIndexedv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glScissorIndexed(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height)
-{
-    d_4_1_Core->f.ScissorIndexed(index, left, bottom, width, height);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glScissorArrayv(GLuint first, GLsizei count, const GLint *v)
-{
-    d_4_1_Core->f.ScissorArrayv(first, count, v);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glViewportIndexedfv(GLuint index, const GLfloat *v)
-{
-    d_4_1_Core->f.ViewportIndexedfv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glViewportIndexedf(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h)
-{
-    d_4_1_Core->f.ViewportIndexedf(index, x, y, w, h);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glViewportArrayv(GLuint first, GLsizei count, const GLfloat *v)
-{
-    d_4_1_Core->f.ViewportArrayv(first, count, v);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetVertexAttribLdv(GLuint index, GLenum pname, GLdouble *params)
-{
-    d_4_1_Core->f.GetVertexAttribLdv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttribLPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer)
-{
-    d_4_1_Core->f.VertexAttribLPointer(index, size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttribL4dv(GLuint index, const GLdouble *v)
-{
-    d_4_1_Core->f.VertexAttribL4dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttribL3dv(GLuint index, const GLdouble *v)
-{
-    d_4_1_Core->f.VertexAttribL3dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttribL2dv(GLuint index, const GLdouble *v)
-{
-    d_4_1_Core->f.VertexAttribL2dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttribL1dv(GLuint index, const GLdouble *v)
-{
-    d_4_1_Core->f.VertexAttribL1dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttribL4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_4_1_Core->f.VertexAttribL4d(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttribL3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
-{
-    d_4_1_Core->f.VertexAttribL3d(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttribL2d(GLuint index, GLdouble x, GLdouble y)
-{
-    d_4_1_Core->f.VertexAttribL2d(index, x, y);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttribL1d(GLuint index, GLdouble x)
-{
-    d_4_1_Core->f.VertexAttribL1d(index, x);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-{
-    d_4_1_Core->f.GetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glValidateProgramPipeline(GLuint pipeline)
-{
-    d_4_1_Core->f.ValidateProgramPipeline(pipeline);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProgramUniformMatrix4x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4x3dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProgramUniformMatrix3x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3x4dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProgramUniformMatrix4x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4x2dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProgramUniformMatrix2x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2x4dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProgramUniformMatrix3x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3x2dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProgramUniformMatrix2x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2x3dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProgramUniformMatrix4x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4x3fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProgramUniformMatrix3x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3x4fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProgramUniformMatrix4x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4x2fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProgramUniformMatrix2x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2x4fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProgramUniformMatrix3x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3x2fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProgramUniformMatrix2x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2x3fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProgramUniformMatrix4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProgramUniformMatrix3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProgramUniformMatrix2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProgramUniformMatrix4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProgramUniformMatrix3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProgramUniformMatrix2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProgramUniform4uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
-{
-    d_4_1_Core->f.ProgramUniform4uiv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
-{
-    d_4_1_Core->f.ProgramUniform4ui(program, location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProgramUniform4dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniform4dv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProgramUniform4d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3)
-{
-    d_4_1_Core->f.ProgramUniform4d(program, location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProgramUniform4fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniform4fv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
-{
-    d_4_1_Core->f.ProgramUniform4f(program, location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProgramUniform4iv(GLuint program, GLint location, GLsizei count, const GLint *value)
-{
-    d_4_1_Core->f.ProgramUniform4iv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
-{
-    d_4_1_Core->f.ProgramUniform4i(program, location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProgramUniform3uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
-{
-    d_4_1_Core->f.ProgramUniform3uiv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2)
-{
-    d_4_1_Core->f.ProgramUniform3ui(program, location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProgramUniform3dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniform3dv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProgramUniform3d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2)
-{
-    d_4_1_Core->f.ProgramUniform3d(program, location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProgramUniform3fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniform3fv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
-{
-    d_4_1_Core->f.ProgramUniform3f(program, location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProgramUniform3iv(GLuint program, GLint location, GLsizei count, const GLint *value)
-{
-    d_4_1_Core->f.ProgramUniform3iv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2)
-{
-    d_4_1_Core->f.ProgramUniform3i(program, location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProgramUniform2uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
-{
-    d_4_1_Core->f.ProgramUniform2uiv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1)
-{
-    d_4_1_Core->f.ProgramUniform2ui(program, location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProgramUniform2dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniform2dv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProgramUniform2d(GLuint program, GLint location, GLdouble v0, GLdouble v1)
-{
-    d_4_1_Core->f.ProgramUniform2d(program, location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProgramUniform2fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniform2fv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1)
-{
-    d_4_1_Core->f.ProgramUniform2f(program, location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProgramUniform2iv(GLuint program, GLint location, GLsizei count, const GLint *value)
-{
-    d_4_1_Core->f.ProgramUniform2iv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1)
-{
-    d_4_1_Core->f.ProgramUniform2i(program, location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProgramUniform1uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
-{
-    d_4_1_Core->f.ProgramUniform1uiv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProgramUniform1ui(GLuint program, GLint location, GLuint v0)
-{
-    d_4_1_Core->f.ProgramUniform1ui(program, location, v0);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProgramUniform1dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniform1dv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProgramUniform1d(GLuint program, GLint location, GLdouble v0)
-{
-    d_4_1_Core->f.ProgramUniform1d(program, location, v0);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProgramUniform1fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniform1fv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProgramUniform1f(GLuint program, GLint location, GLfloat v0)
-{
-    d_4_1_Core->f.ProgramUniform1f(program, location, v0);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProgramUniform1iv(GLuint program, GLint location, GLsizei count, const GLint *value)
-{
-    d_4_1_Core->f.ProgramUniform1iv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProgramUniform1i(GLuint program, GLint location, GLint v0)
-{
-    d_4_1_Core->f.ProgramUniform1i(program, location, v0);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params)
-{
-    d_4_1_Core->f.GetProgramPipelineiv(pipeline, pname, params);
-}
-
-inline GLboolean QOpenGLFunctions_4_4_Core::glIsProgramPipeline(GLuint pipeline)
-{
-    return d_4_1_Core->f.IsProgramPipeline(pipeline);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGenProgramPipelines(GLsizei n, GLuint *pipelines)
-{
-    d_4_1_Core->f.GenProgramPipelines(n, pipelines);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glDeleteProgramPipelines(GLsizei n, const GLuint *pipelines)
-{
-    d_4_1_Core->f.DeleteProgramPipelines(n, pipelines);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glBindProgramPipeline(GLuint pipeline)
-{
-    d_4_1_Core->f.BindProgramPipeline(pipeline);
-}
-
-inline GLuint QOpenGLFunctions_4_4_Core::glCreateShaderProgramv(GLenum type, GLsizei count, const GLchar *const *strings)
-{
-    return d_4_1_Core->f.CreateShaderProgramv(type, count, strings);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glActiveShaderProgram(GLuint pipeline, GLuint program)
-{
-    d_4_1_Core->f.ActiveShaderProgram(pipeline, program);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program)
-{
-    d_4_1_Core->f.UseProgramStages(pipeline, stages, program);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProgramParameteri(GLuint program, GLenum pname, GLint value)
-{
-    d_4_1_Core->f.ProgramParameteri(program, pname, value);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glProgramBinary(GLuint program, GLenum binaryFormat, const void *binary, GLsizei length)
-{
-    d_4_1_Core->f.ProgramBinary(program, binaryFormat, binary, length);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, void *binary)
-{
-    d_4_1_Core->f.GetProgramBinary(program, bufSize, length, binaryFormat, binary);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glClearDepthf(GLfloat dd)
-{
-    d_4_1_Core->f.ClearDepthf(dd);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glDepthRangef(GLfloat n, GLfloat f)
-{
-    d_4_1_Core->f.DepthRangef(n, f);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision)
-{
-    d_4_1_Core->f.GetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glShaderBinary(GLsizei count, const GLuint *shaders, GLenum binaryformat, const void *binary, GLsizei length)
-{
-    d_4_1_Core->f.ShaderBinary(count, shaders, binaryformat, binary, length);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glReleaseShaderCompiler()
-{
-    d_4_1_Core->f.ReleaseShaderCompiler();
-}
-
-
-// OpenGL 4.2 core functions
-inline void QOpenGLFunctions_4_4_Core::glDrawTransformFeedbackStreamInstanced(GLenum mode, GLuint id, GLuint stream, GLsizei instancecount)
-{
-    d_4_2_Core->f.DrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glDrawTransformFeedbackInstanced(GLenum mode, GLuint id, GLsizei instancecount)
-{
-    d_4_2_Core->f.DrawTransformFeedbackInstanced(mode, id, instancecount);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
-{
-    d_4_2_Core->f.TexStorage3D(target, levels, internalformat, width, height, depth);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    d_4_2_Core->f.TexStorage2D(target, levels, internalformat, width, height);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glTexStorage1D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width)
-{
-    d_4_2_Core->f.TexStorage1D(target, levels, internalformat, width);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glMemoryBarrier(GLbitfield barriers)
-{
-    d_4_2_Core->f.MemoryBarrier(barriers);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glBindImageTexture(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format)
-{
-    d_4_2_Core->f.BindImageTexture(unit, texture, level, layered, layer, access, format);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetActiveAtomicCounterBufferiv(GLuint program, GLuint bufferIndex, GLenum pname, GLint *params)
-{
-    d_4_2_Core->f.GetActiveAtomicCounterBufferiv(program, bufferIndex, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params)
-{
-    d_4_2_Core->f.GetInternalformativ(target, internalformat, pname, bufSize, params);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glDrawElementsInstancedBaseVertexBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance)
-{
-    d_4_2_Core->f.DrawElementsInstancedBaseVertexBaseInstance(mode, count, type, indices, instancecount, basevertex, baseinstance);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glDrawElementsInstancedBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLuint baseinstance)
-{
-    d_4_2_Core->f.DrawElementsInstancedBaseInstance(mode, count, type, indices, instancecount, baseinstance);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glDrawArraysInstancedBaseInstance(GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance)
-{
-    d_4_2_Core->f.DrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);
-}
-
-
-// OpenGL 4.3 core functions
-inline void QOpenGLFunctions_4_4_Core::glGetObjectPtrLabel(const void *ptr, GLsizei bufSize, GLsizei *length, GLchar *label)
-{
-    d_4_3_Core->f.GetObjectPtrLabel(ptr, bufSize, length, label);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glObjectPtrLabel(const void *ptr, GLsizei length, const GLchar *label)
-{
-    d_4_3_Core->f.ObjectPtrLabel(ptr, length, label);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetObjectLabel(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label)
-{
-    d_4_3_Core->f.GetObjectLabel(identifier, name, bufSize, length, label);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glObjectLabel(GLenum identifier, GLuint name, GLsizei length, const GLchar *label)
-{
-    d_4_3_Core->f.ObjectLabel(identifier, name, length, label);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glPopDebugGroup()
-{
-    d_4_3_Core->f.PopDebugGroup();
-}
-
-inline void QOpenGLFunctions_4_4_Core::glPushDebugGroup(GLenum source, GLuint id, GLsizei length, const GLchar *message)
-{
-    d_4_3_Core->f.PushDebugGroup(source, id, length, message);
-}
-
-inline GLuint QOpenGLFunctions_4_4_Core::glGetDebugMessageLog(GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog)
-{
-    return d_4_3_Core->f.GetDebugMessageLog(count, bufSize, sources, types, ids, severities, lengths, messageLog);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glDebugMessageCallback(GLDEBUGPROC callback, const void *userParam)
-{
-    d_4_3_Core->f.DebugMessageCallback(callback, userParam);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glDebugMessageInsert(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf)
-{
-    d_4_3_Core->f.DebugMessageInsert(source, type, id, severity, length, buf);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glDebugMessageControl(GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled)
-{
-    d_4_3_Core->f.DebugMessageControl(source, type, severity, count, ids, enabled);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexBindingDivisor(GLuint bindingindex, GLuint divisor)
-{
-    d_4_3_Core->f.VertexBindingDivisor(bindingindex, divisor);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttribBinding(GLuint attribindex, GLuint bindingindex)
-{
-    d_4_3_Core->f.VertexAttribBinding(attribindex, bindingindex);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttribLFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
-{
-    d_4_3_Core->f.VertexAttribLFormat(attribindex, size, type, relativeoffset);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttribIFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
-{
-    d_4_3_Core->f.VertexAttribIFormat(attribindex, size, type, relativeoffset);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glVertexAttribFormat(GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset)
-{
-    d_4_3_Core->f.VertexAttribFormat(attribindex, size, type, normalized, relativeoffset);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glBindVertexBuffer(GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride)
-{
-    d_4_3_Core->f.BindVertexBuffer(bindingindex, buffer, offset, stride);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glTextureView(GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers)
-{
-    d_4_3_Core->f.TextureView(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glTexStorage3DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
-{
-    d_4_3_Core->f.TexStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glTexStorage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
-{
-    d_4_3_Core->f.TexStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glTexBufferRange(GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size)
-{
-    d_4_3_Core->f.TexBufferRange(target, internalformat, buffer, offset, size);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glShaderStorageBlockBinding(GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding)
-{
-    d_4_3_Core->f.ShaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding);
-}
-
-inline GLint QOpenGLFunctions_4_4_Core::glGetProgramResourceLocationIndex(GLuint program, GLenum programInterface, const GLchar *name)
-{
-    return d_4_3_Core->f.GetProgramResourceLocationIndex(program, programInterface, name);
-}
-
-inline GLint QOpenGLFunctions_4_4_Core::glGetProgramResourceLocation(GLuint program, GLenum programInterface, const GLchar *name)
-{
-    return d_4_3_Core->f.GetProgramResourceLocation(program, programInterface, name);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetProgramResourceiv(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params)
-{
-    d_4_3_Core->f.GetProgramResourceiv(program, programInterface, index, propCount, props, bufSize, length, params);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetProgramResourceName(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name)
-{
-    d_4_3_Core->f.GetProgramResourceName(program, programInterface, index, bufSize, length, name);
-}
-
-inline GLuint QOpenGLFunctions_4_4_Core::glGetProgramResourceIndex(GLuint program, GLenum programInterface, const GLchar *name)
-{
-    return d_4_3_Core->f.GetProgramResourceIndex(program, programInterface, name);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetProgramInterfaceiv(GLuint program, GLenum programInterface, GLenum pname, GLint *params)
-{
-    d_4_3_Core->f.GetProgramInterfaceiv(program, programInterface, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glMultiDrawElementsIndirect(GLenum mode, GLenum type, const void *indirect, GLsizei drawcount, GLsizei stride)
-{
-    d_4_3_Core->f.MultiDrawElementsIndirect(mode, type, indirect, drawcount, stride);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glMultiDrawArraysIndirect(GLenum mode, const void *indirect, GLsizei drawcount, GLsizei stride)
-{
-    d_4_3_Core->f.MultiDrawArraysIndirect(mode, indirect, drawcount, stride);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glInvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_4_3_Core->f.InvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glInvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments)
-{
-    d_4_3_Core->f.InvalidateFramebuffer(target, numAttachments, attachments);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glInvalidateBufferData(GLuint buffer)
-{
-    d_4_3_Core->f.InvalidateBufferData(buffer);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glInvalidateBufferSubData(GLuint buffer, GLintptr offset, GLsizeiptr length)
-{
-    d_4_3_Core->f.InvalidateBufferSubData(buffer, offset, length);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glInvalidateTexImage(GLuint texture, GLint level)
-{
-    d_4_3_Core->f.InvalidateTexImage(texture, level);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glInvalidateTexSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth)
-{
-    d_4_3_Core->f.InvalidateTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetInternalformati64v(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint64 *params)
-{
-    d_4_3_Core->f.GetInternalformati64v(target, internalformat, pname, bufSize, params);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glGetFramebufferParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_4_3_Core->f.GetFramebufferParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glFramebufferParameteri(GLenum target, GLenum pname, GLint param)
-{
-    d_4_3_Core->f.FramebufferParameteri(target, pname, param);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glCopyImageSubData(GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth)
-{
-    d_4_3_Core->f.CopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glDispatchComputeIndirect(GLintptr indirect)
-{
-    d_4_3_Core->f.DispatchComputeIndirect(indirect);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glDispatchCompute(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z)
-{
-    d_4_3_Core->f.DispatchCompute(num_groups_x, num_groups_y, num_groups_z);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glClearBufferSubData(GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data)
-{
-    d_4_3_Core->f.ClearBufferSubData(target, internalformat, offset, size, format, type, data);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glClearBufferData(GLenum target, GLenum internalformat, GLenum format, GLenum type, const void *data)
-{
-    d_4_3_Core->f.ClearBufferData(target, internalformat, format, type, data);
-}
-
-
-// OpenGL 4.4 core functions
-inline void QOpenGLFunctions_4_4_Core::glBindVertexBuffers(GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides)
-{
-    d_4_4_Core->f.BindVertexBuffers(first, count, buffers, offsets, strides);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glBindImageTextures(GLuint first, GLsizei count, const GLuint *textures)
-{
-    d_4_4_Core->f.BindImageTextures(first, count, textures);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glBindSamplers(GLuint first, GLsizei count, const GLuint *samplers)
-{
-    d_4_4_Core->f.BindSamplers(first, count, samplers);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glBindTextures(GLuint first, GLsizei count, const GLuint *textures)
-{
-    d_4_4_Core->f.BindTextures(first, count, textures);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glBindBuffersRange(GLenum target, GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizeiptr *sizes)
-{
-    d_4_4_Core->f.BindBuffersRange(target, first, count, buffers, offsets, sizes);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glBindBuffersBase(GLenum target, GLuint first, GLsizei count, const GLuint *buffers)
-{
-    d_4_4_Core->f.BindBuffersBase(target, first, count, buffers);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glClearTexSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *data)
-{
-    d_4_4_Core->f.ClearTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glClearTexImage(GLuint texture, GLint level, GLenum format, GLenum type, const void *data)
-{
-    d_4_4_Core->f.ClearTexImage(texture, level, format, type, data);
-}
-
-inline void QOpenGLFunctions_4_4_Core::glBufferStorage(GLenum target, GLsizeiptr size, const void *data, GLbitfield flags)
-{
-    d_4_4_Core->f.BufferStorage(target, size, data, flags);
-}
-
-
-
-QT_END_NAMESPACE
-
-#ifdef Q_OS_WIN
-#pragma pop_macro("MemoryBarrier")
-#endif
-
-#endif // QT_NO_OPENGL && !QT_OPENGL_ES_2
-
-#endif
diff --git a/src/gui/opengl/qopenglfunctions_4_5_compatibility.cpp b/src/gui/opengl/qopenglfunctions_4_5_compatibility.cpp
deleted file mode 100644
index 02af443498..0000000000
--- a/src/gui/opengl/qopenglfunctions_4_5_compatibility.cpp
+++ /dev/null
@@ -1,344 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2015 Klaralvdalens Datakonsult AB (KDAB)
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#include "qopenglfunctions_4_5_compatibility.h"
-#include "qopenglcontext.h"
-
-QT_BEGIN_NAMESPACE
-
-/*!
-    \class QOpenGLFunctions_4_5_Compatibility
-    \inmodule QtGui
-    \since 5.5
-    \wrapper
-    \brief The QOpenGLFunctions_4_5_Compatibility class provides all functions for OpenGL 4.5 compatibility profile.
-
-    This class is a wrapper for functions from OpenGL 4.5 compatibility profile.
-    See reference pages on \l {http://www.opengl.org/sdk/docs/}{opengl.org}
-    for function documentation.
-
-    \sa QAbstractOpenGLFunctions
-*/
-
-QOpenGLFunctions_4_5_Compatibility::QOpenGLFunctions_4_5_Compatibility()
- : QAbstractOpenGLFunctions()
- , d_1_0_Core(nullptr)
- , d_1_1_Core(nullptr)
- , d_1_2_Core(nullptr)
- , d_1_3_Core(nullptr)
- , d_1_4_Core(nullptr)
- , d_1_5_Core(nullptr)
- , d_2_0_Core(nullptr)
- , d_2_1_Core(nullptr)
- , d_3_0_Core(nullptr)
- , d_3_1_Core(nullptr)
- , d_3_2_Core(nullptr)
- , d_3_3_Core(nullptr)
- , d_4_0_Core(nullptr)
- , d_4_1_Core(nullptr)
- , d_4_2_Core(nullptr)
- , d_4_3_Core(nullptr)
- , d_4_4_Core(nullptr)
- , d_4_5_Core(nullptr)
- , d_1_0_Deprecated(nullptr)
- , d_1_1_Deprecated(nullptr)
- , d_1_2_Deprecated(nullptr)
- , d_1_3_Deprecated(nullptr)
- , d_1_4_Deprecated(nullptr)
- , d_3_3_Deprecated(nullptr)
- , d_4_5_Deprecated(nullptr)
-{
-}
-
-QOpenGLFunctions_4_5_Compatibility::~QOpenGLFunctions_4_5_Compatibility()
-{
-    if (d_1_0_Core) {
-        d_1_0_Core->refs.deref();
-        Q_ASSERT(d_1_0_Core->refs.loadRelaxed());
-    }
-    if (d_1_1_Core) {
-        d_1_1_Core->refs.deref();
-        Q_ASSERT(d_1_1_Core->refs.loadRelaxed());
-    }
-    if (d_1_2_Core) {
-        d_1_2_Core->refs.deref();
-        Q_ASSERT(d_1_2_Core->refs.loadRelaxed());
-    }
-    if (d_1_3_Core) {
-        d_1_3_Core->refs.deref();
-        Q_ASSERT(d_1_3_Core->refs.loadRelaxed());
-    }
-    if (d_1_4_Core) {
-        d_1_4_Core->refs.deref();
-        Q_ASSERT(d_1_4_Core->refs.loadRelaxed());
-    }
-    if (d_1_5_Core) {
-        d_1_5_Core->refs.deref();
-        Q_ASSERT(d_1_5_Core->refs.loadRelaxed());
-    }
-    if (d_2_0_Core) {
-        d_2_0_Core->refs.deref();
-        Q_ASSERT(d_2_0_Core->refs.loadRelaxed());
-    }
-    if (d_2_1_Core) {
-        d_2_1_Core->refs.deref();
-        Q_ASSERT(d_2_1_Core->refs.loadRelaxed());
-    }
-    if (d_3_0_Core) {
-        d_3_0_Core->refs.deref();
-        Q_ASSERT(d_3_0_Core->refs.loadRelaxed());
-    }
-    if (d_3_1_Core) {
-        d_3_1_Core->refs.deref();
-        Q_ASSERT(d_3_1_Core->refs.loadRelaxed());
-    }
-    if (d_3_2_Core) {
-        d_3_2_Core->refs.deref();
-        Q_ASSERT(d_3_2_Core->refs.loadRelaxed());
-    }
-    if (d_3_3_Core) {
-        d_3_3_Core->refs.deref();
-        Q_ASSERT(d_3_3_Core->refs.loadRelaxed());
-    }
-    if (d_4_0_Core) {
-        d_4_0_Core->refs.deref();
-        Q_ASSERT(d_4_0_Core->refs.loadRelaxed());
-    }
-    if (d_4_1_Core) {
-        d_4_1_Core->refs.deref();
-        Q_ASSERT(d_4_1_Core->refs.loadRelaxed());
-    }
-    if (d_4_2_Core) {
-        d_4_2_Core->refs.deref();
-        Q_ASSERT(d_4_2_Core->refs.loadRelaxed());
-    }
-    if (d_4_3_Core) {
-        d_4_3_Core->refs.deref();
-        Q_ASSERT(d_4_3_Core->refs.loadRelaxed());
-    }
-    if (d_4_4_Core) {
-        d_4_4_Core->refs.deref();
-        Q_ASSERT(d_4_4_Core->refs.loadRelaxed());
-    }
-    if (d_4_5_Core) {
-        d_4_5_Core->refs.deref();
-        Q_ASSERT(d_4_5_Core->refs.loadRelaxed());
-    }
-    if (d_1_0_Deprecated) {
-        d_1_0_Deprecated->refs.deref();
-        Q_ASSERT(d_1_0_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_1_Deprecated) {
-        d_1_1_Deprecated->refs.deref();
-        Q_ASSERT(d_1_1_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_2_Deprecated) {
-        d_1_2_Deprecated->refs.deref();
-        Q_ASSERT(d_1_2_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_3_Deprecated) {
-        d_1_3_Deprecated->refs.deref();
-        Q_ASSERT(d_1_3_Deprecated->refs.loadRelaxed());
-    }
-    if (d_1_4_Deprecated) {
-        d_1_4_Deprecated->refs.deref();
-        Q_ASSERT(d_1_4_Deprecated->refs.loadRelaxed());
-    }
-    if (d_3_3_Deprecated) {
-        d_3_3_Deprecated->refs.deref();
-        Q_ASSERT(d_3_3_Deprecated->refs.loadRelaxed());
-    }
-    if (d_4_5_Deprecated) {
-        d_4_5_Deprecated->refs.deref();
-        Q_ASSERT(d_4_5_Deprecated->refs.loadRelaxed());
-    }
-}
-
-bool QOpenGLFunctions_4_5_Compatibility::initializeOpenGLFunctions()
-{
-    if ( isInitialized() )
-        return true;
-
-    QOpenGLContext* context = QOpenGLContext::currentContext();
-
-    // If owned by a context object make sure it is current.
-    // Also check that current context is capable of resolving all needed functions
-    if (((owningContext() && owningContext() == context) || !owningContext())
-        && QOpenGLFunctions_4_5_Compatibility::isContextCompatible(context))
-    {
-        // Associate with private implementation, creating if necessary
-        // Function pointers in the backends are resolved at creation time
-        QOpenGLVersionFunctionsBackend* d = nullptr;
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        d_1_3_Core = static_cast<QOpenGLFunctions_1_3_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        d_1_4_Core = static_cast<QOpenGLFunctions_1_4_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        d_1_5_Core = static_cast<QOpenGLFunctions_1_5_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        d_2_0_Core = static_cast<QOpenGLFunctions_2_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        d_2_1_Core = static_cast<QOpenGLFunctions_2_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        d_3_0_Core = static_cast<QOpenGLFunctions_3_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
-        d_3_1_Core = static_cast<QOpenGLFunctions_3_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
-        d_3_2_Core = static_cast<QOpenGLFunctions_3_2_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_CoreBackend::versionStatus());
-        d_3_3_Core = static_cast<QOpenGLFunctions_3_3_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_0_CoreBackend::versionStatus());
-        d_4_0_Core = static_cast<QOpenGLFunctions_4_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_1_CoreBackend::versionStatus());
-        d_4_1_Core = static_cast<QOpenGLFunctions_4_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_2_CoreBackend::versionStatus());
-        d_4_2_Core = static_cast<QOpenGLFunctions_4_2_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_3_CoreBackend::versionStatus());
-        d_4_3_Core = static_cast<QOpenGLFunctions_4_3_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_4_CoreBackend::versionStatus());
-        d_4_4_Core = static_cast<QOpenGLFunctions_4_4_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_5_CoreBackend::versionStatus());
-        d_4_5_Core = static_cast<QOpenGLFunctions_4_5_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
-        d_1_0_Deprecated = static_cast<QOpenGLFunctions_1_0_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
-        d_1_1_Deprecated = static_cast<QOpenGLFunctions_1_1_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus());
-        d_1_2_Deprecated = static_cast<QOpenGLFunctions_1_2_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus());
-        d_1_3_Deprecated = static_cast<QOpenGLFunctions_1_3_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
-        d_1_4_Deprecated = static_cast<QOpenGLFunctions_1_4_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_DeprecatedBackend::versionStatus());
-        d_3_3_Deprecated = static_cast<QOpenGLFunctions_3_3_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_5_DeprecatedBackend::versionStatus());
-        d_4_5_Deprecated = static_cast<QOpenGLFunctions_4_5_DeprecatedBackend*>(d);
-        d->refs.ref();
-
-        QAbstractOpenGLFunctions::initializeOpenGLFunctions();
-    }
-    return isInitialized();
-}
-
-bool QOpenGLFunctions_4_5_Compatibility::isContextCompatible(QOpenGLContext *context)
-{
-    Q_ASSERT(context);
-    QSurfaceFormat f = context->format();
-    const QPair<int, int> v = qMakePair(f.majorVersion(), f.minorVersion());
-    if (v < qMakePair(4, 5))
-        return false;
-
-    if (f.profile() == QSurfaceFormat::CoreProfile)
-        return false;
-
-    return true;
-}
-
-QOpenGLVersionProfile QOpenGLFunctions_4_5_Compatibility::versionProfile()
-{
-    QOpenGLVersionProfile v;
-    v.setVersion(4, 5);
-    v.setProfile(QSurfaceFormat::CompatibilityProfile);
-    return v;
-}
-
-QT_END_NAMESPACE
diff --git a/src/gui/opengl/qopenglfunctions_4_5_compatibility.h b/src/gui/opengl/qopenglfunctions_4_5_compatibility.h
deleted file mode 100644
index 9d9d14548b..0000000000
--- a/src/gui/opengl/qopenglfunctions_4_5_compatibility.h
+++ /dev/null
@@ -1,6694 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2015 Klaralvdalens Datakonsult AB (KDAB)
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#ifndef QOPENGLVERSIONFUNCTIONS_4_5_COMPATIBILITY_H
-#define QOPENGLVERSIONFUNCTIONS_4_5_COMPATIBILITY_H
-
-#include <QtGui/qtguiglobal.h>
-
-#if !defined(QT_NO_OPENGL) && !defined(QT_OPENGL_ES_2)
-
-#include <QtGui/QOpenGLVersionFunctions>
-#include <QtGui/qopenglcontext.h>
-
-// MemoryBarrier is a macro on some architectures on Windows
-#ifdef Q_OS_WIN
-#pragma push_macro("MemoryBarrier")
-#undef MemoryBarrier
-#endif
-
-QT_BEGIN_NAMESPACE
-
-class Q_GUI_EXPORT QOpenGLFunctions_4_5_Compatibility : public QAbstractOpenGLFunctions
-{
-public:
-    QOpenGLFunctions_4_5_Compatibility();
-    ~QOpenGLFunctions_4_5_Compatibility();
-
-    bool initializeOpenGLFunctions() override;
-
-    // OpenGL 1.0 core functions
-    void glViewport(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glDepthRange(GLdouble nearVal, GLdouble farVal);
-    GLboolean glIsEnabled(GLenum cap);
-    void glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params);
-    void glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params);
-    void glGetTexParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, void *pixels);
-    const GLubyte * glGetString(GLenum name);
-    void glGetIntegerv(GLenum pname, GLint *data);
-    void glGetFloatv(GLenum pname, GLfloat *data);
-    GLenum glGetError();
-    void glGetDoublev(GLenum pname, GLdouble *data);
-    void glGetBooleanv(GLenum pname, GLboolean *data);
-    void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels);
-    void glReadBuffer(GLenum src);
-    void glPixelStorei(GLenum pname, GLint param);
-    void glPixelStoref(GLenum pname, GLfloat param);
-    void glDepthFunc(GLenum func);
-    void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass);
-    void glStencilFunc(GLenum func, GLint ref, GLuint mask);
-    void glLogicOp(GLenum opcode);
-    void glBlendFunc(GLenum sfactor, GLenum dfactor);
-    void glFlush();
-    void glFinish();
-    void glEnable(GLenum cap);
-    void glDisable(GLenum cap);
-    void glDepthMask(GLboolean flag);
-    void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
-    void glStencilMask(GLuint mask);
-    void glClearDepth(GLdouble depth);
-    void glClearStencil(GLint s);
-    void glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glClear(GLbitfield mask);
-    void glDrawBuffer(GLenum buf);
-    void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels);
-    void glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels);
-    void glTexParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glTexParameteri(GLenum target, GLenum pname, GLint param);
-    void glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glTexParameterf(GLenum target, GLenum pname, GLfloat param);
-    void glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glPolygonMode(GLenum face, GLenum mode);
-    void glPointSize(GLfloat size);
-    void glLineWidth(GLfloat width);
-    void glHint(GLenum target, GLenum mode);
-    void glFrontFace(GLenum mode);
-    void glCullFace(GLenum mode);
-
-    // OpenGL 1.1 core functions
-    GLboolean glIsTexture(GLuint texture);
-    void glGenTextures(GLsizei n, GLuint *textures);
-    void glDeleteTextures(GLsizei n, const GLuint *textures);
-    void glBindTexture(GLenum target, GLuint texture);
-    void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels);
-    void glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels);
-    void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
-    void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
-    void glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
-    void glPolygonOffset(GLfloat factor, GLfloat units);
-    void glDrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices);
-    void glDrawArrays(GLenum mode, GLint first, GLsizei count);
-
-    // OpenGL 1.2 core functions
-    void glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glBlendEquation(GLenum mode);
-    void glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels);
-    void glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels);
-    void glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices);
-
-    // OpenGL 1.3 core functions
-    void glGetCompressedTexImage(GLenum target, GLint level, void *img);
-    void glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data);
-    void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data);
-    void glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data);
-    void glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data);
-    void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data);
-    void glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data);
-    void glSampleCoverage(GLfloat value, GLboolean invert);
-    void glActiveTexture(GLenum texture);
-
-    // OpenGL 1.4 core functions
-    void glPointParameteriv(GLenum pname, const GLint *params);
-    void glPointParameteri(GLenum pname, GLint param);
-    void glPointParameterfv(GLenum pname, const GLfloat *params);
-    void glPointParameterf(GLenum pname, GLfloat param);
-    void glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const void *const *indices, GLsizei drawcount);
-    void glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount);
-    void glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
-
-    // OpenGL 1.5 core functions
-    void glGetBufferPointerv(GLenum target, GLenum pname, void * *params);
-    void glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params);
-    GLboolean glUnmapBuffer(GLenum target);
-    void * glMapBuffer(GLenum target, GLenum access);
-    void glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, void *data);
-    void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void *data);
-    void glBufferData(GLenum target, GLsizeiptr size, const void *data, GLenum usage);
-    GLboolean glIsBuffer(GLuint buffer);
-    void glGenBuffers(GLsizei n, GLuint *buffers);
-    void glDeleteBuffers(GLsizei n, const GLuint *buffers);
-    void glBindBuffer(GLenum target, GLuint buffer);
-    void glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params);
-    void glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params);
-    void glGetQueryiv(GLenum target, GLenum pname, GLint *params);
-    void glEndQuery(GLenum target);
-    void glBeginQuery(GLenum target, GLuint id);
-    GLboolean glIsQuery(GLuint id);
-    void glDeleteQueries(GLsizei n, const GLuint *ids);
-    void glGenQueries(GLsizei n, GLuint *ids);
-
-    // OpenGL 2.0 core functions
-    void glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer);
-    void glVertexAttrib4usv(GLuint index, const GLushort *v);
-    void glVertexAttrib4uiv(GLuint index, const GLuint *v);
-    void glVertexAttrib4ubv(GLuint index, const GLubyte *v);
-    void glVertexAttrib4sv(GLuint index, const GLshort *v);
-    void glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
-    void glVertexAttrib4iv(GLuint index, const GLint *v);
-    void glVertexAttrib4fv(GLuint index, const GLfloat *v);
-    void glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void glVertexAttrib4dv(GLuint index, const GLdouble *v);
-    void glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glVertexAttrib4bv(GLuint index, const GLbyte *v);
-    void glVertexAttrib4Nusv(GLuint index, const GLushort *v);
-    void glVertexAttrib4Nuiv(GLuint index, const GLuint *v);
-    void glVertexAttrib4Nubv(GLuint index, const GLubyte *v);
-    void glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
-    void glVertexAttrib4Nsv(GLuint index, const GLshort *v);
-    void glVertexAttrib4Niv(GLuint index, const GLint *v);
-    void glVertexAttrib4Nbv(GLuint index, const GLbyte *v);
-    void glVertexAttrib3sv(GLuint index, const GLshort *v);
-    void glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z);
-    void glVertexAttrib3fv(GLuint index, const GLfloat *v);
-    void glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z);
-    void glVertexAttrib3dv(GLuint index, const GLdouble *v);
-    void glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z);
-    void glVertexAttrib2sv(GLuint index, const GLshort *v);
-    void glVertexAttrib2s(GLuint index, GLshort x, GLshort y);
-    void glVertexAttrib2fv(GLuint index, const GLfloat *v);
-    void glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y);
-    void glVertexAttrib2dv(GLuint index, const GLdouble *v);
-    void glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y);
-    void glVertexAttrib1sv(GLuint index, const GLshort *v);
-    void glVertexAttrib1s(GLuint index, GLshort x);
-    void glVertexAttrib1fv(GLuint index, const GLfloat *v);
-    void glVertexAttrib1f(GLuint index, GLfloat x);
-    void glVertexAttrib1dv(GLuint index, const GLdouble *v);
-    void glVertexAttrib1d(GLuint index, GLdouble x);
-    void glValidateProgram(GLuint program);
-    void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniform4iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform3iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform2iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform1iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform4fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform3fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform2fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform1fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
-    void glUniform3i(GLint location, GLint v0, GLint v1, GLint v2);
-    void glUniform2i(GLint location, GLint v0, GLint v1);
-    void glUniform1i(GLint location, GLint v0);
-    void glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
-    void glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
-    void glUniform2f(GLint location, GLfloat v0, GLfloat v1);
-    void glUniform1f(GLint location, GLfloat v0);
-    void glUseProgram(GLuint program);
-    void glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length);
-    void glLinkProgram(GLuint program);
-    GLboolean glIsShader(GLuint shader);
-    GLboolean glIsProgram(GLuint program);
-    void glGetVertexAttribPointerv(GLuint index, GLenum pname, void * *pointer);
-    void glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params);
-    void glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params);
-    void glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params);
-    void glGetUniformiv(GLuint program, GLint location, GLint *params);
-    void glGetUniformfv(GLuint program, GLint location, GLfloat *params);
-    GLint glGetUniformLocation(GLuint program, const GLchar *name);
-    void glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source);
-    void glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void glGetShaderiv(GLuint shader, GLenum pname, GLint *params);
-    void glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void glGetProgramiv(GLuint program, GLenum pname, GLint *params);
-    GLint glGetAttribLocation(GLuint program, const GLchar *name);
-    void glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders);
-    void glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
-    void glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
-    void glEnableVertexAttribArray(GLuint index);
-    void glDisableVertexAttribArray(GLuint index);
-    void glDetachShader(GLuint program, GLuint shader);
-    void glDeleteShader(GLuint shader);
-    void glDeleteProgram(GLuint program);
-    GLuint glCreateShader(GLenum type);
-    GLuint glCreateProgram();
-    void glCompileShader(GLuint shader);
-    void glBindAttribLocation(GLuint program, GLuint index, const GLchar *name);
-    void glAttachShader(GLuint program, GLuint shader);
-    void glStencilMaskSeparate(GLenum face, GLuint mask);
-    void glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask);
-    void glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);
-    void glDrawBuffers(GLsizei n, const GLenum *bufs);
-    void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha);
-
-    // OpenGL 2.1 core functions
-    void glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-
-    // OpenGL 3.0 core functions
-    GLboolean glIsVertexArray(GLuint array);
-    void glGenVertexArrays(GLsizei n, GLuint *arrays);
-    void glDeleteVertexArrays(GLsizei n, const GLuint *arrays);
-    void glBindVertexArray(GLuint array);
-    void glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length);
-    void * glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
-    void glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
-    void glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
-    void glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
-    void glGenerateMipmap(GLenum target);
-    void glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params);
-    void glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
-    void glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset);
-    void glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
-    void glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
-    GLenum glCheckFramebufferStatus(GLenum target);
-    void glGenFramebuffers(GLsizei n, GLuint *framebuffers);
-    void glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers);
-    void glBindFramebuffer(GLenum target, GLuint framebuffer);
-    GLboolean glIsFramebuffer(GLuint framebuffer);
-    void glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
-    void glGenRenderbuffers(GLsizei n, GLuint *renderbuffers);
-    void glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers);
-    void glBindRenderbuffer(GLenum target, GLuint renderbuffer);
-    GLboolean glIsRenderbuffer(GLuint renderbuffer);
-    const GLubyte * glGetStringi(GLenum name, GLuint index);
-    void glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
-    void glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value);
-    void glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value);
-    void glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value);
-    void glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params);
-    void glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params);
-    void glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params);
-    void glTexParameterIiv(GLenum target, GLenum pname, const GLint *params);
-    void glUniform4uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform3uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform2uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform1uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
-    void glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2);
-    void glUniform2ui(GLint location, GLuint v0, GLuint v1);
-    void glUniform1ui(GLint location, GLuint v0);
-    GLint glGetFragDataLocation(GLuint program, const GLchar *name);
-    void glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name);
-    void glGetUniformuiv(GLuint program, GLint location, GLuint *params);
-    void glVertexAttribI4usv(GLuint index, const GLushort *v);
-    void glVertexAttribI4ubv(GLuint index, const GLubyte *v);
-    void glVertexAttribI4sv(GLuint index, const GLshort *v);
-    void glVertexAttribI4bv(GLuint index, const GLbyte *v);
-    void glVertexAttribI4uiv(GLuint index, const GLuint *v);
-    void glVertexAttribI3uiv(GLuint index, const GLuint *v);
-    void glVertexAttribI2uiv(GLuint index, const GLuint *v);
-    void glVertexAttribI1uiv(GLuint index, const GLuint *v);
-    void glVertexAttribI4iv(GLuint index, const GLint *v);
-    void glVertexAttribI3iv(GLuint index, const GLint *v);
-    void glVertexAttribI2iv(GLuint index, const GLint *v);
-    void glVertexAttribI1iv(GLuint index, const GLint *v);
-    void glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
-    void glVertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z);
-    void glVertexAttribI2ui(GLuint index, GLuint x, GLuint y);
-    void glVertexAttribI1ui(GLuint index, GLuint x);
-    void glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w);
-    void glVertexAttribI3i(GLuint index, GLint x, GLint y, GLint z);
-    void glVertexAttribI2i(GLuint index, GLint x, GLint y);
-    void glVertexAttribI1i(GLuint index, GLint x);
-    void glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params);
-    void glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params);
-    void glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer);
-    void glEndConditionalRender();
-    void glBeginConditionalRender(GLuint id, GLenum mode);
-    void glClampColor(GLenum target, GLenum clamp);
-    void glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name);
-    void glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode);
-    void glBindBufferBase(GLenum target, GLuint index, GLuint buffer);
-    void glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
-    void glEndTransformFeedback();
-    void glBeginTransformFeedback(GLenum primitiveMode);
-    GLboolean glIsEnabledi(GLenum target, GLuint index);
-    void glDisablei(GLenum target, GLuint index);
-    void glEnablei(GLenum target, GLuint index);
-    void glGetIntegeri_v(GLenum target, GLuint index, GLint *data);
-    void glGetBooleani_v(GLenum target, GLuint index, GLboolean *data);
-    void glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a);
-
-    // OpenGL 3.1 core functions
-    void glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);
-    void glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName);
-    void glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params);
-    GLuint glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName);
-    void glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName);
-    void glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params);
-    void glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar *const *uniformNames, GLuint *uniformIndices);
-    void glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
-    void glPrimitiveRestartIndex(GLuint index);
-    void glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer);
-    void glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount);
-    void glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount);
-
-    // OpenGL 3.2 core functions
-    void glSampleMaski(GLuint maskNumber, GLbitfield mask);
-    void glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val);
-    void glTexImage3DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
-    void glTexImage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
-    void glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level);
-    void glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params);
-    void glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data);
-    void glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values);
-    void glGetInteger64v(GLenum pname, GLint64 *data);
-    void glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout);
-    GLenum glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout);
-    void glDeleteSync(GLsync sync);
-    GLboolean glIsSync(GLsync sync);
-    GLsync glFenceSync(GLenum condition, GLbitfield flags);
-    void glProvokingVertex(GLenum mode);
-    void glMultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count, GLenum type, const void *const *indices, GLsizei drawcount, const GLint *basevertex);
-    void glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex);
-    void glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex);
-    void glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex);
-
-    // OpenGL 3.3 core functions
-    void glVertexAttribP4uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glVertexAttribP3uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glVertexAttribP2uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glVertexAttribP1uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glVertexAttribDivisor(GLuint index, GLuint divisor);
-    void glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params);
-    void glGetQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params);
-    void glQueryCounter(GLuint id, GLenum target);
-    void glGetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params);
-    void glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params);
-    void glGetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params);
-    void glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params);
-    void glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param);
-    void glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param);
-    void glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param);
-    void glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param);
-    void glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param);
-    void glSamplerParameteri(GLuint sampler, GLenum pname, GLint param);
-    void glBindSampler(GLuint unit, GLuint sampler);
-    GLboolean glIsSampler(GLuint sampler);
-    void glDeleteSamplers(GLsizei count, const GLuint *samplers);
-    void glGenSamplers(GLsizei count, GLuint *samplers);
-    GLint glGetFragDataIndex(GLuint program, const GLchar *name);
-    void glBindFragDataLocationIndexed(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name);
-
-    // OpenGL 4.0 core functions
-    void glGetQueryIndexediv(GLenum target, GLuint index, GLenum pname, GLint *params);
-    void glEndQueryIndexed(GLenum target, GLuint index);
-    void glBeginQueryIndexed(GLenum target, GLuint index, GLuint id);
-    void glDrawTransformFeedbackStream(GLenum mode, GLuint id, GLuint stream);
-    void glDrawTransformFeedback(GLenum mode, GLuint id);
-    void glResumeTransformFeedback();
-    void glPauseTransformFeedback();
-    GLboolean glIsTransformFeedback(GLuint id);
-    void glGenTransformFeedbacks(GLsizei n, GLuint *ids);
-    void glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids);
-    void glBindTransformFeedback(GLenum target, GLuint id);
-    void glPatchParameterfv(GLenum pname, const GLfloat *values);
-    void glPatchParameteri(GLenum pname, GLint value);
-    void glGetProgramStageiv(GLuint program, GLenum shadertype, GLenum pname, GLint *values);
-    void glGetUniformSubroutineuiv(GLenum shadertype, GLint location, GLuint *params);
-    void glUniformSubroutinesuiv(GLenum shadertype, GLsizei count, const GLuint *indices);
-    void glGetActiveSubroutineName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name);
-    void glGetActiveSubroutineUniformName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name);
-    void glGetActiveSubroutineUniformiv(GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values);
-    GLuint glGetSubroutineIndex(GLuint program, GLenum shadertype, const GLchar *name);
-    GLint glGetSubroutineUniformLocation(GLuint program, GLenum shadertype, const GLchar *name);
-    void glGetUniformdv(GLuint program, GLint location, GLdouble *params);
-    void glUniformMatrix4x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix4x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix3x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix3x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix2x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix2x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniform4dv(GLint location, GLsizei count, const GLdouble *value);
-    void glUniform3dv(GLint location, GLsizei count, const GLdouble *value);
-    void glUniform2dv(GLint location, GLsizei count, const GLdouble *value);
-    void glUniform1dv(GLint location, GLsizei count, const GLdouble *value);
-    void glUniform4d(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glUniform3d(GLint location, GLdouble x, GLdouble y, GLdouble z);
-    void glUniform2d(GLint location, GLdouble x, GLdouble y);
-    void glUniform1d(GLint location, GLdouble x);
-    void glDrawElementsIndirect(GLenum mode, GLenum type, const void *indirect);
-    void glDrawArraysIndirect(GLenum mode, const void *indirect);
-    void glBlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
-    void glBlendFunci(GLuint buf, GLenum src, GLenum dst);
-    void glBlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha);
-    void glBlendEquationi(GLuint buf, GLenum mode);
-    void glMinSampleShading(GLfloat value);
-
-    // OpenGL 4.1 core functions
-    void glGetDoublei_v(GLenum target, GLuint index, GLdouble *data);
-    void glGetFloati_v(GLenum target, GLuint index, GLfloat *data);
-    void glDepthRangeIndexed(GLuint index, GLdouble n, GLdouble f);
-    void glDepthRangeArrayv(GLuint first, GLsizei count, const GLdouble *v);
-    void glScissorIndexedv(GLuint index, const GLint *v);
-    void glScissorIndexed(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height);
-    void glScissorArrayv(GLuint first, GLsizei count, const GLint *v);
-    void glViewportIndexedfv(GLuint index, const GLfloat *v);
-    void glViewportIndexedf(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h);
-    void glViewportArrayv(GLuint first, GLsizei count, const GLfloat *v);
-    void glGetVertexAttribLdv(GLuint index, GLenum pname, GLdouble *params);
-    void glVertexAttribLPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer);
-    void glVertexAttribL4dv(GLuint index, const GLdouble *v);
-    void glVertexAttribL3dv(GLuint index, const GLdouble *v);
-    void glVertexAttribL2dv(GLuint index, const GLdouble *v);
-    void glVertexAttribL1dv(GLuint index, const GLdouble *v);
-    void glVertexAttribL4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glVertexAttribL3d(GLuint index, GLdouble x, GLdouble y, GLdouble z);
-    void glVertexAttribL2d(GLuint index, GLdouble x, GLdouble y);
-    void glVertexAttribL1d(GLuint index, GLdouble x);
-    void glGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void glValidateProgramPipeline(GLuint pipeline);
-    void glProgramUniformMatrix4x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix3x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix4x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix2x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix3x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix2x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix4x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix3x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix4x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix2x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix3x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix2x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniform4uiv(GLuint program, GLint location, GLsizei count, const GLuint *value);
-    void glProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
-    void glProgramUniform4dv(GLuint program, GLint location, GLsizei count, const GLdouble *value);
-    void glProgramUniform4d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3);
-    void glProgramUniform4fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-    void glProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
-    void glProgramUniform4iv(GLuint program, GLint location, GLsizei count, const GLint *value);
-    void glProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
-    void glProgramUniform3uiv(GLuint program, GLint location, GLsizei count, const GLuint *value);
-    void glProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2);
-    void glProgramUniform3dv(GLuint program, GLint location, GLsizei count, const GLdouble *value);
-    void glProgramUniform3d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2);
-    void glProgramUniform3fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-    void glProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
-    void glProgramUniform3iv(GLuint program, GLint location, GLsizei count, const GLint *value);
-    void glProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2);
-    void glProgramUniform2uiv(GLuint program, GLint location, GLsizei count, const GLuint *value);
-    void glProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1);
-    void glProgramUniform2dv(GLuint program, GLint location, GLsizei count, const GLdouble *value);
-    void glProgramUniform2d(GLuint program, GLint location, GLdouble v0, GLdouble v1);
-    void glProgramUniform2fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-    void glProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1);
-    void glProgramUniform2iv(GLuint program, GLint location, GLsizei count, const GLint *value);
-    void glProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1);
-    void glProgramUniform1uiv(GLuint program, GLint location, GLsizei count, const GLuint *value);
-    void glProgramUniform1ui(GLuint program, GLint location, GLuint v0);
-    void glProgramUniform1dv(GLuint program, GLint location, GLsizei count, const GLdouble *value);
-    void glProgramUniform1d(GLuint program, GLint location, GLdouble v0);
-    void glProgramUniform1fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-    void glProgramUniform1f(GLuint program, GLint location, GLfloat v0);
-    void glProgramUniform1iv(GLuint program, GLint location, GLsizei count, const GLint *value);
-    void glProgramUniform1i(GLuint program, GLint location, GLint v0);
-    void glGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params);
-    GLboolean glIsProgramPipeline(GLuint pipeline);
-    void glGenProgramPipelines(GLsizei n, GLuint *pipelines);
-    void glDeleteProgramPipelines(GLsizei n, const GLuint *pipelines);
-    void glBindProgramPipeline(GLuint pipeline);
-    GLuint glCreateShaderProgramv(GLenum type, GLsizei count, const GLchar* const *strings);
-    void glActiveShaderProgram(GLuint pipeline, GLuint program);
-    void glUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program);
-    void glProgramParameteri(GLuint program, GLenum pname, GLint value);
-    void glProgramBinary(GLuint program, GLenum binaryFormat, const void *binary, GLsizei length);
-    void glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, void *binary);
-    void glClearDepthf(GLfloat dd);
-    void glDepthRangef(GLfloat n, GLfloat f);
-    void glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision);
-    void glShaderBinary(GLsizei count, const GLuint *shaders, GLenum binaryformat, const void *binary, GLsizei length);
-    void glReleaseShaderCompiler();
-
-    // OpenGL 4.2 core functions
-    void glDrawTransformFeedbackStreamInstanced(GLenum mode, GLuint id, GLuint stream, GLsizei instancecount);
-    void glDrawTransformFeedbackInstanced(GLenum mode, GLuint id, GLsizei instancecount);
-    void glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
-    void glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);
-    void glTexStorage1D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width);
-    void glMemoryBarrier(GLbitfield barriers);
-    void glBindImageTexture(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format);
-    void glGetActiveAtomicCounterBufferiv(GLuint program, GLuint bufferIndex, GLenum pname, GLint *params);
-    void glGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params);
-    void glDrawElementsInstancedBaseVertexBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance);
-    void glDrawElementsInstancedBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLuint baseinstance);
-    void glDrawArraysInstancedBaseInstance(GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance);
-
-    // OpenGL 4.3 core functions
-    void glGetObjectPtrLabel(const void *ptr, GLsizei bufSize, GLsizei *length, GLchar *label);
-    void glObjectPtrLabel(const void *ptr, GLsizei length, const GLchar *label);
-    void glGetObjectLabel(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label);
-    void glObjectLabel(GLenum identifier, GLuint name, GLsizei length, const GLchar *label);
-    void glPopDebugGroup();
-    void glPushDebugGroup(GLenum source, GLuint id, GLsizei length, const GLchar *message);
-    GLuint glGetDebugMessageLog(GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog);
-    void glDebugMessageCallback(GLDEBUGPROC callback, const void *userParam);
-    void glDebugMessageInsert(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf);
-    void glDebugMessageControl(GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled);
-    void glVertexBindingDivisor(GLuint bindingindex, GLuint divisor);
-    void glVertexAttribBinding(GLuint attribindex, GLuint bindingindex);
-    void glVertexAttribLFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);
-    void glVertexAttribIFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);
-    void glVertexAttribFormat(GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset);
-    void glBindVertexBuffer(GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride);
-    void glTextureView(GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers);
-    void glTexStorage3DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
-    void glTexStorage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
-    void glTexBufferRange(GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size);
-    void glShaderStorageBlockBinding(GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding);
-    GLint glGetProgramResourceLocationIndex(GLuint program, GLenum programInterface, const GLchar *name);
-    GLint glGetProgramResourceLocation(GLuint program, GLenum programInterface, const GLchar *name);
-    void glGetProgramResourceiv(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params);
-    void glGetProgramResourceName(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name);
-    GLuint glGetProgramResourceIndex(GLuint program, GLenum programInterface, const GLchar *name);
-    void glGetProgramInterfaceiv(GLuint program, GLenum programInterface, GLenum pname, GLint *params);
-    void glMultiDrawElementsIndirect(GLenum mode, GLenum type, const void *indirect, GLsizei drawcount, GLsizei stride);
-    void glMultiDrawArraysIndirect(GLenum mode, const void *indirect, GLsizei drawcount, GLsizei stride);
-    void glInvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glInvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments);
-    void glInvalidateBufferData(GLuint buffer);
-    void glInvalidateBufferSubData(GLuint buffer, GLintptr offset, GLsizeiptr length);
-    void glInvalidateTexImage(GLuint texture, GLint level);
-    void glInvalidateTexSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth);
-    void glGetInternalformati64v(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint64 *params);
-    void glGetFramebufferParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glFramebufferParameteri(GLenum target, GLenum pname, GLint param);
-    void glCopyImageSubData(GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth);
-    void glDispatchComputeIndirect(GLintptr indirect);
-    void glDispatchCompute(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z);
-    void glClearBufferSubData(GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data);
-    void glClearBufferData(GLenum target, GLenum internalformat, GLenum format, GLenum type, const void *data);
-
-    // OpenGL 4.4 core functions
-    void glBindVertexBuffers(GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides);
-    void glBindImageTextures(GLuint first, GLsizei count, const GLuint *textures);
-    void glBindSamplers(GLuint first, GLsizei count, const GLuint *samplers);
-    void glBindTextures(GLuint first, GLsizei count, const GLuint *textures);
-    void glBindBuffersRange(GLenum target, GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizeiptr *sizes);
-    void glBindBuffersBase(GLenum target, GLuint first, GLsizei count, const GLuint *buffers);
-    void glClearTexSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *data);
-    void glClearTexImage(GLuint texture, GLint level, GLenum format, GLenum type, const void *data);
-    void glBufferStorage(GLenum target, GLsizeiptr size, const void *data, GLbitfield flags);
-
-    // OpenGL 4.5 core functions
-    void glTextureBarrier();
-    void glReadnPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data);
-    void glGetnUniformuiv(GLuint program, GLint location, GLsizei bufSize, GLuint *params);
-    void glGetnUniformiv(GLuint program, GLint location, GLsizei bufSize, GLint *params);
-    void glGetnUniformfv(GLuint program, GLint location, GLsizei bufSize, GLfloat *params);
-    void glGetnUniformdv(GLuint program, GLint location, GLsizei bufSize, GLdouble *params);
-    void glGetnTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, void *pixels);
-    void glGetnCompressedTexImage(GLenum target, GLint lod, GLsizei bufSize, void *pixels);
-    GLenum glGetGraphicsResetStatus();
-    void glGetCompressedTextureSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei bufSize, void *pixels);
-    void glGetTextureSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLsizei bufSize, void *pixels);
-    void glMemoryBarrierByRegion(GLbitfield barriers);
-    void glCreateQueries(GLenum target, GLsizei n, GLuint *ids);
-    void glCreateProgramPipelines(GLsizei n, GLuint *pipelines);
-    void glCreateSamplers(GLsizei n, GLuint *samplers);
-    void glGetVertexArrayIndexed64iv(GLuint vaobj, GLuint index, GLenum pname, GLint64 *param);
-    void glGetVertexArrayIndexediv(GLuint vaobj, GLuint index, GLenum pname, GLint *param);
-    void glGetVertexArrayiv(GLuint vaobj, GLenum pname, GLint *param);
-    void glVertexArrayBindingDivisor(GLuint vaobj, GLuint bindingindex, GLuint divisor);
-    void glVertexArrayAttribLFormat(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);
-    void glVertexArrayAttribIFormat(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);
-    void glVertexArrayAttribFormat(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset);
-    void glVertexArrayAttribBinding(GLuint vaobj, GLuint attribindex, GLuint bindingindex);
-    void glVertexArrayVertexBuffers(GLuint vaobj, GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides);
-    void glVertexArrayVertexBuffer(GLuint vaobj, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride);
-    void glVertexArrayElementBuffer(GLuint vaobj, GLuint buffer);
-    void glEnableVertexArrayAttrib(GLuint vaobj, GLuint index);
-    void glDisableVertexArrayAttrib(GLuint vaobj, GLuint index);
-    void glCreateVertexArrays(GLsizei n, GLuint *arrays);
-    void glGetTextureParameteriv(GLuint texture, GLenum pname, GLint *params);
-    void glGetTextureParameterIuiv(GLuint texture, GLenum pname, GLuint *params);
-    void glGetTextureParameterIiv(GLuint texture, GLenum pname, GLint *params);
-    void glGetTextureParameterfv(GLuint texture, GLenum pname, GLfloat *params);
-    void glGetTextureLevelParameteriv(GLuint texture, GLint level, GLenum pname, GLint *params);
-    void glGetTextureLevelParameterfv(GLuint texture, GLint level, GLenum pname, GLfloat *params);
-    void glGetCompressedTextureImage(GLuint texture, GLint level, GLsizei bufSize, void *pixels);
-    void glGetTextureImage(GLuint texture, GLint level, GLenum format, GLenum type, GLsizei bufSize, void *pixels);
-    void glBindTextureUnit(GLuint unit, GLuint texture);
-    void glGenerateTextureMipmap(GLuint texture);
-    void glTextureParameteriv(GLuint texture, GLenum pname, const GLint *param);
-    void glTextureParameterIuiv(GLuint texture, GLenum pname, const GLuint *params);
-    void glTextureParameterIiv(GLuint texture, GLenum pname, const GLint *params);
-    void glTextureParameteri(GLuint texture, GLenum pname, GLint param);
-    void glTextureParameterfv(GLuint texture, GLenum pname, const GLfloat *param);
-    void glTextureParameterf(GLuint texture, GLenum pname, GLfloat param);
-    void glCopyTextureSubImage3D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glCopyTextureSubImage2D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glCopyTextureSubImage1D(GLuint texture, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
-    void glCompressedTextureSubImage3D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data);
-    void glCompressedTextureSubImage2D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data);
-    void glCompressedTextureSubImage1D(GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data);
-    void glTextureSubImage3D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels);
-    void glTextureSubImage2D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels);
-    void glTextureSubImage1D(GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels);
-    void glTextureStorage3DMultisample(GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
-    void glTextureStorage2DMultisample(GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
-    void glTextureStorage3D(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
-    void glTextureStorage2D(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);
-    void glTextureStorage1D(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width);
-    void glTextureBufferRange(GLuint texture, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizei size);
-    void glTextureBuffer(GLuint texture, GLenum internalformat, GLuint buffer);
-    void glCreateTextures(GLenum target, GLsizei n, GLuint *textures);
-    void glGetNamedRenderbufferParameteriv(GLuint renderbuffer, GLenum pname, GLint *params);
-    void glNamedRenderbufferStorageMultisample(GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
-    void glNamedRenderbufferStorage(GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height);
-    void glCreateRenderbuffers(GLsizei n, GLuint *renderbuffers);
-    void glGetNamedFramebufferAttachmentParameteriv(GLuint framebuffer, GLenum attachment, GLenum pname, GLint *params);
-    void glGetNamedFramebufferParameteriv(GLuint framebuffer, GLenum pname, GLint *param);
-    GLenum glCheckNamedFramebufferStatus(GLuint framebuffer, GLenum target);
-    void glBlitNamedFramebuffer(GLuint readFramebuffer, GLuint drawFramebuffer, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
-    void glClearNamedFramebufferfi(GLuint framebuffer, GLenum buffer, GLfloat depth, GLint stencil);
-    void glClearNamedFramebufferfv(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLfloat *value);
-    void glClearNamedFramebufferuiv(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLuint *value);
-    void glClearNamedFramebufferiv(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLint *value);
-    void glInvalidateNamedFramebufferSubData(GLuint framebuffer, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glInvalidateNamedFramebufferData(GLuint framebuffer, GLsizei numAttachments, const GLenum *attachments);
-    void glNamedFramebufferReadBuffer(GLuint framebuffer, GLenum src);
-    void glNamedFramebufferDrawBuffers(GLuint framebuffer, GLsizei n, const GLenum *bufs);
-    void glNamedFramebufferDrawBuffer(GLuint framebuffer, GLenum buf);
-    void glNamedFramebufferTextureLayer(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer);
-    void glNamedFramebufferTexture(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level);
-    void glNamedFramebufferParameteri(GLuint framebuffer, GLenum pname, GLint param);
-    void glNamedFramebufferRenderbuffer(GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
-    void glCreateFramebuffers(GLsizei n, GLuint *framebuffers);
-    void glGetNamedBufferSubData(GLuint buffer, GLintptr offset, GLsizei size, void *data);
-    void glGetNamedBufferPointerv(GLuint buffer, GLenum pname, void * *params);
-    void glGetNamedBufferParameteri64v(GLuint buffer, GLenum pname, GLint64 *params);
-    void glGetNamedBufferParameteriv(GLuint buffer, GLenum pname, GLint *params);
-    void glFlushMappedNamedBufferRange(GLuint buffer, GLintptr offset, GLsizei length);
-    GLboolean glUnmapNamedBuffer(GLuint buffer);
-    void * glMapNamedBufferRange(GLuint buffer, GLintptr offset, GLsizei length, GLbitfield access);
-    void * glMapNamedBuffer(GLuint buffer, GLenum access);
-    void glClearNamedBufferSubData(GLuint buffer, GLenum internalformat, GLintptr offset, GLsizei size, GLenum format, GLenum type, const void *data);
-    void glClearNamedBufferData(GLuint buffer, GLenum internalformat, GLenum format, GLenum type, const void *data);
-    void glCopyNamedBufferSubData(GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizei size);
-    void glNamedBufferSubData(GLuint buffer, GLintptr offset, GLsizei size, const void *data);
-    void glNamedBufferData(GLuint buffer, GLsizei size, const void *data, GLenum usage);
-    void glNamedBufferStorage(GLuint buffer, GLsizei size, const void *data, GLbitfield flags);
-    void glCreateBuffers(GLsizei n, GLuint *buffers);
-    void glGetTransformFeedbacki64_v(GLuint xfb, GLenum pname, GLuint index, GLint64 *param);
-    void glGetTransformFeedbacki_v(GLuint xfb, GLenum pname, GLuint index, GLint *param);
-    void glGetTransformFeedbackiv(GLuint xfb, GLenum pname, GLint *param);
-    void glTransformFeedbackBufferRange(GLuint xfb, GLuint index, GLuint buffer, GLintptr offset, GLsizei size);
-    void glTransformFeedbackBufferBase(GLuint xfb, GLuint index, GLuint buffer);
-    void glCreateTransformFeedbacks(GLsizei n, GLuint *ids);
-    void glClipControl(GLenum origin, GLenum depth);
-
-    // OpenGL 1.0 deprecated functions
-    void glTranslatef(GLfloat x, GLfloat y, GLfloat z);
-    void glTranslated(GLdouble x, GLdouble y, GLdouble z);
-    void glScalef(GLfloat x, GLfloat y, GLfloat z);
-    void glScaled(GLdouble x, GLdouble y, GLdouble z);
-    void glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
-    void glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
-    void glPushMatrix();
-    void glPopMatrix();
-    void glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
-    void glMultMatrixd(const GLdouble *m);
-    void glMultMatrixf(const GLfloat *m);
-    void glMatrixMode(GLenum mode);
-    void glLoadMatrixd(const GLdouble *m);
-    void glLoadMatrixf(const GLfloat *m);
-    void glLoadIdentity();
-    void glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
-    GLboolean glIsList(GLuint list);
-    void glGetTexGeniv(GLenum coord, GLenum pname, GLint *params);
-    void glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params);
-    void glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params);
-    void glGetTexEnviv(GLenum target, GLenum pname, GLint *params);
-    void glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetPolygonStipple(GLubyte *mask);
-    void glGetPixelMapusv(GLenum map, GLushort *values);
-    void glGetPixelMapuiv(GLenum map, GLuint *values);
-    void glGetPixelMapfv(GLenum map, GLfloat *values);
-    void glGetMaterialiv(GLenum face, GLenum pname, GLint *params);
-    void glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params);
-    void glGetMapiv(GLenum target, GLenum query, GLint *v);
-    void glGetMapfv(GLenum target, GLenum query, GLfloat *v);
-    void glGetMapdv(GLenum target, GLenum query, GLdouble *v);
-    void glGetLightiv(GLenum light, GLenum pname, GLint *params);
-    void glGetLightfv(GLenum light, GLenum pname, GLfloat *params);
-    void glGetClipPlane(GLenum plane, GLdouble *equation);
-    void glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels);
-    void glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
-    void glPixelMapusv(GLenum map, GLsizei mapsize, const GLushort *values);
-    void glPixelMapuiv(GLenum map, GLsizei mapsize, const GLuint *values);
-    void glPixelMapfv(GLenum map, GLsizei mapsize, const GLfloat *values);
-    void glPixelTransferi(GLenum pname, GLint param);
-    void glPixelTransferf(GLenum pname, GLfloat param);
-    void glPixelZoom(GLfloat xfactor, GLfloat yfactor);
-    void glAlphaFunc(GLenum func, GLfloat ref);
-    void glEvalPoint2(GLint i, GLint j);
-    void glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
-    void glEvalPoint1(GLint i);
-    void glEvalMesh1(GLenum mode, GLint i1, GLint i2);
-    void glEvalCoord2fv(const GLfloat *u);
-    void glEvalCoord2f(GLfloat u, GLfloat v);
-    void glEvalCoord2dv(const GLdouble *u);
-    void glEvalCoord2d(GLdouble u, GLdouble v);
-    void glEvalCoord1fv(const GLfloat *u);
-    void glEvalCoord1f(GLfloat u);
-    void glEvalCoord1dv(const GLdouble *u);
-    void glEvalCoord1d(GLdouble u);
-    void glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
-    void glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
-    void glMapGrid1f(GLint un, GLfloat u1, GLfloat u2);
-    void glMapGrid1d(GLint un, GLdouble u1, GLdouble u2);
-    void glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);
-    void glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);
-    void glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);
-    void glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);
-    void glPushAttrib(GLbitfield mask);
-    void glPopAttrib();
-    void glAccum(GLenum op, GLfloat value);
-    void glIndexMask(GLuint mask);
-    void glClearIndex(GLfloat c);
-    void glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glPushName(GLuint name);
-    void glPopName();
-    void glPassThrough(GLfloat token);
-    void glLoadName(GLuint name);
-    void glInitNames();
-    GLint glRenderMode(GLenum mode);
-    void glSelectBuffer(GLsizei size, GLuint *buffer);
-    void glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer);
-    void glTexGeniv(GLenum coord, GLenum pname, const GLint *params);
-    void glTexGeni(GLenum coord, GLenum pname, GLint param);
-    void glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params);
-    void glTexGenf(GLenum coord, GLenum pname, GLfloat param);
-    void glTexGendv(GLenum coord, GLenum pname, const GLdouble *params);
-    void glTexGend(GLenum coord, GLenum pname, GLdouble param);
-    void glTexEnviv(GLenum target, GLenum pname, const GLint *params);
-    void glTexEnvi(GLenum target, GLenum pname, GLint param);
-    void glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glTexEnvf(GLenum target, GLenum pname, GLfloat param);
-    void glShadeModel(GLenum mode);
-    void glPolygonStipple(const GLubyte *mask);
-    void glMaterialiv(GLenum face, GLenum pname, const GLint *params);
-    void glMateriali(GLenum face, GLenum pname, GLint param);
-    void glMaterialfv(GLenum face, GLenum pname, const GLfloat *params);
-    void glMaterialf(GLenum face, GLenum pname, GLfloat param);
-    void glLineStipple(GLint factor, GLushort pattern);
-    void glLightModeliv(GLenum pname, const GLint *params);
-    void glLightModeli(GLenum pname, GLint param);
-    void glLightModelfv(GLenum pname, const GLfloat *params);
-    void glLightModelf(GLenum pname, GLfloat param);
-    void glLightiv(GLenum light, GLenum pname, const GLint *params);
-    void glLighti(GLenum light, GLenum pname, GLint param);
-    void glLightfv(GLenum light, GLenum pname, const GLfloat *params);
-    void glLightf(GLenum light, GLenum pname, GLfloat param);
-    void glFogiv(GLenum pname, const GLint *params);
-    void glFogi(GLenum pname, GLint param);
-    void glFogfv(GLenum pname, const GLfloat *params);
-    void glFogf(GLenum pname, GLfloat param);
-    void glColorMaterial(GLenum face, GLenum mode);
-    void glClipPlane(GLenum plane, const GLdouble *equation);
-    void glVertex4sv(const GLshort *v);
-    void glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w);
-    void glVertex4iv(const GLint *v);
-    void glVertex4i(GLint x, GLint y, GLint z, GLint w);
-    void glVertex4fv(const GLfloat *v);
-    void glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void glVertex4dv(const GLdouble *v);
-    void glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glVertex3sv(const GLshort *v);
-    void glVertex3s(GLshort x, GLshort y, GLshort z);
-    void glVertex3iv(const GLint *v);
-    void glVertex3i(GLint x, GLint y, GLint z);
-    void glVertex3fv(const GLfloat *v);
-    void glVertex3f(GLfloat x, GLfloat y, GLfloat z);
-    void glVertex3dv(const GLdouble *v);
-    void glVertex3d(GLdouble x, GLdouble y, GLdouble z);
-    void glVertex2sv(const GLshort *v);
-    void glVertex2s(GLshort x, GLshort y);
-    void glVertex2iv(const GLint *v);
-    void glVertex2i(GLint x, GLint y);
-    void glVertex2fv(const GLfloat *v);
-    void glVertex2f(GLfloat x, GLfloat y);
-    void glVertex2dv(const GLdouble *v);
-    void glVertex2d(GLdouble x, GLdouble y);
-    void glTexCoord4sv(const GLshort *v);
-    void glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q);
-    void glTexCoord4iv(const GLint *v);
-    void glTexCoord4i(GLint s, GLint t, GLint r, GLint q);
-    void glTexCoord4fv(const GLfloat *v);
-    void glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
-    void glTexCoord4dv(const GLdouble *v);
-    void glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q);
-    void glTexCoord3sv(const GLshort *v);
-    void glTexCoord3s(GLshort s, GLshort t, GLshort r);
-    void glTexCoord3iv(const GLint *v);
-    void glTexCoord3i(GLint s, GLint t, GLint r);
-    void glTexCoord3fv(const GLfloat *v);
-    void glTexCoord3f(GLfloat s, GLfloat t, GLfloat r);
-    void glTexCoord3dv(const GLdouble *v);
-    void glTexCoord3d(GLdouble s, GLdouble t, GLdouble r);
-    void glTexCoord2sv(const GLshort *v);
-    void glTexCoord2s(GLshort s, GLshort t);
-    void glTexCoord2iv(const GLint *v);
-    void glTexCoord2i(GLint s, GLint t);
-    void glTexCoord2fv(const GLfloat *v);
-    void glTexCoord2f(GLfloat s, GLfloat t);
-    void glTexCoord2dv(const GLdouble *v);
-    void glTexCoord2d(GLdouble s, GLdouble t);
-    void glTexCoord1sv(const GLshort *v);
-    void glTexCoord1s(GLshort s);
-    void glTexCoord1iv(const GLint *v);
-    void glTexCoord1i(GLint s);
-    void glTexCoord1fv(const GLfloat *v);
-    void glTexCoord1f(GLfloat s);
-    void glTexCoord1dv(const GLdouble *v);
-    void glTexCoord1d(GLdouble s);
-    void glRectsv(const GLshort *v1, const GLshort *v2);
-    void glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
-    void glRectiv(const GLint *v1, const GLint *v2);
-    void glRecti(GLint x1, GLint y1, GLint x2, GLint y2);
-    void glRectfv(const GLfloat *v1, const GLfloat *v2);
-    void glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
-    void glRectdv(const GLdouble *v1, const GLdouble *v2);
-    void glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
-    void glRasterPos4sv(const GLshort *v);
-    void glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w);
-    void glRasterPos4iv(const GLint *v);
-    void glRasterPos4i(GLint x, GLint y, GLint z, GLint w);
-    void glRasterPos4fv(const GLfloat *v);
-    void glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void glRasterPos4dv(const GLdouble *v);
-    void glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glRasterPos3sv(const GLshort *v);
-    void glRasterPos3s(GLshort x, GLshort y, GLshort z);
-    void glRasterPos3iv(const GLint *v);
-    void glRasterPos3i(GLint x, GLint y, GLint z);
-    void glRasterPos3fv(const GLfloat *v);
-    void glRasterPos3f(GLfloat x, GLfloat y, GLfloat z);
-    void glRasterPos3dv(const GLdouble *v);
-    void glRasterPos3d(GLdouble x, GLdouble y, GLdouble z);
-    void glRasterPos2sv(const GLshort *v);
-    void glRasterPos2s(GLshort x, GLshort y);
-    void glRasterPos2iv(const GLint *v);
-    void glRasterPos2i(GLint x, GLint y);
-    void glRasterPos2fv(const GLfloat *v);
-    void glRasterPos2f(GLfloat x, GLfloat y);
-    void glRasterPos2dv(const GLdouble *v);
-    void glRasterPos2d(GLdouble x, GLdouble y);
-    void glNormal3sv(const GLshort *v);
-    void glNormal3s(GLshort nx, GLshort ny, GLshort nz);
-    void glNormal3iv(const GLint *v);
-    void glNormal3i(GLint nx, GLint ny, GLint nz);
-    void glNormal3fv(const GLfloat *v);
-    void glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz);
-    void glNormal3dv(const GLdouble *v);
-    void glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz);
-    void glNormal3bv(const GLbyte *v);
-    void glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz);
-    void glIndexsv(const GLshort *c);
-    void glIndexs(GLshort c);
-    void glIndexiv(const GLint *c);
-    void glIndexi(GLint c);
-    void glIndexfv(const GLfloat *c);
-    void glIndexf(GLfloat c);
-    void glIndexdv(const GLdouble *c);
-    void glIndexd(GLdouble c);
-    void glEnd();
-    void glEdgeFlagv(const GLboolean *flag);
-    void glEdgeFlag(GLboolean flag);
-    void glColor4usv(const GLushort *v);
-    void glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha);
-    void glColor4uiv(const GLuint *v);
-    void glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha);
-    void glColor4ubv(const GLubyte *v);
-    void glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
-    void glColor4sv(const GLshort *v);
-    void glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha);
-    void glColor4iv(const GLint *v);
-    void glColor4i(GLint red, GLint green, GLint blue, GLint alpha);
-    void glColor4fv(const GLfloat *v);
-    void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glColor4dv(const GLdouble *v);
-    void glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
-    void glColor4bv(const GLbyte *v);
-    void glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
-    void glColor3usv(const GLushort *v);
-    void glColor3us(GLushort red, GLushort green, GLushort blue);
-    void glColor3uiv(const GLuint *v);
-    void glColor3ui(GLuint red, GLuint green, GLuint blue);
-    void glColor3ubv(const GLubyte *v);
-    void glColor3ub(GLubyte red, GLubyte green, GLubyte blue);
-    void glColor3sv(const GLshort *v);
-    void glColor3s(GLshort red, GLshort green, GLshort blue);
-    void glColor3iv(const GLint *v);
-    void glColor3i(GLint red, GLint green, GLint blue);
-    void glColor3fv(const GLfloat *v);
-    void glColor3f(GLfloat red, GLfloat green, GLfloat blue);
-    void glColor3dv(const GLdouble *v);
-    void glColor3d(GLdouble red, GLdouble green, GLdouble blue);
-    void glColor3bv(const GLbyte *v);
-    void glColor3b(GLbyte red, GLbyte green, GLbyte blue);
-    void glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap);
-    void glBegin(GLenum mode);
-    void glListBase(GLuint base);
-    GLuint glGenLists(GLsizei range);
-    void glDeleteLists(GLuint list, GLsizei range);
-    void glCallLists(GLsizei n, GLenum type, const void *lists);
-    void glCallList(GLuint list);
-    void glEndList();
-    void glNewList(GLuint list, GLenum mode);
-
-    // OpenGL 1.1 deprecated functions
-    void glPushClientAttrib(GLbitfield mask);
-    void glPopClientAttrib();
-    void glIndexubv(const GLubyte *c);
-    void glIndexub(GLubyte c);
-    void glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities);
-    GLboolean glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences);
-    void glVertexPointer(GLint size, GLenum type, GLsizei stride, const void *pointer);
-    void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const void *pointer);
-    void glNormalPointer(GLenum type, GLsizei stride, const void *pointer);
-    void glInterleavedArrays(GLenum format, GLsizei stride, const void *pointer);
-    void glGetPointerv(GLenum pname, void * *params);
-    void glIndexPointer(GLenum type, GLsizei stride, const void *pointer);
-    void glEnableClientState(GLenum array);
-    void glEdgeFlagPointer(GLsizei stride, const void *pointer);
-    void glDisableClientState(GLenum array);
-    void glColorPointer(GLint size, GLenum type, GLsizei stride, const void *pointer);
-    void glArrayElement(GLint i);
-
-    // OpenGL 1.2 deprecated functions
-    void glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void *table);
-    void glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
-    void glGetColorTable(GLenum target, GLenum format, GLenum type, void *table);
-    void glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const void *data);
-    void glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width);
-    void glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void *image);
-    void glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *image);
-    void glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params);
-    void glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glConvolutionParameteri(GLenum target, GLenum pname, GLint params);
-    void glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
-    void glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, void *image);
-    void glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetSeparableFilter(GLenum target, GLenum format, GLenum type, void *row, void *column, void *span);
-    void glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *row, const void *column);
-    void glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, void *values);
-    void glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, void *values);
-    void glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink);
-    void glMinmax(GLenum target, GLenum internalformat, GLboolean sink);
-    void glResetHistogram(GLenum target);
-    void glResetMinmax(GLenum target);
-
-    // OpenGL 1.3 deprecated functions
-    void glMultTransposeMatrixd(const GLdouble *m);
-    void glMultTransposeMatrixf(const GLfloat *m);
-    void glLoadTransposeMatrixd(const GLdouble *m);
-    void glLoadTransposeMatrixf(const GLfloat *m);
-    void glMultiTexCoord4sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);
-    void glMultiTexCoord4iv(GLenum target, const GLint *v);
-    void glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q);
-    void glMultiTexCoord4fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
-    void glMultiTexCoord4dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
-    void glMultiTexCoord3sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r);
-    void glMultiTexCoord3iv(GLenum target, const GLint *v);
-    void glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r);
-    void glMultiTexCoord3fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r);
-    void glMultiTexCoord3dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r);
-    void glMultiTexCoord2sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord2s(GLenum target, GLshort s, GLshort t);
-    void glMultiTexCoord2iv(GLenum target, const GLint *v);
-    void glMultiTexCoord2i(GLenum target, GLint s, GLint t);
-    void glMultiTexCoord2fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t);
-    void glMultiTexCoord2dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t);
-    void glMultiTexCoord1sv(GLenum target, const GLshort *v);
-    void glMultiTexCoord1s(GLenum target, GLshort s);
-    void glMultiTexCoord1iv(GLenum target, const GLint *v);
-    void glMultiTexCoord1i(GLenum target, GLint s);
-    void glMultiTexCoord1fv(GLenum target, const GLfloat *v);
-    void glMultiTexCoord1f(GLenum target, GLfloat s);
-    void glMultiTexCoord1dv(GLenum target, const GLdouble *v);
-    void glMultiTexCoord1d(GLenum target, GLdouble s);
-    void glClientActiveTexture(GLenum texture);
-
-    // OpenGL 1.4 deprecated functions
-    void glWindowPos3sv(const GLshort *v);
-    void glWindowPos3s(GLshort x, GLshort y, GLshort z);
-    void glWindowPos3iv(const GLint *v);
-    void glWindowPos3i(GLint x, GLint y, GLint z);
-    void glWindowPos3fv(const GLfloat *v);
-    void glWindowPos3f(GLfloat x, GLfloat y, GLfloat z);
-    void glWindowPos3dv(const GLdouble *v);
-    void glWindowPos3d(GLdouble x, GLdouble y, GLdouble z);
-    void glWindowPos2sv(const GLshort *v);
-    void glWindowPos2s(GLshort x, GLshort y);
-    void glWindowPos2iv(const GLint *v);
-    void glWindowPos2i(GLint x, GLint y);
-    void glWindowPos2fv(const GLfloat *v);
-    void glWindowPos2f(GLfloat x, GLfloat y);
-    void glWindowPos2dv(const GLdouble *v);
-    void glWindowPos2d(GLdouble x, GLdouble y);
-    void glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const void *pointer);
-    void glSecondaryColor3usv(const GLushort *v);
-    void glSecondaryColor3us(GLushort red, GLushort green, GLushort blue);
-    void glSecondaryColor3uiv(const GLuint *v);
-    void glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue);
-    void glSecondaryColor3ubv(const GLubyte *v);
-    void glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue);
-    void glSecondaryColor3sv(const GLshort *v);
-    void glSecondaryColor3s(GLshort red, GLshort green, GLshort blue);
-    void glSecondaryColor3iv(const GLint *v);
-    void glSecondaryColor3i(GLint red, GLint green, GLint blue);
-    void glSecondaryColor3fv(const GLfloat *v);
-    void glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue);
-    void glSecondaryColor3dv(const GLdouble *v);
-    void glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue);
-    void glSecondaryColor3bv(const GLbyte *v);
-    void glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue);
-    void glFogCoordPointer(GLenum type, GLsizei stride, const void *pointer);
-    void glFogCoorddv(const GLdouble *coord);
-    void glFogCoordd(GLdouble coord);
-    void glFogCoordfv(const GLfloat *coord);
-    void glFogCoordf(GLfloat coord);
-
-    // OpenGL 1.5 deprecated functions
-
-    // OpenGL 2.0 deprecated functions
-
-    // OpenGL 2.1 deprecated functions
-
-    // OpenGL 3.0 deprecated functions
-
-    // OpenGL 3.1 deprecated functions
-
-    // OpenGL 3.2 deprecated functions
-
-    // OpenGL 3.3 deprecated functions
-    void glSecondaryColorP3uiv(GLenum type, const GLuint *color);
-    void glSecondaryColorP3ui(GLenum type, GLuint color);
-    void glColorP4uiv(GLenum type, const GLuint *color);
-    void glColorP4ui(GLenum type, GLuint color);
-    void glColorP3uiv(GLenum type, const GLuint *color);
-    void glColorP3ui(GLenum type, GLuint color);
-    void glNormalP3uiv(GLenum type, const GLuint *coords);
-    void glNormalP3ui(GLenum type, GLuint coords);
-    void glMultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint *coords);
-    void glMultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords);
-    void glMultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint *coords);
-    void glMultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords);
-    void glMultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint *coords);
-    void glMultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords);
-    void glMultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint *coords);
-    void glMultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords);
-    void glTexCoordP4uiv(GLenum type, const GLuint *coords);
-    void glTexCoordP4ui(GLenum type, GLuint coords);
-    void glTexCoordP3uiv(GLenum type, const GLuint *coords);
-    void glTexCoordP3ui(GLenum type, GLuint coords);
-    void glTexCoordP2uiv(GLenum type, const GLuint *coords);
-    void glTexCoordP2ui(GLenum type, GLuint coords);
-    void glTexCoordP1uiv(GLenum type, const GLuint *coords);
-    void glTexCoordP1ui(GLenum type, GLuint coords);
-    void glVertexP4uiv(GLenum type, const GLuint *value);
-    void glVertexP4ui(GLenum type, GLuint value);
-    void glVertexP3uiv(GLenum type, const GLuint *value);
-    void glVertexP3ui(GLenum type, GLuint value);
-    void glVertexP2uiv(GLenum type, const GLuint *value);
-    void glVertexP2ui(GLenum type, GLuint value);
-
-    // OpenGL 4.0 deprecated functions
-
-    // OpenGL 4.1 deprecated functions
-
-    // OpenGL 4.2 deprecated functions
-
-    // OpenGL 4.3 deprecated functions
-
-    // OpenGL 4.4 deprecated functions
-
-    // OpenGL 4.5 deprecated functions
-    void glGetnMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, void *values);
-    void glGetnHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, void *values);
-    void glGetnSeparableFilter(GLenum target, GLenum format, GLenum type, GLsizei rowBufSize, void *row, GLsizei columnBufSize, void *column, void *span);
-    void glGetnConvolutionFilter(GLenum target, GLenum format, GLenum type, GLsizei bufSize, void *image);
-    void glGetnColorTable(GLenum target, GLenum format, GLenum type, GLsizei bufSize, void *table);
-    void glGetnPolygonStipple(GLsizei bufSize, GLubyte *pattern);
-    void glGetnPixelMapusv(GLenum map, GLsizei bufSize, GLushort *values);
-    void glGetnPixelMapuiv(GLenum map, GLsizei bufSize, GLuint *values);
-    void glGetnPixelMapfv(GLenum map, GLsizei bufSize, GLfloat *values);
-    void glGetnMapiv(GLenum target, GLenum query, GLsizei bufSize, GLint *v);
-    void glGetnMapfv(GLenum target, GLenum query, GLsizei bufSize, GLfloat *v);
-    void glGetnMapdv(GLenum target, GLenum query, GLsizei bufSize, GLdouble *v);
-
-private:
-    friend class QOpenGLContext;
-
-    static bool isContextCompatible(QOpenGLContext *context);
-    static QOpenGLVersionProfile versionProfile();
-
-    QOpenGLFunctions_1_0_CoreBackend* d_1_0_Core;
-    QOpenGLFunctions_1_1_CoreBackend* d_1_1_Core;
-    QOpenGLFunctions_1_2_CoreBackend* d_1_2_Core;
-    QOpenGLFunctions_1_3_CoreBackend* d_1_3_Core;
-    QOpenGLFunctions_1_4_CoreBackend* d_1_4_Core;
-    QOpenGLFunctions_1_5_CoreBackend* d_1_5_Core;
-    QOpenGLFunctions_2_0_CoreBackend* d_2_0_Core;
-    QOpenGLFunctions_2_1_CoreBackend* d_2_1_Core;
-    QOpenGLFunctions_3_0_CoreBackend* d_3_0_Core;
-    QOpenGLFunctions_3_1_CoreBackend* d_3_1_Core;
-    QOpenGLFunctions_3_2_CoreBackend* d_3_2_Core;
-    QOpenGLFunctions_3_3_CoreBackend* d_3_3_Core;
-    QOpenGLFunctions_4_0_CoreBackend* d_4_0_Core;
-    QOpenGLFunctions_4_1_CoreBackend* d_4_1_Core;
-    QOpenGLFunctions_4_2_CoreBackend* d_4_2_Core;
-    QOpenGLFunctions_4_3_CoreBackend* d_4_3_Core;
-    QOpenGLFunctions_4_4_CoreBackend* d_4_4_Core;
-    QOpenGLFunctions_4_5_CoreBackend* d_4_5_Core;
-    QOpenGLFunctions_1_0_DeprecatedBackend* d_1_0_Deprecated;
-    QOpenGLFunctions_1_1_DeprecatedBackend* d_1_1_Deprecated;
-    QOpenGLFunctions_1_2_DeprecatedBackend* d_1_2_Deprecated;
-    QOpenGLFunctions_1_3_DeprecatedBackend* d_1_3_Deprecated;
-    QOpenGLFunctions_1_4_DeprecatedBackend* d_1_4_Deprecated;
-    QOpenGLFunctions_3_3_DeprecatedBackend* d_3_3_Deprecated;
-    QOpenGLFunctions_4_5_DeprecatedBackend* d_4_5_Deprecated;
-};
-
-// OpenGL 1.0 core functions
-inline void QOpenGLFunctions_4_5_Compatibility::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_0_Core->f.Viewport(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glDepthRange(GLdouble nearVal, GLdouble farVal)
-{
-    d_1_0_Core->f.DepthRange(nearVal, farVal);
-}
-
-inline GLboolean QOpenGLFunctions_4_5_Compatibility::glIsEnabled(GLenum cap)
-{
-    return d_1_0_Core->f.IsEnabled(cap);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetTexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetTexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, void *pixels)
-{
-    d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
-}
-
-inline const GLubyte * QOpenGLFunctions_4_5_Compatibility::glGetString(GLenum name)
-{
-    return d_1_0_Core->f.GetString(name);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetIntegerv(GLenum pname, GLint *data)
-{
-    d_1_0_Core->f.GetIntegerv(pname, data);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetFloatv(GLenum pname, GLfloat *data)
-{
-    d_1_0_Core->f.GetFloatv(pname, data);
-}
-
-inline GLenum QOpenGLFunctions_4_5_Compatibility::glGetError()
-{
-    return d_1_0_Core->f.GetError();
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetDoublev(GLenum pname, GLdouble *data)
-{
-    d_1_0_Core->f.GetDoublev(pname, data);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetBooleanv(GLenum pname, GLboolean *data)
-{
-    d_1_0_Core->f.GetBooleanv(pname, data);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels)
-{
-    d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glReadBuffer(GLenum src)
-{
-    d_1_0_Core->f.ReadBuffer(src);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glPixelStorei(GLenum pname, GLint param)
-{
-    d_1_0_Core->f.PixelStorei(pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glPixelStoref(GLenum pname, GLfloat param)
-{
-    d_1_0_Core->f.PixelStoref(pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glDepthFunc(GLenum func)
-{
-    d_1_0_Core->f.DepthFunc(func);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
-{
-    d_1_0_Core->f.StencilOp(fail, zfail, zpass);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glStencilFunc(GLenum func, GLint ref, GLuint mask)
-{
-    d_1_0_Core->f.StencilFunc(func, ref, mask);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glLogicOp(GLenum opcode)
-{
-    d_1_0_Core->f.LogicOp(opcode);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glBlendFunc(GLenum sfactor, GLenum dfactor)
-{
-    d_1_0_Core->f.BlendFunc(sfactor, dfactor);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glFlush()
-{
-    d_1_0_Core->f.Flush();
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glFinish()
-{
-    d_1_0_Core->f.Finish();
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glEnable(GLenum cap)
-{
-    d_1_0_Core->f.Enable(cap);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glDisable(GLenum cap)
-{
-    d_1_0_Core->f.Disable(cap);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glDepthMask(GLboolean flag)
-{
-    d_1_0_Core->f.DepthMask(flag);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
-{
-    d_1_0_Core->f.ColorMask(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glStencilMask(GLuint mask)
-{
-    d_1_0_Core->f.StencilMask(mask);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glClearDepth(GLdouble depth)
-{
-    d_1_0_Core->f.ClearDepth(depth);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glClearStencil(GLint s)
-{
-    d_1_0_Core->f.ClearStencil(s);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Core->f.ClearColor(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glClear(GLbitfield mask)
-{
-    d_1_0_Core->f.Clear(mask);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glDrawBuffer(GLenum buf)
-{
-    d_1_0_Core->f.DrawBuffer(buf);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels)
-{
-    d_1_0_Core->f.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels)
-{
-    d_1_0_Core->f.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_0_Core->f.TexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexParameteri(GLenum target, GLenum pname, GLint param)
-{
-    d_1_0_Core->f.TexParameteri(target, pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Core->f.TexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
-{
-    d_1_0_Core->f.TexParameterf(target, pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_0_Core->f.Scissor(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glPolygonMode(GLenum face, GLenum mode)
-{
-    d_1_0_Core->f.PolygonMode(face, mode);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glPointSize(GLfloat size)
-{
-    d_1_0_Core->f.PointSize(size);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glLineWidth(GLfloat width)
-{
-    d_1_0_Core->f.LineWidth(width);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glHint(GLenum target, GLenum mode)
-{
-    d_1_0_Core->f.Hint(target, mode);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glFrontFace(GLenum mode)
-{
-    d_1_0_Core->f.FrontFace(mode);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glCullFace(GLenum mode)
-{
-    d_1_0_Core->f.CullFace(mode);
-}
-
-
-// OpenGL 1.1 core functions
-inline GLboolean QOpenGLFunctions_4_5_Compatibility::glIsTexture(GLuint texture)
-{
-    return d_1_1_Core->f.IsTexture(texture);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGenTextures(GLsizei n, GLuint *textures)
-{
-    d_1_1_Core->f.GenTextures(n, textures);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glDeleteTextures(GLsizei n, const GLuint *textures)
-{
-    d_1_1_Core->f.DeleteTextures(n, textures);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glBindTexture(GLenum target, GLuint texture)
-{
-    d_1_1_Core->f.BindTexture(target, texture);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)
-{
-    d_1_1_Core->f.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels)
-{
-    d_1_1_Core->f.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_1_Core->f.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
-{
-    d_1_1_Core->f.CopyTexSubImage1D(target, level, xoffset, x, y, width);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
-{
-    d_1_1_Core->f.CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
-{
-    d_1_1_Core->f.CopyTexImage1D(target, level, internalformat, x, y, width, border);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glPolygonOffset(GLfloat factor, GLfloat units)
-{
-    d_1_1_Core->f.PolygonOffset(factor, units);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glDrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices)
-{
-    d_1_1_Core->f.DrawElements(mode, count, type, indices);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glDrawArrays(GLenum mode, GLint first, GLsizei count)
-{
-    d_1_1_Core->f.DrawArrays(mode, first, count);
-}
-
-
-// OpenGL 1.2 core functions
-inline void QOpenGLFunctions_4_5_Compatibility::glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_2_Core->f.BlendColor(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glBlendEquation(GLenum mode)
-{
-    d_1_2_Core->f.BlendEquation(mode);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_2_Core->f.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels)
-{
-    d_1_2_Core->f.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels)
-{
-    d_1_2_Core->f.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices)
-{
-    d_1_2_Core->f.DrawRangeElements(mode, start, end, count, type, indices);
-}
-
-
-// OpenGL 1.3 core functions
-inline void QOpenGLFunctions_4_5_Compatibility::glGetCompressedTexImage(GLenum target, GLint level, void *img)
-{
-    d_1_3_Core->f.GetCompressedTexImage(target, level, img);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data)
-{
-    d_1_3_Core->f.CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data)
-{
-    d_1_3_Core->f.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data)
-{
-    d_1_3_Core->f.CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glSampleCoverage(GLfloat value, GLboolean invert)
-{
-    d_1_3_Core->f.SampleCoverage(value, invert);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glActiveTexture(GLenum texture)
-{
-    d_1_3_Core->f.ActiveTexture(texture);
-}
-
-
-// OpenGL 1.4 core functions
-inline void QOpenGLFunctions_4_5_Compatibility::glPointParameteriv(GLenum pname, const GLint *params)
-{
-    d_1_4_Core->f.PointParameteriv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glPointParameteri(GLenum pname, GLint param)
-{
-    d_1_4_Core->f.PointParameteri(pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glPointParameterfv(GLenum pname, const GLfloat *params)
-{
-    d_1_4_Core->f.PointParameterfv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glPointParameterf(GLenum pname, GLfloat param)
-{
-    d_1_4_Core->f.PointParameterf(pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const void *const *indices, GLsizei drawcount)
-{
-    d_1_4_Core->f.MultiDrawElements(mode, count, type, indices, drawcount);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
-{
-    d_1_4_Core->f.MultiDrawArrays(mode, first, count, drawcount);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
-{
-    d_1_4_Core->f.BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
-}
-
-
-// OpenGL 1.5 core functions
-inline void QOpenGLFunctions_4_5_Compatibility::glGetBufferPointerv(GLenum target, GLenum pname, void * *params)
-{
-    d_1_5_Core->f.GetBufferPointerv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetBufferParameteriv(target, pname, params);
-}
-
-inline GLboolean QOpenGLFunctions_4_5_Compatibility::glUnmapBuffer(GLenum target)
-{
-    return d_1_5_Core->f.UnmapBuffer(target);
-}
-
-inline void * QOpenGLFunctions_4_5_Compatibility::glMapBuffer(GLenum target, GLenum access)
-{
-    return d_1_5_Core->f.MapBuffer(target, access);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, void *data)
-{
-    d_1_5_Core->f.GetBufferSubData(target, offset, size, data);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void *data)
-{
-    d_1_5_Core->f.BufferSubData(target, offset, size, data);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glBufferData(GLenum target, GLsizeiptr size, const void *data, GLenum usage)
-{
-    d_1_5_Core->f.BufferData(target, size, data, usage);
-}
-
-inline GLboolean QOpenGLFunctions_4_5_Compatibility::glIsBuffer(GLuint buffer)
-{
-    return d_1_5_Core->f.IsBuffer(buffer);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGenBuffers(GLsizei n, GLuint *buffers)
-{
-    d_1_5_Core->f.GenBuffers(n, buffers);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glDeleteBuffers(GLsizei n, const GLuint *buffers)
-{
-    d_1_5_Core->f.DeleteBuffers(n, buffers);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glBindBuffer(GLenum target, GLuint buffer)
-{
-    d_1_5_Core->f.BindBuffer(target, buffer);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
-{
-    d_1_5_Core->f.GetQueryObjectuiv(id, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetQueryObjectiv(id, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetQueryiv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetQueryiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glEndQuery(GLenum target)
-{
-    d_1_5_Core->f.EndQuery(target);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glBeginQuery(GLenum target, GLuint id)
-{
-    d_1_5_Core->f.BeginQuery(target, id);
-}
-
-inline GLboolean QOpenGLFunctions_4_5_Compatibility::glIsQuery(GLuint id)
-{
-    return d_1_5_Core->f.IsQuery(id);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glDeleteQueries(GLsizei n, const GLuint *ids)
-{
-    d_1_5_Core->f.DeleteQueries(n, ids);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGenQueries(GLsizei n, GLuint *ids)
-{
-    d_1_5_Core->f.GenQueries(n, ids);
-}
-
-
-// OpenGL 2.0 core functions
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer)
-{
-    d_2_0_Core->f.VertexAttribPointer(index, size, type, normalized, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib4usv(GLuint index, const GLushort *v)
-{
-    d_2_0_Core->f.VertexAttrib4usv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib4uiv(GLuint index, const GLuint *v)
-{
-    d_2_0_Core->f.VertexAttrib4uiv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib4ubv(GLuint index, const GLubyte *v)
-{
-    d_2_0_Core->f.VertexAttrib4ubv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib4sv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib4sv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
-{
-    d_2_0_Core->f.VertexAttrib4s(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib4iv(GLuint index, const GLint *v)
-{
-    d_2_0_Core->f.VertexAttrib4iv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib4fv(GLuint index, const GLfloat *v)
-{
-    d_2_0_Core->f.VertexAttrib4fv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    d_2_0_Core->f.VertexAttrib4f(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib4dv(GLuint index, const GLdouble *v)
-{
-    d_2_0_Core->f.VertexAttrib4dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_2_0_Core->f.VertexAttrib4d(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib4bv(GLuint index, const GLbyte *v)
-{
-    d_2_0_Core->f.VertexAttrib4bv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib4Nusv(GLuint index, const GLushort *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nusv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib4Nuiv(GLuint index, const GLuint *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nuiv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib4Nubv(GLuint index, const GLubyte *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nubv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
-{
-    d_2_0_Core->f.VertexAttrib4Nub(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib4Nsv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nsv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib4Niv(GLuint index, const GLint *v)
-{
-    d_2_0_Core->f.VertexAttrib4Niv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib4Nbv(GLuint index, const GLbyte *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nbv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib3sv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib3sv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
-{
-    d_2_0_Core->f.VertexAttrib3s(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib3fv(GLuint index, const GLfloat *v)
-{
-    d_2_0_Core->f.VertexAttrib3fv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
-{
-    d_2_0_Core->f.VertexAttrib3f(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib3dv(GLuint index, const GLdouble *v)
-{
-    d_2_0_Core->f.VertexAttrib3dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
-{
-    d_2_0_Core->f.VertexAttrib3d(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib2sv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib2sv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib2s(GLuint index, GLshort x, GLshort y)
-{
-    d_2_0_Core->f.VertexAttrib2s(index, x, y);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib2fv(GLuint index, const GLfloat *v)
-{
-    d_2_0_Core->f.VertexAttrib2fv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
-{
-    d_2_0_Core->f.VertexAttrib2f(index, x, y);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib2dv(GLuint index, const GLdouble *v)
-{
-    d_2_0_Core->f.VertexAttrib2dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
-{
-    d_2_0_Core->f.VertexAttrib2d(index, x, y);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib1sv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib1sv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib1s(GLuint index, GLshort x)
-{
-    d_2_0_Core->f.VertexAttrib1s(index, x);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib1fv(GLuint index, const GLfloat *v)
-{
-    d_2_0_Core->f.VertexAttrib1fv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib1f(GLuint index, GLfloat x)
-{
-    d_2_0_Core->f.VertexAttrib1f(index, x);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib1dv(GLuint index, const GLdouble *v)
-{
-    d_2_0_Core->f.VertexAttrib1dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib1d(GLuint index, GLdouble x)
-{
-    d_2_0_Core->f.VertexAttrib1d(index, x);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glValidateProgram(GLuint program)
-{
-    d_2_0_Core->f.ValidateProgram(program);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix3fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glUniform4iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform4iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glUniform3iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform3iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glUniform2iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform2iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glUniform1iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform1iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glUniform4fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform4fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glUniform3fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform3fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glUniform2fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform2fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glUniform1fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform1fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
-{
-    d_2_0_Core->f.Uniform4i(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glUniform3i(GLint location, GLint v0, GLint v1, GLint v2)
-{
-    d_2_0_Core->f.Uniform3i(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glUniform2i(GLint location, GLint v0, GLint v1)
-{
-    d_2_0_Core->f.Uniform2i(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glUniform1i(GLint location, GLint v0)
-{
-    d_2_0_Core->f.Uniform1i(location, v0);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
-{
-    d_2_0_Core->f.Uniform4f(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
-{
-    d_2_0_Core->f.Uniform3f(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glUniform2f(GLint location, GLfloat v0, GLfloat v1)
-{
-    d_2_0_Core->f.Uniform2f(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glUniform1f(GLint location, GLfloat v0)
-{
-    d_2_0_Core->f.Uniform1f(location, v0);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glUseProgram(GLuint program)
-{
-    d_2_0_Core->f.UseProgram(program);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glShaderSource(GLuint shader, GLsizei count, const GLchar *const *string, const GLint *length)
-{
-    d_2_0_Core->f.ShaderSource(shader, count, string, length);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glLinkProgram(GLuint program)
-{
-    d_2_0_Core->f.LinkProgram(program);
-}
-
-inline GLboolean QOpenGLFunctions_4_5_Compatibility::glIsShader(GLuint shader)
-{
-    return d_2_0_Core->f.IsShader(shader);
-}
-
-inline GLboolean QOpenGLFunctions_4_5_Compatibility::glIsProgram(GLuint program)
-{
-    return d_2_0_Core->f.IsProgram(program);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetVertexAttribPointerv(GLuint index, GLenum pname, void * *pointer)
-{
-    d_2_0_Core->f.GetVertexAttribPointerv(index, pname, pointer);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetVertexAttribiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
-{
-    d_2_0_Core->f.GetVertexAttribfv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
-{
-    d_2_0_Core->f.GetVertexAttribdv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetUniformiv(GLuint program, GLint location, GLint *params)
-{
-    d_2_0_Core->f.GetUniformiv(program, location, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetUniformfv(GLuint program, GLint location, GLfloat *params)
-{
-    d_2_0_Core->f.GetUniformfv(program, location, params);
-}
-
-inline GLint QOpenGLFunctions_4_5_Compatibility::glGetUniformLocation(GLuint program, const GLchar *name)
-{
-    return d_2_0_Core->f.GetUniformLocation(program, name);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
-{
-    d_2_0_Core->f.GetShaderSource(shader, bufSize, length, source);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-{
-    d_2_0_Core->f.GetShaderInfoLog(shader, bufSize, length, infoLog);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetShaderiv(GLuint shader, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetShaderiv(shader, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-{
-    d_2_0_Core->f.GetProgramInfoLog(program, bufSize, length, infoLog);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetProgramiv(GLuint program, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetProgramiv(program, pname, params);
-}
-
-inline GLint QOpenGLFunctions_4_5_Compatibility::glGetAttribLocation(GLuint program, const GLchar *name)
-{
-    return d_2_0_Core->f.GetAttribLocation(program, name);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders)
-{
-    d_2_0_Core->f.GetAttachedShaders(program, maxCount, count, shaders);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
-{
-    d_2_0_Core->f.GetActiveUniform(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
-{
-    d_2_0_Core->f.GetActiveAttrib(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glEnableVertexAttribArray(GLuint index)
-{
-    d_2_0_Core->f.EnableVertexAttribArray(index);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glDisableVertexAttribArray(GLuint index)
-{
-    d_2_0_Core->f.DisableVertexAttribArray(index);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glDetachShader(GLuint program, GLuint shader)
-{
-    d_2_0_Core->f.DetachShader(program, shader);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glDeleteShader(GLuint shader)
-{
-    d_2_0_Core->f.DeleteShader(shader);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glDeleteProgram(GLuint program)
-{
-    d_2_0_Core->f.DeleteProgram(program);
-}
-
-inline GLuint QOpenGLFunctions_4_5_Compatibility::glCreateShader(GLenum type)
-{
-    return d_2_0_Core->f.CreateShader(type);
-}
-
-inline GLuint QOpenGLFunctions_4_5_Compatibility::glCreateProgram()
-{
-    return d_2_0_Core->f.CreateProgram();
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glCompileShader(GLuint shader)
-{
-    d_2_0_Core->f.CompileShader(shader);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glBindAttribLocation(GLuint program, GLuint index, const GLchar *name)
-{
-    d_2_0_Core->f.BindAttribLocation(program, index, name);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glAttachShader(GLuint program, GLuint shader)
-{
-    d_2_0_Core->f.AttachShader(program, shader);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glStencilMaskSeparate(GLenum face, GLuint mask)
-{
-    d_2_0_Core->f.StencilMaskSeparate(face, mask);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
-{
-    d_2_0_Core->f.StencilFuncSeparate(face, func, ref, mask);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
-{
-    d_2_0_Core->f.StencilOpSeparate(face, sfail, dpfail, dppass);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glDrawBuffers(GLsizei n, const GLenum *bufs)
-{
-    d_2_0_Core->f.DrawBuffers(n, bufs);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
-{
-    d_2_0_Core->f.BlendEquationSeparate(modeRGB, modeAlpha);
-}
-
-
-// OpenGL 2.1 core functions
-inline void QOpenGLFunctions_4_5_Compatibility::glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix4x3fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix3x4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix4x2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix2x4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix3x2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix2x3fv(location, count, transpose, value);
-}
-
-
-// OpenGL 3.0 core functions
-inline GLboolean QOpenGLFunctions_4_5_Compatibility::glIsVertexArray(GLuint array)
-{
-    return d_3_0_Core->f.IsVertexArray(array);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGenVertexArrays(GLsizei n, GLuint *arrays)
-{
-    d_3_0_Core->f.GenVertexArrays(n, arrays);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glDeleteVertexArrays(GLsizei n, const GLuint *arrays)
-{
-    d_3_0_Core->f.DeleteVertexArrays(n, arrays);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glBindVertexArray(GLuint array)
-{
-    d_3_0_Core->f.BindVertexArray(array);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
-{
-    d_3_0_Core->f.FlushMappedBufferRange(target, offset, length);
-}
-
-inline void * QOpenGLFunctions_4_5_Compatibility::glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
-{
-    return d_3_0_Core->f.MapBufferRange(target, offset, length, access);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
-{
-    d_3_0_Core->f.FramebufferTextureLayer(target, attachment, texture, level, layer);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    d_3_0_Core->f.RenderbufferStorageMultisample(target, samples, internalformat, width, height);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
-{
-    d_3_0_Core->f.BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGenerateMipmap(GLenum target)
-{
-    d_3_0_Core->f.GenerateMipmap(target);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
-{
-    d_3_0_Core->f.FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
-{
-    d_3_0_Core->f.FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
-{
-    d_3_0_Core->f.FramebufferTexture2D(target, attachment, textarget, texture, level);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
-{
-    d_3_0_Core->f.FramebufferTexture1D(target, attachment, textarget, texture, level);
-}
-
-inline GLenum QOpenGLFunctions_4_5_Compatibility::glCheckFramebufferStatus(GLenum target)
-{
-    return d_3_0_Core->f.CheckFramebufferStatus(target);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGenFramebuffers(GLsizei n, GLuint *framebuffers)
-{
-    d_3_0_Core->f.GenFramebuffers(n, framebuffers);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
-{
-    d_3_0_Core->f.DeleteFramebuffers(n, framebuffers);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glBindFramebuffer(GLenum target, GLuint framebuffer)
-{
-    d_3_0_Core->f.BindFramebuffer(target, framebuffer);
-}
-
-inline GLboolean QOpenGLFunctions_4_5_Compatibility::glIsFramebuffer(GLuint framebuffer)
-{
-    return d_3_0_Core->f.IsFramebuffer(framebuffer);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetRenderbufferParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    d_3_0_Core->f.RenderbufferStorage(target, internalformat, width, height);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGenRenderbuffers(GLsizei n, GLuint *renderbuffers)
-{
-    d_3_0_Core->f.GenRenderbuffers(n, renderbuffers);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
-{
-    d_3_0_Core->f.DeleteRenderbuffers(n, renderbuffers);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glBindRenderbuffer(GLenum target, GLuint renderbuffer)
-{
-    d_3_0_Core->f.BindRenderbuffer(target, renderbuffer);
-}
-
-inline GLboolean QOpenGLFunctions_4_5_Compatibility::glIsRenderbuffer(GLuint renderbuffer)
-{
-    return d_3_0_Core->f.IsRenderbuffer(renderbuffer);
-}
-
-inline const GLubyte * QOpenGLFunctions_4_5_Compatibility::glGetStringi(GLenum name, GLuint index)
-{
-    return d_3_0_Core->f.GetStringi(name, index);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
-{
-    d_3_0_Core->f.ClearBufferfi(buffer, drawbuffer, depth, stencil);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
-{
-    d_3_0_Core->f.ClearBufferfv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
-{
-    d_3_0_Core->f.ClearBufferuiv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
-{
-    d_3_0_Core->f.ClearBufferiv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params)
-{
-    d_3_0_Core->f.GetTexParameterIuiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetTexParameterIiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params)
-{
-    d_3_0_Core->f.TexParameterIuiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexParameterIiv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_3_0_Core->f.TexParameterIiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glUniform4uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform4uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glUniform3uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform3uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glUniform2uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform2uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glUniform1uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform1uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
-{
-    d_3_0_Core->f.Uniform4ui(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
-{
-    d_3_0_Core->f.Uniform3ui(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glUniform2ui(GLint location, GLuint v0, GLuint v1)
-{
-    d_3_0_Core->f.Uniform2ui(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glUniform1ui(GLint location, GLuint v0)
-{
-    d_3_0_Core->f.Uniform1ui(location, v0);
-}
-
-inline GLint QOpenGLFunctions_4_5_Compatibility::glGetFragDataLocation(GLuint program, const GLchar *name)
-{
-    return d_3_0_Core->f.GetFragDataLocation(program, name);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name)
-{
-    d_3_0_Core->f.BindFragDataLocation(program, color, name);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetUniformuiv(GLuint program, GLint location, GLuint *params)
-{
-    d_3_0_Core->f.GetUniformuiv(program, location, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribI4usv(GLuint index, const GLushort *v)
-{
-    d_3_0_Core->f.VertexAttribI4usv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribI4ubv(GLuint index, const GLubyte *v)
-{
-    d_3_0_Core->f.VertexAttribI4ubv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribI4sv(GLuint index, const GLshort *v)
-{
-    d_3_0_Core->f.VertexAttribI4sv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribI4bv(GLuint index, const GLbyte *v)
-{
-    d_3_0_Core->f.VertexAttribI4bv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribI4uiv(GLuint index, const GLuint *v)
-{
-    d_3_0_Core->f.VertexAttribI4uiv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribI3uiv(GLuint index, const GLuint *v)
-{
-    d_3_0_Core->f.VertexAttribI3uiv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribI2uiv(GLuint index, const GLuint *v)
-{
-    d_3_0_Core->f.VertexAttribI2uiv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribI1uiv(GLuint index, const GLuint *v)
-{
-    d_3_0_Core->f.VertexAttribI1uiv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribI4iv(GLuint index, const GLint *v)
-{
-    d_3_0_Core->f.VertexAttribI4iv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribI3iv(GLuint index, const GLint *v)
-{
-    d_3_0_Core->f.VertexAttribI3iv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribI2iv(GLuint index, const GLint *v)
-{
-    d_3_0_Core->f.VertexAttribI2iv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribI1iv(GLuint index, const GLint *v)
-{
-    d_3_0_Core->f.VertexAttribI1iv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
-{
-    d_3_0_Core->f.VertexAttribI4ui(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z)
-{
-    d_3_0_Core->f.VertexAttribI3ui(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribI2ui(GLuint index, GLuint x, GLuint y)
-{
-    d_3_0_Core->f.VertexAttribI2ui(index, x, y);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribI1ui(GLuint index, GLuint x)
-{
-    d_3_0_Core->f.VertexAttribI1ui(index, x);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
-{
-    d_3_0_Core->f.VertexAttribI4i(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribI3i(GLuint index, GLint x, GLint y, GLint z)
-{
-    d_3_0_Core->f.VertexAttribI3i(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribI2i(GLuint index, GLint x, GLint y)
-{
-    d_3_0_Core->f.VertexAttribI2i(index, x, y);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribI1i(GLuint index, GLint x)
-{
-    d_3_0_Core->f.VertexAttribI1i(index, x);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
-{
-    d_3_0_Core->f.GetVertexAttribIuiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetVertexAttribIiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer)
-{
-    d_3_0_Core->f.VertexAttribIPointer(index, size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glEndConditionalRender()
-{
-    d_3_0_Core->f.EndConditionalRender();
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glBeginConditionalRender(GLuint id, GLenum mode)
-{
-    d_3_0_Core->f.BeginConditionalRender(id, mode);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glClampColor(GLenum target, GLenum clamp)
-{
-    d_3_0_Core->f.ClampColor(target, clamp);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
-{
-    d_3_0_Core->f.GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar *const *varyings, GLenum bufferMode)
-{
-    d_3_0_Core->f.TransformFeedbackVaryings(program, count, varyings, bufferMode);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
-{
-    d_3_0_Core->f.BindBufferBase(target, index, buffer);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
-{
-    d_3_0_Core->f.BindBufferRange(target, index, buffer, offset, size);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glEndTransformFeedback()
-{
-    d_3_0_Core->f.EndTransformFeedback();
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glBeginTransformFeedback(GLenum primitiveMode)
-{
-    d_3_0_Core->f.BeginTransformFeedback(primitiveMode);
-}
-
-inline GLboolean QOpenGLFunctions_4_5_Compatibility::glIsEnabledi(GLenum target, GLuint index)
-{
-    return d_3_0_Core->f.IsEnabledi(target, index);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glDisablei(GLenum target, GLuint index)
-{
-    d_3_0_Core->f.Disablei(target, index);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glEnablei(GLenum target, GLuint index)
-{
-    d_3_0_Core->f.Enablei(target, index);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetIntegeri_v(GLenum target, GLuint index, GLint *data)
-{
-    d_3_0_Core->f.GetIntegeri_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetBooleani_v(GLenum target, GLuint index, GLboolean *data)
-{
-    d_3_0_Core->f.GetBooleani_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
-{
-    d_3_0_Core->f.ColorMaski(index, r, g, b, a);
-}
-
-
-// OpenGL 3.1 core functions
-inline void QOpenGLFunctions_4_5_Compatibility::glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
-{
-    d_3_1_Core->f.UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
-{
-    d_3_1_Core->f.GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params)
-{
-    d_3_1_Core->f.GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
-}
-
-inline GLuint QOpenGLFunctions_4_5_Compatibility::glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName)
-{
-    return d_3_1_Core->f.GetUniformBlockIndex(program, uniformBlockName);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName)
-{
-    d_3_1_Core->f.GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params)
-{
-    d_3_1_Core->f.GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar *const *uniformNames, GLuint *uniformIndices)
-{
-    d_3_1_Core->f.GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
-{
-    d_3_1_Core->f.CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glPrimitiveRestartIndex(GLuint index)
-{
-    d_3_1_Core->f.PrimitiveRestartIndex(index);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer)
-{
-    d_3_1_Core->f.TexBuffer(target, internalformat, buffer);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount)
-{
-    d_3_1_Core->f.DrawElementsInstanced(mode, count, type, indices, instancecount);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount)
-{
-    d_3_1_Core->f.DrawArraysInstanced(mode, first, count, instancecount);
-}
-
-
-// OpenGL 3.2 core functions
-inline void QOpenGLFunctions_4_5_Compatibility::glSampleMaski(GLuint maskNumber, GLbitfield mask)
-{
-    d_3_2_Core->f.SampleMaski(maskNumber, mask);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val)
-{
-    d_3_2_Core->f.GetMultisamplefv(pname, index, val);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexImage3DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
-{
-    d_3_2_Core->f.TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexImage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
-{
-    d_3_2_Core->f.TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level)
-{
-    d_3_2_Core->f.FramebufferTexture(target, attachment, texture, level);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params)
-{
-    d_3_2_Core->f.GetBufferParameteri64v(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data)
-{
-    d_3_2_Core->f.GetInteger64i_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values)
-{
-    d_3_2_Core->f.GetSynciv(sync, pname, bufSize, length, values);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetInteger64v(GLenum pname, GLint64 *data)
-{
-    d_3_2_Core->f.GetInteger64v(pname, data);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
-{
-    d_3_2_Core->f.WaitSync(sync, flags, timeout);
-}
-
-inline GLenum QOpenGLFunctions_4_5_Compatibility::glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
-{
-    return d_3_2_Core->f.ClientWaitSync(sync, flags, timeout);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glDeleteSync(GLsync sync)
-{
-    d_3_2_Core->f.DeleteSync(sync);
-}
-
-inline GLboolean QOpenGLFunctions_4_5_Compatibility::glIsSync(GLsync sync)
-{
-    return d_3_2_Core->f.IsSync(sync);
-}
-
-inline GLsync QOpenGLFunctions_4_5_Compatibility::glFenceSync(GLenum condition, GLbitfield flags)
-{
-    return d_3_2_Core->f.FenceSync(condition, flags);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProvokingVertex(GLenum mode)
-{
-    d_3_2_Core->f.ProvokingVertex(mode);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count, GLenum type, const void *const *indices, GLsizei drawcount, const GLint *basevertex)
-{
-    d_3_2_Core->f.MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex)
-{
-    d_3_2_Core->f.DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex)
-{
-    d_3_2_Core->f.DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex)
-{
-    d_3_2_Core->f.DrawElementsBaseVertex(mode, count, type, indices, basevertex);
-}
-
-
-// OpenGL 3.3 core functions
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribP4uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP4uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP4ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribP3uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP3uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP3ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribP2uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP2uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP2ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribP1uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP1uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP1ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribDivisor(GLuint index, GLuint divisor)
-{
-    d_3_3_Core->f.VertexAttribDivisor(index, divisor);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params)
-{
-    d_3_3_Core->f.GetQueryObjectui64v(id, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params)
-{
-    d_3_3_Core->f.GetQueryObjecti64v(id, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glQueryCounter(GLuint id, GLenum target)
-{
-    d_3_3_Core->f.QueryCounter(id, target);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params)
-{
-    d_3_3_Core->f.GetSamplerParameterIuiv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params)
-{
-    d_3_3_Core->f.GetSamplerParameterfv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params)
-{
-    d_3_3_Core->f.GetSamplerParameterIiv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params)
-{
-    d_3_3_Core->f.GetSamplerParameteriv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param)
-{
-    d_3_3_Core->f.SamplerParameterIuiv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param)
-{
-    d_3_3_Core->f.SamplerParameterIiv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param)
-{
-    d_3_3_Core->f.SamplerParameterfv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
-{
-    d_3_3_Core->f.SamplerParameterf(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param)
-{
-    d_3_3_Core->f.SamplerParameteriv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glSamplerParameteri(GLuint sampler, GLenum pname, GLint param)
-{
-    d_3_3_Core->f.SamplerParameteri(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glBindSampler(GLuint unit, GLuint sampler)
-{
-    d_3_3_Core->f.BindSampler(unit, sampler);
-}
-
-inline GLboolean QOpenGLFunctions_4_5_Compatibility::glIsSampler(GLuint sampler)
-{
-    return d_3_3_Core->f.IsSampler(sampler);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glDeleteSamplers(GLsizei count, const GLuint *samplers)
-{
-    d_3_3_Core->f.DeleteSamplers(count, samplers);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGenSamplers(GLsizei count, GLuint *samplers)
-{
-    d_3_3_Core->f.GenSamplers(count, samplers);
-}
-
-inline GLint QOpenGLFunctions_4_5_Compatibility::glGetFragDataIndex(GLuint program, const GLchar *name)
-{
-    return d_3_3_Core->f.GetFragDataIndex(program, name);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glBindFragDataLocationIndexed(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name)
-{
-    d_3_3_Core->f.BindFragDataLocationIndexed(program, colorNumber, index, name);
-}
-
-
-// OpenGL 4.0 core functions
-inline void QOpenGLFunctions_4_5_Compatibility::glGetQueryIndexediv(GLenum target, GLuint index, GLenum pname, GLint *params)
-{
-    d_4_0_Core->f.GetQueryIndexediv(target, index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glEndQueryIndexed(GLenum target, GLuint index)
-{
-    d_4_0_Core->f.EndQueryIndexed(target, index);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glBeginQueryIndexed(GLenum target, GLuint index, GLuint id)
-{
-    d_4_0_Core->f.BeginQueryIndexed(target, index, id);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glDrawTransformFeedbackStream(GLenum mode, GLuint id, GLuint stream)
-{
-    d_4_0_Core->f.DrawTransformFeedbackStream(mode, id, stream);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glDrawTransformFeedback(GLenum mode, GLuint id)
-{
-    d_4_0_Core->f.DrawTransformFeedback(mode, id);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glResumeTransformFeedback()
-{
-    d_4_0_Core->f.ResumeTransformFeedback();
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glPauseTransformFeedback()
-{
-    d_4_0_Core->f.PauseTransformFeedback();
-}
-
-inline GLboolean QOpenGLFunctions_4_5_Compatibility::glIsTransformFeedback(GLuint id)
-{
-    return d_4_0_Core->f.IsTransformFeedback(id);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGenTransformFeedbacks(GLsizei n, GLuint *ids)
-{
-    d_4_0_Core->f.GenTransformFeedbacks(n, ids);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids)
-{
-    d_4_0_Core->f.DeleteTransformFeedbacks(n, ids);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glBindTransformFeedback(GLenum target, GLuint id)
-{
-    d_4_0_Core->f.BindTransformFeedback(target, id);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glPatchParameterfv(GLenum pname, const GLfloat *values)
-{
-    d_4_0_Core->f.PatchParameterfv(pname, values);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glPatchParameteri(GLenum pname, GLint value)
-{
-    d_4_0_Core->f.PatchParameteri(pname, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetProgramStageiv(GLuint program, GLenum shadertype, GLenum pname, GLint *values)
-{
-    d_4_0_Core->f.GetProgramStageiv(program, shadertype, pname, values);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetUniformSubroutineuiv(GLenum shadertype, GLint location, GLuint *params)
-{
-    d_4_0_Core->f.GetUniformSubroutineuiv(shadertype, location, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glUniformSubroutinesuiv(GLenum shadertype, GLsizei count, const GLuint *indices)
-{
-    d_4_0_Core->f.UniformSubroutinesuiv(shadertype, count, indices);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetActiveSubroutineName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
-{
-    d_4_0_Core->f.GetActiveSubroutineName(program, shadertype, index, bufsize, length, name);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetActiveSubroutineUniformName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
-{
-    d_4_0_Core->f.GetActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetActiveSubroutineUniformiv(GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values)
-{
-    d_4_0_Core->f.GetActiveSubroutineUniformiv(program, shadertype, index, pname, values);
-}
-
-inline GLuint QOpenGLFunctions_4_5_Compatibility::glGetSubroutineIndex(GLuint program, GLenum shadertype, const GLchar *name)
-{
-    return d_4_0_Core->f.GetSubroutineIndex(program, shadertype, name);
-}
-
-inline GLint QOpenGLFunctions_4_5_Compatibility::glGetSubroutineUniformLocation(GLuint program, GLenum shadertype, const GLchar *name)
-{
-    return d_4_0_Core->f.GetSubroutineUniformLocation(program, shadertype, name);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetUniformdv(GLuint program, GLint location, GLdouble *params)
-{
-    d_4_0_Core->f.GetUniformdv(program, location, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glUniformMatrix4x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix4x3dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glUniformMatrix4x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix4x2dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glUniformMatrix3x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix3x4dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glUniformMatrix3x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix3x2dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glUniformMatrix2x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix2x4dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glUniformMatrix2x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix2x3dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glUniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix4dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glUniformMatrix3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix3dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glUniformMatrix2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix2dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glUniform4dv(GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_0_Core->f.Uniform4dv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glUniform3dv(GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_0_Core->f.Uniform3dv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glUniform2dv(GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_0_Core->f.Uniform2dv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glUniform1dv(GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_0_Core->f.Uniform1dv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glUniform4d(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_4_0_Core->f.Uniform4d(location, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glUniform3d(GLint location, GLdouble x, GLdouble y, GLdouble z)
-{
-    d_4_0_Core->f.Uniform3d(location, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glUniform2d(GLint location, GLdouble x, GLdouble y)
-{
-    d_4_0_Core->f.Uniform2d(location, x, y);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glUniform1d(GLint location, GLdouble x)
-{
-    d_4_0_Core->f.Uniform1d(location, x);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glDrawElementsIndirect(GLenum mode, GLenum type, const void *indirect)
-{
-    d_4_0_Core->f.DrawElementsIndirect(mode, type, indirect);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glDrawArraysIndirect(GLenum mode, const void *indirect)
-{
-    d_4_0_Core->f.DrawArraysIndirect(mode, indirect);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glBlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
-{
-    d_4_0_Core->f.BlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glBlendFunci(GLuint buf, GLenum src, GLenum dst)
-{
-    d_4_0_Core->f.BlendFunci(buf, src, dst);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glBlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha)
-{
-    d_4_0_Core->f.BlendEquationSeparatei(buf, modeRGB, modeAlpha);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glBlendEquationi(GLuint buf, GLenum mode)
-{
-    d_4_0_Core->f.BlendEquationi(buf, mode);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMinSampleShading(GLfloat value)
-{
-    d_4_0_Core->f.MinSampleShading(value);
-}
-
-
-// OpenGL 4.1 core functions
-inline void QOpenGLFunctions_4_5_Compatibility::glGetDoublei_v(GLenum target, GLuint index, GLdouble *data)
-{
-    d_4_1_Core->f.GetDoublei_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetFloati_v(GLenum target, GLuint index, GLfloat *data)
-{
-    d_4_1_Core->f.GetFloati_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glDepthRangeIndexed(GLuint index, GLdouble n, GLdouble f)
-{
-    d_4_1_Core->f.DepthRangeIndexed(index, n, f);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glDepthRangeArrayv(GLuint first, GLsizei count, const GLdouble *v)
-{
-    d_4_1_Core->f.DepthRangeArrayv(first, count, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glScissorIndexedv(GLuint index, const GLint *v)
-{
-    d_4_1_Core->f.ScissorIndexedv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glScissorIndexed(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height)
-{
-    d_4_1_Core->f.ScissorIndexed(index, left, bottom, width, height);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glScissorArrayv(GLuint first, GLsizei count, const GLint *v)
-{
-    d_4_1_Core->f.ScissorArrayv(first, count, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glViewportIndexedfv(GLuint index, const GLfloat *v)
-{
-    d_4_1_Core->f.ViewportIndexedfv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glViewportIndexedf(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h)
-{
-    d_4_1_Core->f.ViewportIndexedf(index, x, y, w, h);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glViewportArrayv(GLuint first, GLsizei count, const GLfloat *v)
-{
-    d_4_1_Core->f.ViewportArrayv(first, count, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetVertexAttribLdv(GLuint index, GLenum pname, GLdouble *params)
-{
-    d_4_1_Core->f.GetVertexAttribLdv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribLPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer)
-{
-    d_4_1_Core->f.VertexAttribLPointer(index, size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribL4dv(GLuint index, const GLdouble *v)
-{
-    d_4_1_Core->f.VertexAttribL4dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribL3dv(GLuint index, const GLdouble *v)
-{
-    d_4_1_Core->f.VertexAttribL3dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribL2dv(GLuint index, const GLdouble *v)
-{
-    d_4_1_Core->f.VertexAttribL2dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribL1dv(GLuint index, const GLdouble *v)
-{
-    d_4_1_Core->f.VertexAttribL1dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribL4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_4_1_Core->f.VertexAttribL4d(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribL3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
-{
-    d_4_1_Core->f.VertexAttribL3d(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribL2d(GLuint index, GLdouble x, GLdouble y)
-{
-    d_4_1_Core->f.VertexAttribL2d(index, x, y);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribL1d(GLuint index, GLdouble x)
-{
-    d_4_1_Core->f.VertexAttribL1d(index, x);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-{
-    d_4_1_Core->f.GetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glValidateProgramPipeline(GLuint pipeline)
-{
-    d_4_1_Core->f.ValidateProgramPipeline(pipeline);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniformMatrix4x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4x3dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniformMatrix3x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3x4dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniformMatrix4x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4x2dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniformMatrix2x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2x4dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniformMatrix3x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3x2dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniformMatrix2x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2x3dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniformMatrix4x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4x3fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniformMatrix3x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3x4fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniformMatrix4x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4x2fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniformMatrix2x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2x4fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniformMatrix3x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3x2fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniformMatrix2x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2x3fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniformMatrix4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniformMatrix3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniformMatrix2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniformMatrix4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniformMatrix3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniformMatrix2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform4uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
-{
-    d_4_1_Core->f.ProgramUniform4uiv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
-{
-    d_4_1_Core->f.ProgramUniform4ui(program, location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform4dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniform4dv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform4d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3)
-{
-    d_4_1_Core->f.ProgramUniform4d(program, location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform4fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniform4fv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
-{
-    d_4_1_Core->f.ProgramUniform4f(program, location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform4iv(GLuint program, GLint location, GLsizei count, const GLint *value)
-{
-    d_4_1_Core->f.ProgramUniform4iv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
-{
-    d_4_1_Core->f.ProgramUniform4i(program, location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform3uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
-{
-    d_4_1_Core->f.ProgramUniform3uiv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2)
-{
-    d_4_1_Core->f.ProgramUniform3ui(program, location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform3dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniform3dv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform3d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2)
-{
-    d_4_1_Core->f.ProgramUniform3d(program, location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform3fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniform3fv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
-{
-    d_4_1_Core->f.ProgramUniform3f(program, location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform3iv(GLuint program, GLint location, GLsizei count, const GLint *value)
-{
-    d_4_1_Core->f.ProgramUniform3iv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2)
-{
-    d_4_1_Core->f.ProgramUniform3i(program, location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform2uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
-{
-    d_4_1_Core->f.ProgramUniform2uiv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1)
-{
-    d_4_1_Core->f.ProgramUniform2ui(program, location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform2dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniform2dv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform2d(GLuint program, GLint location, GLdouble v0, GLdouble v1)
-{
-    d_4_1_Core->f.ProgramUniform2d(program, location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform2fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniform2fv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1)
-{
-    d_4_1_Core->f.ProgramUniform2f(program, location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform2iv(GLuint program, GLint location, GLsizei count, const GLint *value)
-{
-    d_4_1_Core->f.ProgramUniform2iv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1)
-{
-    d_4_1_Core->f.ProgramUniform2i(program, location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform1uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
-{
-    d_4_1_Core->f.ProgramUniform1uiv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform1ui(GLuint program, GLint location, GLuint v0)
-{
-    d_4_1_Core->f.ProgramUniform1ui(program, location, v0);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform1dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniform1dv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform1d(GLuint program, GLint location, GLdouble v0)
-{
-    d_4_1_Core->f.ProgramUniform1d(program, location, v0);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform1fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniform1fv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform1f(GLuint program, GLint location, GLfloat v0)
-{
-    d_4_1_Core->f.ProgramUniform1f(program, location, v0);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform1iv(GLuint program, GLint location, GLsizei count, const GLint *value)
-{
-    d_4_1_Core->f.ProgramUniform1iv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform1i(GLuint program, GLint location, GLint v0)
-{
-    d_4_1_Core->f.ProgramUniform1i(program, location, v0);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params)
-{
-    d_4_1_Core->f.GetProgramPipelineiv(pipeline, pname, params);
-}
-
-inline GLboolean QOpenGLFunctions_4_5_Compatibility::glIsProgramPipeline(GLuint pipeline)
-{
-    return d_4_1_Core->f.IsProgramPipeline(pipeline);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGenProgramPipelines(GLsizei n, GLuint *pipelines)
-{
-    d_4_1_Core->f.GenProgramPipelines(n, pipelines);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glDeleteProgramPipelines(GLsizei n, const GLuint *pipelines)
-{
-    d_4_1_Core->f.DeleteProgramPipelines(n, pipelines);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glBindProgramPipeline(GLuint pipeline)
-{
-    d_4_1_Core->f.BindProgramPipeline(pipeline);
-}
-
-inline GLuint QOpenGLFunctions_4_5_Compatibility::glCreateShaderProgramv(GLenum type, GLsizei count, const GLchar *const *strings)
-{
-    return d_4_1_Core->f.CreateShaderProgramv(type, count, strings);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glActiveShaderProgram(GLuint pipeline, GLuint program)
-{
-    d_4_1_Core->f.ActiveShaderProgram(pipeline, program);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program)
-{
-    d_4_1_Core->f.UseProgramStages(pipeline, stages, program);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProgramParameteri(GLuint program, GLenum pname, GLint value)
-{
-    d_4_1_Core->f.ProgramParameteri(program, pname, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glProgramBinary(GLuint program, GLenum binaryFormat, const void *binary, GLsizei length)
-{
-    d_4_1_Core->f.ProgramBinary(program, binaryFormat, binary, length);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, void *binary)
-{
-    d_4_1_Core->f.GetProgramBinary(program, bufSize, length, binaryFormat, binary);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glClearDepthf(GLfloat dd)
-{
-    d_4_1_Core->f.ClearDepthf(dd);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glDepthRangef(GLfloat n, GLfloat f)
-{
-    d_4_1_Core->f.DepthRangef(n, f);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision)
-{
-    d_4_1_Core->f.GetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glShaderBinary(GLsizei count, const GLuint *shaders, GLenum binaryformat, const void *binary, GLsizei length)
-{
-    d_4_1_Core->f.ShaderBinary(count, shaders, binaryformat, binary, length);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glReleaseShaderCompiler()
-{
-    d_4_1_Core->f.ReleaseShaderCompiler();
-}
-
-
-// OpenGL 4.2 core functions
-inline void QOpenGLFunctions_4_5_Compatibility::glDrawTransformFeedbackStreamInstanced(GLenum mode, GLuint id, GLuint stream, GLsizei instancecount)
-{
-    d_4_2_Core->f.DrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glDrawTransformFeedbackInstanced(GLenum mode, GLuint id, GLsizei instancecount)
-{
-    d_4_2_Core->f.DrawTransformFeedbackInstanced(mode, id, instancecount);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
-{
-    d_4_2_Core->f.TexStorage3D(target, levels, internalformat, width, height, depth);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    d_4_2_Core->f.TexStorage2D(target, levels, internalformat, width, height);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexStorage1D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width)
-{
-    d_4_2_Core->f.TexStorage1D(target, levels, internalformat, width);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMemoryBarrier(GLbitfield barriers)
-{
-    d_4_2_Core->f.MemoryBarrier(barriers);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glBindImageTexture(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format)
-{
-    d_4_2_Core->f.BindImageTexture(unit, texture, level, layered, layer, access, format);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetActiveAtomicCounterBufferiv(GLuint program, GLuint bufferIndex, GLenum pname, GLint *params)
-{
-    d_4_2_Core->f.GetActiveAtomicCounterBufferiv(program, bufferIndex, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params)
-{
-    d_4_2_Core->f.GetInternalformativ(target, internalformat, pname, bufSize, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glDrawElementsInstancedBaseVertexBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance)
-{
-    d_4_2_Core->f.DrawElementsInstancedBaseVertexBaseInstance(mode, count, type, indices, instancecount, basevertex, baseinstance);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glDrawElementsInstancedBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLuint baseinstance)
-{
-    d_4_2_Core->f.DrawElementsInstancedBaseInstance(mode, count, type, indices, instancecount, baseinstance);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glDrawArraysInstancedBaseInstance(GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance)
-{
-    d_4_2_Core->f.DrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);
-}
-
-
-// OpenGL 4.3 core functions
-inline void QOpenGLFunctions_4_5_Compatibility::glGetObjectPtrLabel(const void *ptr, GLsizei bufSize, GLsizei *length, GLchar *label)
-{
-    d_4_3_Core->f.GetObjectPtrLabel(ptr, bufSize, length, label);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glObjectPtrLabel(const void *ptr, GLsizei length, const GLchar *label)
-{
-    d_4_3_Core->f.ObjectPtrLabel(ptr, length, label);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetObjectLabel(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label)
-{
-    d_4_3_Core->f.GetObjectLabel(identifier, name, bufSize, length, label);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glObjectLabel(GLenum identifier, GLuint name, GLsizei length, const GLchar *label)
-{
-    d_4_3_Core->f.ObjectLabel(identifier, name, length, label);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glPopDebugGroup()
-{
-    d_4_3_Core->f.PopDebugGroup();
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glPushDebugGroup(GLenum source, GLuint id, GLsizei length, const GLchar *message)
-{
-    d_4_3_Core->f.PushDebugGroup(source, id, length, message);
-}
-
-inline GLuint QOpenGLFunctions_4_5_Compatibility::glGetDebugMessageLog(GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog)
-{
-    return d_4_3_Core->f.GetDebugMessageLog(count, bufSize, sources, types, ids, severities, lengths, messageLog);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glDebugMessageCallback(GLDEBUGPROC callback, const void *userParam)
-{
-    d_4_3_Core->f.DebugMessageCallback(callback, userParam);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glDebugMessageInsert(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf)
-{
-    d_4_3_Core->f.DebugMessageInsert(source, type, id, severity, length, buf);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glDebugMessageControl(GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled)
-{
-    d_4_3_Core->f.DebugMessageControl(source, type, severity, count, ids, enabled);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexBindingDivisor(GLuint bindingindex, GLuint divisor)
-{
-    d_4_3_Core->f.VertexBindingDivisor(bindingindex, divisor);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribBinding(GLuint attribindex, GLuint bindingindex)
-{
-    d_4_3_Core->f.VertexAttribBinding(attribindex, bindingindex);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribLFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
-{
-    d_4_3_Core->f.VertexAttribLFormat(attribindex, size, type, relativeoffset);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribIFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
-{
-    d_4_3_Core->f.VertexAttribIFormat(attribindex, size, type, relativeoffset);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribFormat(GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset)
-{
-    d_4_3_Core->f.VertexAttribFormat(attribindex, size, type, normalized, relativeoffset);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glBindVertexBuffer(GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride)
-{
-    d_4_3_Core->f.BindVertexBuffer(bindingindex, buffer, offset, stride);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTextureView(GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers)
-{
-    d_4_3_Core->f.TextureView(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexStorage3DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
-{
-    d_4_3_Core->f.TexStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexStorage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
-{
-    d_4_3_Core->f.TexStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexBufferRange(GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size)
-{
-    d_4_3_Core->f.TexBufferRange(target, internalformat, buffer, offset, size);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glShaderStorageBlockBinding(GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding)
-{
-    d_4_3_Core->f.ShaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding);
-}
-
-inline GLint QOpenGLFunctions_4_5_Compatibility::glGetProgramResourceLocationIndex(GLuint program, GLenum programInterface, const GLchar *name)
-{
-    return d_4_3_Core->f.GetProgramResourceLocationIndex(program, programInterface, name);
-}
-
-inline GLint QOpenGLFunctions_4_5_Compatibility::glGetProgramResourceLocation(GLuint program, GLenum programInterface, const GLchar *name)
-{
-    return d_4_3_Core->f.GetProgramResourceLocation(program, programInterface, name);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetProgramResourceiv(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params)
-{
-    d_4_3_Core->f.GetProgramResourceiv(program, programInterface, index, propCount, props, bufSize, length, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetProgramResourceName(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name)
-{
-    d_4_3_Core->f.GetProgramResourceName(program, programInterface, index, bufSize, length, name);
-}
-
-inline GLuint QOpenGLFunctions_4_5_Compatibility::glGetProgramResourceIndex(GLuint program, GLenum programInterface, const GLchar *name)
-{
-    return d_4_3_Core->f.GetProgramResourceIndex(program, programInterface, name);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetProgramInterfaceiv(GLuint program, GLenum programInterface, GLenum pname, GLint *params)
-{
-    d_4_3_Core->f.GetProgramInterfaceiv(program, programInterface, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMultiDrawElementsIndirect(GLenum mode, GLenum type, const void *indirect, GLsizei drawcount, GLsizei stride)
-{
-    d_4_3_Core->f.MultiDrawElementsIndirect(mode, type, indirect, drawcount, stride);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMultiDrawArraysIndirect(GLenum mode, const void *indirect, GLsizei drawcount, GLsizei stride)
-{
-    d_4_3_Core->f.MultiDrawArraysIndirect(mode, indirect, drawcount, stride);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glInvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_4_3_Core->f.InvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glInvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments)
-{
-    d_4_3_Core->f.InvalidateFramebuffer(target, numAttachments, attachments);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glInvalidateBufferData(GLuint buffer)
-{
-    d_4_3_Core->f.InvalidateBufferData(buffer);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glInvalidateBufferSubData(GLuint buffer, GLintptr offset, GLsizeiptr length)
-{
-    d_4_3_Core->f.InvalidateBufferSubData(buffer, offset, length);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glInvalidateTexImage(GLuint texture, GLint level)
-{
-    d_4_3_Core->f.InvalidateTexImage(texture, level);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glInvalidateTexSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth)
-{
-    d_4_3_Core->f.InvalidateTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetInternalformati64v(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint64 *params)
-{
-    d_4_3_Core->f.GetInternalformati64v(target, internalformat, pname, bufSize, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetFramebufferParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_4_3_Core->f.GetFramebufferParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glFramebufferParameteri(GLenum target, GLenum pname, GLint param)
-{
-    d_4_3_Core->f.FramebufferParameteri(target, pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glCopyImageSubData(GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth)
-{
-    d_4_3_Core->f.CopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glDispatchComputeIndirect(GLintptr indirect)
-{
-    d_4_3_Core->f.DispatchComputeIndirect(indirect);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glDispatchCompute(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z)
-{
-    d_4_3_Core->f.DispatchCompute(num_groups_x, num_groups_y, num_groups_z);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glClearBufferSubData(GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data)
-{
-    d_4_3_Core->f.ClearBufferSubData(target, internalformat, offset, size, format, type, data);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glClearBufferData(GLenum target, GLenum internalformat, GLenum format, GLenum type, const void *data)
-{
-    d_4_3_Core->f.ClearBufferData(target, internalformat, format, type, data);
-}
-
-
-// OpenGL 4.4 core functions
-inline void QOpenGLFunctions_4_5_Compatibility::glBindVertexBuffers(GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides)
-{
-    d_4_4_Core->f.BindVertexBuffers(first, count, buffers, offsets, strides);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glBindImageTextures(GLuint first, GLsizei count, const GLuint *textures)
-{
-    d_4_4_Core->f.BindImageTextures(first, count, textures);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glBindSamplers(GLuint first, GLsizei count, const GLuint *samplers)
-{
-    d_4_4_Core->f.BindSamplers(first, count, samplers);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glBindTextures(GLuint first, GLsizei count, const GLuint *textures)
-{
-    d_4_4_Core->f.BindTextures(first, count, textures);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glBindBuffersRange(GLenum target, GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizeiptr *sizes)
-{
-    d_4_4_Core->f.BindBuffersRange(target, first, count, buffers, offsets, sizes);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glBindBuffersBase(GLenum target, GLuint first, GLsizei count, const GLuint *buffers)
-{
-    d_4_4_Core->f.BindBuffersBase(target, first, count, buffers);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glClearTexSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *data)
-{
-    d_4_4_Core->f.ClearTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glClearTexImage(GLuint texture, GLint level, GLenum format, GLenum type, const void *data)
-{
-    d_4_4_Core->f.ClearTexImage(texture, level, format, type, data);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glBufferStorage(GLenum target, GLsizeiptr size, const void *data, GLbitfield flags)
-{
-    d_4_4_Core->f.BufferStorage(target, size, data, flags);
-}
-
-
-// OpenGL 4.5 core functions
-inline void QOpenGLFunctions_4_5_Compatibility::glTextureBarrier()
-{
-    d_4_5_Core->f.TextureBarrier();
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glReadnPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data)
-{
-    d_4_5_Core->f.ReadnPixels(x, y, width, height, format, type, bufSize, data);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetnUniformuiv(GLuint program, GLint location, GLsizei bufSize, GLuint *params)
-{
-    d_4_5_Core->f.GetnUniformuiv(program, location, bufSize, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetnUniformiv(GLuint program, GLint location, GLsizei bufSize, GLint *params)
-{
-    d_4_5_Core->f.GetnUniformiv(program, location, bufSize, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetnUniformfv(GLuint program, GLint location, GLsizei bufSize, GLfloat *params)
-{
-    d_4_5_Core->f.GetnUniformfv(program, location, bufSize, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetnUniformdv(GLuint program, GLint location, GLsizei bufSize, GLdouble *params)
-{
-    d_4_5_Core->f.GetnUniformdv(program, location, bufSize, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetnTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, void *pixels)
-{
-    d_4_5_Core->f.GetnTexImage(target, level, format, type, bufSize, pixels);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetnCompressedTexImage(GLenum target, GLint lod, GLsizei bufSize, void *pixels)
-{
-    d_4_5_Core->f.GetnCompressedTexImage(target, lod, bufSize, pixels);
-}
-
-inline GLenum QOpenGLFunctions_4_5_Compatibility::glGetGraphicsResetStatus()
-{
-    return d_4_5_Core->f.GetGraphicsResetStatus();
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetCompressedTextureSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei bufSize, void *pixels)
-{
-    d_4_5_Core->f.GetCompressedTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, bufSize, pixels);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetTextureSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLsizei bufSize, void *pixels)
-{
-    d_4_5_Core->f.GetTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bufSize, pixels);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMemoryBarrierByRegion(GLbitfield barriers)
-{
-    d_4_5_Core->f.MemoryBarrierByRegion(barriers);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glCreateQueries(GLenum target, GLsizei n, GLuint *ids)
-{
-    d_4_5_Core->f.CreateQueries(target, n, ids);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glCreateProgramPipelines(GLsizei n, GLuint *pipelines)
-{
-    d_4_5_Core->f.CreateProgramPipelines(n, pipelines);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glCreateSamplers(GLsizei n, GLuint *samplers)
-{
-    d_4_5_Core->f.CreateSamplers(n, samplers);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetVertexArrayIndexed64iv(GLuint vaobj, GLuint index, GLenum pname, GLint64 *param)
-{
-    d_4_5_Core->f.GetVertexArrayIndexed64iv(vaobj, index, pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetVertexArrayIndexediv(GLuint vaobj, GLuint index, GLenum pname, GLint *param)
-{
-    d_4_5_Core->f.GetVertexArrayIndexediv(vaobj, index, pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetVertexArrayiv(GLuint vaobj, GLenum pname, GLint *param)
-{
-    d_4_5_Core->f.GetVertexArrayiv(vaobj, pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexArrayBindingDivisor(GLuint vaobj, GLuint bindingindex, GLuint divisor)
-{
-    d_4_5_Core->f.VertexArrayBindingDivisor(vaobj, bindingindex, divisor);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexArrayAttribLFormat(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
-{
-    d_4_5_Core->f.VertexArrayAttribLFormat(vaobj, attribindex, size, type, relativeoffset);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexArrayAttribIFormat(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
-{
-    d_4_5_Core->f.VertexArrayAttribIFormat(vaobj, attribindex, size, type, relativeoffset);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexArrayAttribFormat(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset)
-{
-    d_4_5_Core->f.VertexArrayAttribFormat(vaobj, attribindex, size, type, normalized, relativeoffset);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexArrayAttribBinding(GLuint vaobj, GLuint attribindex, GLuint bindingindex)
-{
-    d_4_5_Core->f.VertexArrayAttribBinding(vaobj, attribindex, bindingindex);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexArrayVertexBuffers(GLuint vaobj, GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides)
-{
-    d_4_5_Core->f.VertexArrayVertexBuffers(vaobj, first, count, buffers, offsets, strides);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexArrayVertexBuffer(GLuint vaobj, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride)
-{
-    d_4_5_Core->f.VertexArrayVertexBuffer(vaobj, bindingindex, buffer, offset, stride);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexArrayElementBuffer(GLuint vaobj, GLuint buffer)
-{
-    d_4_5_Core->f.VertexArrayElementBuffer(vaobj, buffer);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glEnableVertexArrayAttrib(GLuint vaobj, GLuint index)
-{
-    d_4_5_Core->f.EnableVertexArrayAttrib(vaobj, index);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glDisableVertexArrayAttrib(GLuint vaobj, GLuint index)
-{
-    d_4_5_Core->f.DisableVertexArrayAttrib(vaobj, index);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glCreateVertexArrays(GLsizei n, GLuint *arrays)
-{
-    d_4_5_Core->f.CreateVertexArrays(n, arrays);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetTextureParameteriv(GLuint texture, GLenum pname, GLint *params)
-{
-    d_4_5_Core->f.GetTextureParameteriv(texture, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetTextureParameterIuiv(GLuint texture, GLenum pname, GLuint *params)
-{
-    d_4_5_Core->f.GetTextureParameterIuiv(texture, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetTextureParameterIiv(GLuint texture, GLenum pname, GLint *params)
-{
-    d_4_5_Core->f.GetTextureParameterIiv(texture, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetTextureParameterfv(GLuint texture, GLenum pname, GLfloat *params)
-{
-    d_4_5_Core->f.GetTextureParameterfv(texture, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetTextureLevelParameteriv(GLuint texture, GLint level, GLenum pname, GLint *params)
-{
-    d_4_5_Core->f.GetTextureLevelParameteriv(texture, level, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetTextureLevelParameterfv(GLuint texture, GLint level, GLenum pname, GLfloat *params)
-{
-    d_4_5_Core->f.GetTextureLevelParameterfv(texture, level, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetCompressedTextureImage(GLuint texture, GLint level, GLsizei bufSize, void *pixels)
-{
-    d_4_5_Core->f.GetCompressedTextureImage(texture, level, bufSize, pixels);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetTextureImage(GLuint texture, GLint level, GLenum format, GLenum type, GLsizei bufSize, void *pixels)
-{
-    d_4_5_Core->f.GetTextureImage(texture, level, format, type, bufSize, pixels);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glBindTextureUnit(GLuint unit, GLuint texture)
-{
-    d_4_5_Core->f.BindTextureUnit(unit, texture);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGenerateTextureMipmap(GLuint texture)
-{
-    d_4_5_Core->f.GenerateTextureMipmap(texture);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTextureParameteriv(GLuint texture, GLenum pname, const GLint *param)
-{
-    d_4_5_Core->f.TextureParameteriv(texture, pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTextureParameterIuiv(GLuint texture, GLenum pname, const GLuint *params)
-{
-    d_4_5_Core->f.TextureParameterIuiv(texture, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTextureParameterIiv(GLuint texture, GLenum pname, const GLint *params)
-{
-    d_4_5_Core->f.TextureParameterIiv(texture, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTextureParameteri(GLuint texture, GLenum pname, GLint param)
-{
-    d_4_5_Core->f.TextureParameteri(texture, pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTextureParameterfv(GLuint texture, GLenum pname, const GLfloat *param)
-{
-    d_4_5_Core->f.TextureParameterfv(texture, pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTextureParameterf(GLuint texture, GLenum pname, GLfloat param)
-{
-    d_4_5_Core->f.TextureParameterf(texture, pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glCopyTextureSubImage3D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_4_5_Core->f.CopyTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glCopyTextureSubImage2D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_4_5_Core->f.CopyTextureSubImage2D(texture, level, xoffset, yoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glCopyTextureSubImage1D(GLuint texture, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
-{
-    d_4_5_Core->f.CopyTextureSubImage1D(texture, level, xoffset, x, y, width);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glCompressedTextureSubImage3D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data)
-{
-    d_4_5_Core->f.CompressedTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glCompressedTextureSubImage2D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data)
-{
-    d_4_5_Core->f.CompressedTextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glCompressedTextureSubImage1D(GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data)
-{
-    d_4_5_Core->f.CompressedTextureSubImage1D(texture, level, xoffset, width, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTextureSubImage3D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels)
-{
-    d_4_5_Core->f.TextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTextureSubImage2D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)
-{
-    d_4_5_Core->f.TextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTextureSubImage1D(GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels)
-{
-    d_4_5_Core->f.TextureSubImage1D(texture, level, xoffset, width, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTextureStorage3DMultisample(GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
-{
-    d_4_5_Core->f.TextureStorage3DMultisample(texture, samples, internalformat, width, height, depth, fixedsamplelocations);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTextureStorage2DMultisample(GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
-{
-    d_4_5_Core->f.TextureStorage2DMultisample(texture, samples, internalformat, width, height, fixedsamplelocations);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTextureStorage3D(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
-{
-    d_4_5_Core->f.TextureStorage3D(texture, levels, internalformat, width, height, depth);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTextureStorage2D(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    d_4_5_Core->f.TextureStorage2D(texture, levels, internalformat, width, height);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTextureStorage1D(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width)
-{
-    d_4_5_Core->f.TextureStorage1D(texture, levels, internalformat, width);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTextureBufferRange(GLuint texture, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizei size)
-{
-    d_4_5_Core->f.TextureBufferRange(texture, internalformat, buffer, offset, size);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTextureBuffer(GLuint texture, GLenum internalformat, GLuint buffer)
-{
-    d_4_5_Core->f.TextureBuffer(texture, internalformat, buffer);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glCreateTextures(GLenum target, GLsizei n, GLuint *textures)
-{
-    d_4_5_Core->f.CreateTextures(target, n, textures);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetNamedRenderbufferParameteriv(GLuint renderbuffer, GLenum pname, GLint *params)
-{
-    d_4_5_Core->f.GetNamedRenderbufferParameteriv(renderbuffer, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glNamedRenderbufferStorageMultisample(GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    d_4_5_Core->f.NamedRenderbufferStorageMultisample(renderbuffer, samples, internalformat, width, height);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glNamedRenderbufferStorage(GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    d_4_5_Core->f.NamedRenderbufferStorage(renderbuffer, internalformat, width, height);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glCreateRenderbuffers(GLsizei n, GLuint *renderbuffers)
-{
-    d_4_5_Core->f.CreateRenderbuffers(n, renderbuffers);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetNamedFramebufferAttachmentParameteriv(GLuint framebuffer, GLenum attachment, GLenum pname, GLint *params)
-{
-    d_4_5_Core->f.GetNamedFramebufferAttachmentParameteriv(framebuffer, attachment, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetNamedFramebufferParameteriv(GLuint framebuffer, GLenum pname, GLint *param)
-{
-    d_4_5_Core->f.GetNamedFramebufferParameteriv(framebuffer, pname, param);
-}
-
-inline GLenum QOpenGLFunctions_4_5_Compatibility::glCheckNamedFramebufferStatus(GLuint framebuffer, GLenum target)
-{
-    return d_4_5_Core->f.CheckNamedFramebufferStatus(framebuffer, target);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glBlitNamedFramebuffer(GLuint readFramebuffer, GLuint drawFramebuffer, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
-{
-    d_4_5_Core->f.BlitNamedFramebuffer(readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glClearNamedFramebufferfi(GLuint framebuffer, GLenum buffer, GLfloat depth, GLint stencil)
-{
-    d_4_5_Core->f.ClearNamedFramebufferfi(framebuffer, buffer, depth, stencil);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glClearNamedFramebufferfv(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLfloat *value)
-{
-    d_4_5_Core->f.ClearNamedFramebufferfv(framebuffer, buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glClearNamedFramebufferuiv(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLuint *value)
-{
-    d_4_5_Core->f.ClearNamedFramebufferuiv(framebuffer, buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glClearNamedFramebufferiv(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLint *value)
-{
-    d_4_5_Core->f.ClearNamedFramebufferiv(framebuffer, buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glInvalidateNamedFramebufferSubData(GLuint framebuffer, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_4_5_Core->f.InvalidateNamedFramebufferSubData(framebuffer, numAttachments, attachments, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glInvalidateNamedFramebufferData(GLuint framebuffer, GLsizei numAttachments, const GLenum *attachments)
-{
-    d_4_5_Core->f.InvalidateNamedFramebufferData(framebuffer, numAttachments, attachments);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glNamedFramebufferReadBuffer(GLuint framebuffer, GLenum src)
-{
-    d_4_5_Core->f.NamedFramebufferReadBuffer(framebuffer, src);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glNamedFramebufferDrawBuffers(GLuint framebuffer, GLsizei n, const GLenum *bufs)
-{
-    d_4_5_Core->f.NamedFramebufferDrawBuffers(framebuffer, n, bufs);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glNamedFramebufferDrawBuffer(GLuint framebuffer, GLenum buf)
-{
-    d_4_5_Core->f.NamedFramebufferDrawBuffer(framebuffer, buf);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glNamedFramebufferTextureLayer(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer)
-{
-    d_4_5_Core->f.NamedFramebufferTextureLayer(framebuffer, attachment, texture, level, layer);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glNamedFramebufferTexture(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level)
-{
-    d_4_5_Core->f.NamedFramebufferTexture(framebuffer, attachment, texture, level);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glNamedFramebufferParameteri(GLuint framebuffer, GLenum pname, GLint param)
-{
-    d_4_5_Core->f.NamedFramebufferParameteri(framebuffer, pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glNamedFramebufferRenderbuffer(GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
-{
-    d_4_5_Core->f.NamedFramebufferRenderbuffer(framebuffer, attachment, renderbuffertarget, renderbuffer);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glCreateFramebuffers(GLsizei n, GLuint *framebuffers)
-{
-    d_4_5_Core->f.CreateFramebuffers(n, framebuffers);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetNamedBufferSubData(GLuint buffer, GLintptr offset, GLsizei size, void *data)
-{
-    d_4_5_Core->f.GetNamedBufferSubData(buffer, offset, size, data);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetNamedBufferPointerv(GLuint buffer, GLenum pname, void * *params)
-{
-    d_4_5_Core->f.GetNamedBufferPointerv(buffer, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetNamedBufferParameteri64v(GLuint buffer, GLenum pname, GLint64 *params)
-{
-    d_4_5_Core->f.GetNamedBufferParameteri64v(buffer, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetNamedBufferParameteriv(GLuint buffer, GLenum pname, GLint *params)
-{
-    d_4_5_Core->f.GetNamedBufferParameteriv(buffer, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glFlushMappedNamedBufferRange(GLuint buffer, GLintptr offset, GLsizei length)
-{
-    d_4_5_Core->f.FlushMappedNamedBufferRange(buffer, offset, length);
-}
-
-inline GLboolean QOpenGLFunctions_4_5_Compatibility::glUnmapNamedBuffer(GLuint buffer)
-{
-    return d_4_5_Core->f.UnmapNamedBuffer(buffer);
-}
-
-inline void * QOpenGLFunctions_4_5_Compatibility::glMapNamedBufferRange(GLuint buffer, GLintptr offset, GLsizei length, GLbitfield access)
-{
-    return d_4_5_Core->f.MapNamedBufferRange(buffer, offset, length, access);
-}
-
-inline void * QOpenGLFunctions_4_5_Compatibility::glMapNamedBuffer(GLuint buffer, GLenum access)
-{
-    return d_4_5_Core->f.MapNamedBuffer(buffer, access);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glClearNamedBufferSubData(GLuint buffer, GLenum internalformat, GLintptr offset, GLsizei size, GLenum format, GLenum type, const void *data)
-{
-    d_4_5_Core->f.ClearNamedBufferSubData(buffer, internalformat, offset, size, format, type, data);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glClearNamedBufferData(GLuint buffer, GLenum internalformat, GLenum format, GLenum type, const void *data)
-{
-    d_4_5_Core->f.ClearNamedBufferData(buffer, internalformat, format, type, data);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glCopyNamedBufferSubData(GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizei size)
-{
-    d_4_5_Core->f.CopyNamedBufferSubData(readBuffer, writeBuffer, readOffset, writeOffset, size);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glNamedBufferSubData(GLuint buffer, GLintptr offset, GLsizei size, const void *data)
-{
-    d_4_5_Core->f.NamedBufferSubData(buffer, offset, size, data);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glNamedBufferData(GLuint buffer, GLsizei size, const void *data, GLenum usage)
-{
-    d_4_5_Core->f.NamedBufferData(buffer, size, data, usage);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glNamedBufferStorage(GLuint buffer, GLsizei size, const void *data, GLbitfield flags)
-{
-    d_4_5_Core->f.NamedBufferStorage(buffer, size, data, flags);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glCreateBuffers(GLsizei n, GLuint *buffers)
-{
-    d_4_5_Core->f.CreateBuffers(n, buffers);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetTransformFeedbacki64_v(GLuint xfb, GLenum pname, GLuint index, GLint64 *param)
-{
-    d_4_5_Core->f.GetTransformFeedbacki64_v(xfb, pname, index, param);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetTransformFeedbacki_v(GLuint xfb, GLenum pname, GLuint index, GLint *param)
-{
-    d_4_5_Core->f.GetTransformFeedbacki_v(xfb, pname, index, param);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetTransformFeedbackiv(GLuint xfb, GLenum pname, GLint *param)
-{
-    d_4_5_Core->f.GetTransformFeedbackiv(xfb, pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTransformFeedbackBufferRange(GLuint xfb, GLuint index, GLuint buffer, GLintptr offset, GLsizei size)
-{
-    d_4_5_Core->f.TransformFeedbackBufferRange(xfb, index, buffer, offset, size);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTransformFeedbackBufferBase(GLuint xfb, GLuint index, GLuint buffer)
-{
-    d_4_5_Core->f.TransformFeedbackBufferBase(xfb, index, buffer);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glCreateTransformFeedbacks(GLsizei n, GLuint *ids)
-{
-    d_4_5_Core->f.CreateTransformFeedbacks(n, ids);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glClipControl(GLenum origin, GLenum depth)
-{
-    d_4_5_Core->f.ClipControl(origin, depth);
-}
-
-
-// OpenGL 1.0 deprecated functions
-inline void QOpenGLFunctions_4_5_Compatibility::glTranslatef(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Translatef(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTranslated(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Translated(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glScalef(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Scalef(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glScaled(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Scaled(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Rotatef(angle, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Rotated(angle, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glPushMatrix()
-{
-    d_1_0_Deprecated->f.PushMatrix();
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glPopMatrix()
-{
-    d_1_0_Deprecated->f.PopMatrix();
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
-{
-    d_1_0_Deprecated->f.Ortho(left, right, bottom, top, zNear, zFar);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMultMatrixd(const GLdouble *m)
-{
-    d_1_0_Deprecated->f.MultMatrixd(m);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMultMatrixf(const GLfloat *m)
-{
-    d_1_0_Deprecated->f.MultMatrixf(m);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMatrixMode(GLenum mode)
-{
-    d_1_0_Deprecated->f.MatrixMode(mode);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glLoadMatrixd(const GLdouble *m)
-{
-    d_1_0_Deprecated->f.LoadMatrixd(m);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glLoadMatrixf(const GLfloat *m)
-{
-    d_1_0_Deprecated->f.LoadMatrixf(m);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glLoadIdentity()
-{
-    d_1_0_Deprecated->f.LoadIdentity();
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
-{
-    d_1_0_Deprecated->f.Frustum(left, right, bottom, top, zNear, zFar);
-}
-
-inline GLboolean QOpenGLFunctions_4_5_Compatibility::glIsList(GLuint list)
-{
-    return d_1_0_Deprecated->f.IsList(list);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetTexGeniv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetTexGenfv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
-{
-    d_1_0_Deprecated->f.GetTexGendv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetTexEnviv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetTexEnviv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetTexEnvfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetPolygonStipple(GLubyte *mask)
-{
-    d_1_0_Deprecated->f.GetPolygonStipple(mask);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetPixelMapusv(GLenum map, GLushort *values)
-{
-    d_1_0_Deprecated->f.GetPixelMapusv(map, values);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetPixelMapuiv(GLenum map, GLuint *values)
-{
-    d_1_0_Deprecated->f.GetPixelMapuiv(map, values);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetPixelMapfv(GLenum map, GLfloat *values)
-{
-    d_1_0_Deprecated->f.GetPixelMapfv(map, values);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetMaterialiv(GLenum face, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetMaterialiv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetMaterialfv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetMapiv(GLenum target, GLenum query, GLint *v)
-{
-    d_1_0_Deprecated->f.GetMapiv(target, query, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetMapfv(GLenum target, GLenum query, GLfloat *v)
-{
-    d_1_0_Deprecated->f.GetMapfv(target, query, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetMapdv(GLenum target, GLenum query, GLdouble *v)
-{
-    d_1_0_Deprecated->f.GetMapdv(target, query, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetLightiv(GLenum light, GLenum pname, GLint *params)
-{
-    d_1_0_Deprecated->f.GetLightiv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetLightfv(GLenum light, GLenum pname, GLfloat *params)
-{
-    d_1_0_Deprecated->f.GetLightfv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetClipPlane(GLenum plane, GLdouble *equation)
-{
-    d_1_0_Deprecated->f.GetClipPlane(plane, equation);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)
-{
-    d_1_0_Deprecated->f.DrawPixels(width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
-{
-    d_1_0_Deprecated->f.CopyPixels(x, y, width, height, type);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glPixelMapusv(GLenum map, GLsizei mapsize, const GLushort *values)
-{
-    d_1_0_Deprecated->f.PixelMapusv(map, mapsize, values);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glPixelMapuiv(GLenum map, GLsizei mapsize, const GLuint *values)
-{
-    d_1_0_Deprecated->f.PixelMapuiv(map, mapsize, values);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glPixelMapfv(GLenum map, GLsizei mapsize, const GLfloat *values)
-{
-    d_1_0_Deprecated->f.PixelMapfv(map, mapsize, values);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glPixelTransferi(GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.PixelTransferi(pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glPixelTransferf(GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.PixelTransferf(pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glPixelZoom(GLfloat xfactor, GLfloat yfactor)
-{
-    d_1_0_Deprecated->f.PixelZoom(xfactor, yfactor);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glAlphaFunc(GLenum func, GLfloat ref)
-{
-    d_1_0_Deprecated->f.AlphaFunc(func, ref);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glEvalPoint2(GLint i, GLint j)
-{
-    d_1_0_Deprecated->f.EvalPoint2(i, j);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
-{
-    d_1_0_Deprecated->f.EvalMesh2(mode, i1, i2, j1, j2);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glEvalPoint1(GLint i)
-{
-    d_1_0_Deprecated->f.EvalPoint1(i);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glEvalMesh1(GLenum mode, GLint i1, GLint i2)
-{
-    d_1_0_Deprecated->f.EvalMesh1(mode, i1, i2);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glEvalCoord2fv(const GLfloat *u)
-{
-    d_1_0_Deprecated->f.EvalCoord2fv(u);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glEvalCoord2f(GLfloat u, GLfloat v)
-{
-    d_1_0_Deprecated->f.EvalCoord2f(u, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glEvalCoord2dv(const GLdouble *u)
-{
-    d_1_0_Deprecated->f.EvalCoord2dv(u);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glEvalCoord2d(GLdouble u, GLdouble v)
-{
-    d_1_0_Deprecated->f.EvalCoord2d(u, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glEvalCoord1fv(const GLfloat *u)
-{
-    d_1_0_Deprecated->f.EvalCoord1fv(u);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glEvalCoord1f(GLfloat u)
-{
-    d_1_0_Deprecated->f.EvalCoord1f(u);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glEvalCoord1dv(const GLdouble *u)
-{
-    d_1_0_Deprecated->f.EvalCoord1dv(u);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glEvalCoord1d(GLdouble u)
-{
-    d_1_0_Deprecated->f.EvalCoord1d(u);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
-{
-    d_1_0_Deprecated->f.MapGrid2f(un, u1, u2, vn, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
-{
-    d_1_0_Deprecated->f.MapGrid2d(un, u1, u2, vn, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
-{
-    d_1_0_Deprecated->f.MapGrid1f(un, u1, u2);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
-{
-    d_1_0_Deprecated->f.MapGrid1d(un, u1, u2);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
-{
-    d_1_0_Deprecated->f.Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
-{
-    d_1_0_Deprecated->f.Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
-{
-    d_1_0_Deprecated->f.Map1f(target, u1, u2, stride, order, points);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
-{
-    d_1_0_Deprecated->f.Map1d(target, u1, u2, stride, order, points);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glPushAttrib(GLbitfield mask)
-{
-    d_1_0_Deprecated->f.PushAttrib(mask);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glPopAttrib()
-{
-    d_1_0_Deprecated->f.PopAttrib();
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glAccum(GLenum op, GLfloat value)
-{
-    d_1_0_Deprecated->f.Accum(op, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glIndexMask(GLuint mask)
-{
-    d_1_0_Deprecated->f.IndexMask(mask);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glClearIndex(GLfloat c)
-{
-    d_1_0_Deprecated->f.ClearIndex(c);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Deprecated->f.ClearAccum(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glPushName(GLuint name)
-{
-    d_1_0_Deprecated->f.PushName(name);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glPopName()
-{
-    d_1_0_Deprecated->f.PopName();
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glPassThrough(GLfloat token)
-{
-    d_1_0_Deprecated->f.PassThrough(token);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glLoadName(GLuint name)
-{
-    d_1_0_Deprecated->f.LoadName(name);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glInitNames()
-{
-    d_1_0_Deprecated->f.InitNames();
-}
-
-inline GLint QOpenGLFunctions_4_5_Compatibility::glRenderMode(GLenum mode)
-{
-    return d_1_0_Deprecated->f.RenderMode(mode);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glSelectBuffer(GLsizei size, GLuint *buffer)
-{
-    d_1_0_Deprecated->f.SelectBuffer(size, buffer);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
-{
-    d_1_0_Deprecated->f.FeedbackBuffer(size, type, buffer);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexGeniv(GLenum coord, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.TexGeniv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexGeni(GLenum coord, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.TexGeni(coord, pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.TexGenfv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexGenf(GLenum coord, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.TexGenf(coord, pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
-{
-    d_1_0_Deprecated->f.TexGendv(coord, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexGend(GLenum coord, GLenum pname, GLdouble param)
-{
-    d_1_0_Deprecated->f.TexGend(coord, pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexEnviv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.TexEnviv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexEnvi(GLenum target, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.TexEnvi(target, pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.TexEnvfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexEnvf(GLenum target, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.TexEnvf(target, pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glShadeModel(GLenum mode)
-{
-    d_1_0_Deprecated->f.ShadeModel(mode);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glPolygonStipple(const GLubyte *mask)
-{
-    d_1_0_Deprecated->f.PolygonStipple(mask);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMaterialiv(GLenum face, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.Materialiv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMateriali(GLenum face, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.Materiali(face, pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.Materialfv(face, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMaterialf(GLenum face, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.Materialf(face, pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glLineStipple(GLint factor, GLushort pattern)
-{
-    d_1_0_Deprecated->f.LineStipple(factor, pattern);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glLightModeliv(GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.LightModeliv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glLightModeli(GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.LightModeli(pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glLightModelfv(GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.LightModelfv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glLightModelf(GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.LightModelf(pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glLightiv(GLenum light, GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.Lightiv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glLighti(GLenum light, GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.Lighti(light, pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glLightfv(GLenum light, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.Lightfv(light, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glLightf(GLenum light, GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.Lightf(light, pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glFogiv(GLenum pname, const GLint *params)
-{
-    d_1_0_Deprecated->f.Fogiv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glFogi(GLenum pname, GLint param)
-{
-    d_1_0_Deprecated->f.Fogi(pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glFogfv(GLenum pname, const GLfloat *params)
-{
-    d_1_0_Deprecated->f.Fogfv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glFogf(GLenum pname, GLfloat param)
-{
-    d_1_0_Deprecated->f.Fogf(pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glColorMaterial(GLenum face, GLenum mode)
-{
-    d_1_0_Deprecated->f.ColorMaterial(face, mode);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glClipPlane(GLenum plane, const GLdouble *equation)
-{
-    d_1_0_Deprecated->f.ClipPlane(plane, equation);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertex4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Vertex4sv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
-{
-    d_1_0_Deprecated->f.Vertex4s(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertex4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Vertex4iv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertex4i(GLint x, GLint y, GLint z, GLint w)
-{
-    d_1_0_Deprecated->f.Vertex4i(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertex4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Vertex4fv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    d_1_0_Deprecated->f.Vertex4f(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertex4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Vertex4dv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_1_0_Deprecated->f.Vertex4d(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertex3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Vertex3sv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertex3s(GLshort x, GLshort y, GLshort z)
-{
-    d_1_0_Deprecated->f.Vertex3s(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertex3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Vertex3iv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertex3i(GLint x, GLint y, GLint z)
-{
-    d_1_0_Deprecated->f.Vertex3i(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertex3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Vertex3fv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertex3f(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.Vertex3f(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertex3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Vertex3dv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertex3d(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.Vertex3d(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertex2sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Vertex2sv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertex2s(GLshort x, GLshort y)
-{
-    d_1_0_Deprecated->f.Vertex2s(x, y);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertex2iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Vertex2iv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertex2i(GLint x, GLint y)
-{
-    d_1_0_Deprecated->f.Vertex2i(x, y);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertex2fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Vertex2fv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertex2f(GLfloat x, GLfloat y)
-{
-    d_1_0_Deprecated->f.Vertex2f(x, y);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertex2dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Vertex2dv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertex2d(GLdouble x, GLdouble y)
-{
-    d_1_0_Deprecated->f.Vertex2d(x, y);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord4sv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
-{
-    d_1_0_Deprecated->f.TexCoord4s(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord4iv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
-{
-    d_1_0_Deprecated->f.TexCoord4i(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord4fv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
-{
-    d_1_0_Deprecated->f.TexCoord4f(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord4dv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
-{
-    d_1_0_Deprecated->f.TexCoord4d(s, t, r, q);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord3sv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord3s(GLshort s, GLshort t, GLshort r)
-{
-    d_1_0_Deprecated->f.TexCoord3s(s, t, r);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord3iv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord3i(GLint s, GLint t, GLint r)
-{
-    d_1_0_Deprecated->f.TexCoord3i(s, t, r);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord3fv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
-{
-    d_1_0_Deprecated->f.TexCoord3f(s, t, r);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord3dv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
-{
-    d_1_0_Deprecated->f.TexCoord3d(s, t, r);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord2sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord2sv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord2s(GLshort s, GLshort t)
-{
-    d_1_0_Deprecated->f.TexCoord2s(s, t);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord2iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord2iv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord2i(GLint s, GLint t)
-{
-    d_1_0_Deprecated->f.TexCoord2i(s, t);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord2fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord2fv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord2f(GLfloat s, GLfloat t)
-{
-    d_1_0_Deprecated->f.TexCoord2f(s, t);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord2dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord2dv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord2d(GLdouble s, GLdouble t)
-{
-    d_1_0_Deprecated->f.TexCoord2d(s, t);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord1sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.TexCoord1sv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord1s(GLshort s)
-{
-    d_1_0_Deprecated->f.TexCoord1s(s);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord1iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.TexCoord1iv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord1i(GLint s)
-{
-    d_1_0_Deprecated->f.TexCoord1i(s);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord1fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.TexCoord1fv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord1f(GLfloat s)
-{
-    d_1_0_Deprecated->f.TexCoord1f(s);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord1dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.TexCoord1dv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord1d(GLdouble s)
-{
-    d_1_0_Deprecated->f.TexCoord1d(s);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glRectsv(const GLshort *v1, const GLshort *v2)
-{
-    d_1_0_Deprecated->f.Rectsv(v1, v2);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
-{
-    d_1_0_Deprecated->f.Rects(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glRectiv(const GLint *v1, const GLint *v2)
-{
-    d_1_0_Deprecated->f.Rectiv(v1, v2);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
-{
-    d_1_0_Deprecated->f.Recti(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glRectfv(const GLfloat *v1, const GLfloat *v2)
-{
-    d_1_0_Deprecated->f.Rectfv(v1, v2);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
-{
-    d_1_0_Deprecated->f.Rectf(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glRectdv(const GLdouble *v1, const GLdouble *v2)
-{
-    d_1_0_Deprecated->f.Rectdv(v1, v2);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
-{
-    d_1_0_Deprecated->f.Rectd(x1, y1, x2, y2);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glRasterPos4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.RasterPos4sv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
-{
-    d_1_0_Deprecated->f.RasterPos4s(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glRasterPos4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.RasterPos4iv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
-{
-    d_1_0_Deprecated->f.RasterPos4i(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glRasterPos4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.RasterPos4fv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    d_1_0_Deprecated->f.RasterPos4f(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glRasterPos4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.RasterPos4dv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_1_0_Deprecated->f.RasterPos4d(x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glRasterPos3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.RasterPos3sv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glRasterPos3s(GLshort x, GLshort y, GLshort z)
-{
-    d_1_0_Deprecated->f.RasterPos3s(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glRasterPos3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.RasterPos3iv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glRasterPos3i(GLint x, GLint y, GLint z)
-{
-    d_1_0_Deprecated->f.RasterPos3i(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glRasterPos3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.RasterPos3fv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_0_Deprecated->f.RasterPos3f(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glRasterPos3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.RasterPos3dv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_0_Deprecated->f.RasterPos3d(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glRasterPos2sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.RasterPos2sv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glRasterPos2s(GLshort x, GLshort y)
-{
-    d_1_0_Deprecated->f.RasterPos2s(x, y);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glRasterPos2iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.RasterPos2iv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glRasterPos2i(GLint x, GLint y)
-{
-    d_1_0_Deprecated->f.RasterPos2i(x, y);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glRasterPos2fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.RasterPos2fv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glRasterPos2f(GLfloat x, GLfloat y)
-{
-    d_1_0_Deprecated->f.RasterPos2f(x, y);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glRasterPos2dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.RasterPos2dv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glRasterPos2d(GLdouble x, GLdouble y)
-{
-    d_1_0_Deprecated->f.RasterPos2d(x, y);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glNormal3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Normal3sv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glNormal3s(GLshort nx, GLshort ny, GLshort nz)
-{
-    d_1_0_Deprecated->f.Normal3s(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glNormal3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Normal3iv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glNormal3i(GLint nx, GLint ny, GLint nz)
-{
-    d_1_0_Deprecated->f.Normal3i(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glNormal3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Normal3fv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
-{
-    d_1_0_Deprecated->f.Normal3f(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glNormal3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Normal3dv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
-{
-    d_1_0_Deprecated->f.Normal3d(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glNormal3bv(const GLbyte *v)
-{
-    d_1_0_Deprecated->f.Normal3bv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
-{
-    d_1_0_Deprecated->f.Normal3b(nx, ny, nz);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glIndexsv(const GLshort *c)
-{
-    d_1_0_Deprecated->f.Indexsv(c);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glIndexs(GLshort c)
-{
-    d_1_0_Deprecated->f.Indexs(c);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glIndexiv(const GLint *c)
-{
-    d_1_0_Deprecated->f.Indexiv(c);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glIndexi(GLint c)
-{
-    d_1_0_Deprecated->f.Indexi(c);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glIndexfv(const GLfloat *c)
-{
-    d_1_0_Deprecated->f.Indexfv(c);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glIndexf(GLfloat c)
-{
-    d_1_0_Deprecated->f.Indexf(c);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glIndexdv(const GLdouble *c)
-{
-    d_1_0_Deprecated->f.Indexdv(c);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glIndexd(GLdouble c)
-{
-    d_1_0_Deprecated->f.Indexd(c);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glEnd()
-{
-    d_1_0_Deprecated->f.End();
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glEdgeFlagv(const GLboolean *flag)
-{
-    d_1_0_Deprecated->f.EdgeFlagv(flag);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glEdgeFlag(GLboolean flag)
-{
-    d_1_0_Deprecated->f.EdgeFlag(flag);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glColor4usv(const GLushort *v)
-{
-    d_1_0_Deprecated->f.Color4usv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
-{
-    d_1_0_Deprecated->f.Color4us(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glColor4uiv(const GLuint *v)
-{
-    d_1_0_Deprecated->f.Color4uiv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
-{
-    d_1_0_Deprecated->f.Color4ui(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glColor4ubv(const GLubyte *v)
-{
-    d_1_0_Deprecated->f.Color4ubv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
-{
-    d_1_0_Deprecated->f.Color4ub(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glColor4sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Color4sv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
-{
-    d_1_0_Deprecated->f.Color4s(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glColor4iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Color4iv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
-{
-    d_1_0_Deprecated->f.Color4i(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glColor4fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Color4fv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Deprecated->f.Color4f(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glColor4dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Color4dv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
-{
-    d_1_0_Deprecated->f.Color4d(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glColor4bv(const GLbyte *v)
-{
-    d_1_0_Deprecated->f.Color4bv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
-{
-    d_1_0_Deprecated->f.Color4b(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glColor3usv(const GLushort *v)
-{
-    d_1_0_Deprecated->f.Color3usv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glColor3us(GLushort red, GLushort green, GLushort blue)
-{
-    d_1_0_Deprecated->f.Color3us(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glColor3uiv(const GLuint *v)
-{
-    d_1_0_Deprecated->f.Color3uiv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glColor3ui(GLuint red, GLuint green, GLuint blue)
-{
-    d_1_0_Deprecated->f.Color3ui(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glColor3ubv(const GLubyte *v)
-{
-    d_1_0_Deprecated->f.Color3ubv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
-{
-    d_1_0_Deprecated->f.Color3ub(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glColor3sv(const GLshort *v)
-{
-    d_1_0_Deprecated->f.Color3sv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glColor3s(GLshort red, GLshort green, GLshort blue)
-{
-    d_1_0_Deprecated->f.Color3s(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glColor3iv(const GLint *v)
-{
-    d_1_0_Deprecated->f.Color3iv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glColor3i(GLint red, GLint green, GLint blue)
-{
-    d_1_0_Deprecated->f.Color3i(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glColor3fv(const GLfloat *v)
-{
-    d_1_0_Deprecated->f.Color3fv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glColor3f(GLfloat red, GLfloat green, GLfloat blue)
-{
-    d_1_0_Deprecated->f.Color3f(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glColor3dv(const GLdouble *v)
-{
-    d_1_0_Deprecated->f.Color3dv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glColor3d(GLdouble red, GLdouble green, GLdouble blue)
-{
-    d_1_0_Deprecated->f.Color3d(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glColor3bv(const GLbyte *v)
-{
-    d_1_0_Deprecated->f.Color3bv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glColor3b(GLbyte red, GLbyte green, GLbyte blue)
-{
-    d_1_0_Deprecated->f.Color3b(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
-{
-    d_1_0_Deprecated->f.Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glBegin(GLenum mode)
-{
-    d_1_0_Deprecated->f.Begin(mode);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glListBase(GLuint base)
-{
-    d_1_0_Deprecated->f.ListBase(base);
-}
-
-inline GLuint QOpenGLFunctions_4_5_Compatibility::glGenLists(GLsizei range)
-{
-    return d_1_0_Deprecated->f.GenLists(range);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glDeleteLists(GLuint list, GLsizei range)
-{
-    d_1_0_Deprecated->f.DeleteLists(list, range);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glCallLists(GLsizei n, GLenum type, const void *lists)
-{
-    d_1_0_Deprecated->f.CallLists(n, type, lists);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glCallList(GLuint list)
-{
-    d_1_0_Deprecated->f.CallList(list);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glEndList()
-{
-    d_1_0_Deprecated->f.EndList();
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glNewList(GLuint list, GLenum mode)
-{
-    d_1_0_Deprecated->f.NewList(list, mode);
-}
-
-
-// OpenGL 1.1 deprecated functions
-inline void QOpenGLFunctions_4_5_Compatibility::glPushClientAttrib(GLbitfield mask)
-{
-    d_1_1_Deprecated->f.PushClientAttrib(mask);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glPopClientAttrib()
-{
-    d_1_1_Deprecated->f.PopClientAttrib();
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glIndexubv(const GLubyte *c)
-{
-    d_1_1_Deprecated->f.Indexubv(c);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glIndexub(GLubyte c)
-{
-    d_1_1_Deprecated->f.Indexub(c);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities)
-{
-    d_1_1_Deprecated->f.PrioritizeTextures(n, textures, priorities);
-}
-
-inline GLboolean QOpenGLFunctions_4_5_Compatibility::glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
-{
-    return d_1_1_Deprecated->f.AreTexturesResident(n, textures, residences);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
-{
-    d_1_1_Deprecated->f.VertexPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
-{
-    d_1_1_Deprecated->f.TexCoordPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glNormalPointer(GLenum type, GLsizei stride, const void *pointer)
-{
-    d_1_1_Deprecated->f.NormalPointer(type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glInterleavedArrays(GLenum format, GLsizei stride, const void *pointer)
-{
-    d_1_1_Deprecated->f.InterleavedArrays(format, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetPointerv(GLenum pname, void * *params)
-{
-    d_1_1_Deprecated->f.GetPointerv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glIndexPointer(GLenum type, GLsizei stride, const void *pointer)
-{
-    d_1_1_Deprecated->f.IndexPointer(type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glEnableClientState(GLenum array)
-{
-    d_1_1_Deprecated->f.EnableClientState(array);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glEdgeFlagPointer(GLsizei stride, const void *pointer)
-{
-    d_1_1_Deprecated->f.EdgeFlagPointer(stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glDisableClientState(GLenum array)
-{
-    d_1_1_Deprecated->f.DisableClientState(array);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glColorPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
-{
-    d_1_1_Deprecated->f.ColorPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glArrayElement(GLint i)
-{
-    d_1_1_Deprecated->f.ArrayElement(i);
-}
-
-
-// OpenGL 1.2 deprecated functions
-inline void QOpenGLFunctions_4_5_Compatibility::glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void *table)
-{
-    d_1_2_Deprecated->f.ColorTable(target, internalformat, width, format, type, table);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_2_Deprecated->f.ColorTableParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_2_Deprecated->f.ColorTableParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
-{
-    d_1_2_Deprecated->f.CopyColorTable(target, internalformat, x, y, width);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetColorTable(GLenum target, GLenum format, GLenum type, void *table)
-{
-    d_1_2_Deprecated->f.GetColorTable(target, format, type, table);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetColorTableParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetColorTableParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const void *data)
-{
-    d_1_2_Deprecated->f.ColorSubTable(target, start, count, format, type, data);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
-{
-    d_1_2_Deprecated->f.CopyColorSubTable(target, start, x, y, width);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void *image)
-{
-    d_1_2_Deprecated->f.ConvolutionFilter1D(target, internalformat, width, format, type, image);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *image)
-{
-    d_1_2_Deprecated->f.ConvolutionFilter2D(target, internalformat, width, height, format, type, image);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameterf(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glConvolutionParameteri(GLenum target, GLenum pname, GLint params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameteri(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_2_Deprecated->f.ConvolutionParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
-{
-    d_1_2_Deprecated->f.CopyConvolutionFilter1D(target, internalformat, x, y, width);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_2_Deprecated->f.CopyConvolutionFilter2D(target, internalformat, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, void *image)
-{
-    d_1_2_Deprecated->f.GetConvolutionFilter(target, format, type, image);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetConvolutionParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetConvolutionParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetSeparableFilter(GLenum target, GLenum format, GLenum type, void *row, void *column, void *span)
-{
-    d_1_2_Deprecated->f.GetSeparableFilter(target, format, type, row, column, span);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *row, const void *column)
-{
-    d_1_2_Deprecated->f.SeparableFilter2D(target, internalformat, width, height, format, type, row, column);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, void *values)
-{
-    d_1_2_Deprecated->f.GetHistogram(target, reset, format, type, values);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetHistogramParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetHistogramParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, void *values)
-{
-    d_1_2_Deprecated->f.GetMinmax(target, reset, format, type, values);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_2_Deprecated->f.GetMinmaxParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_2_Deprecated->f.GetMinmaxParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
-{
-    d_1_2_Deprecated->f.Histogram(target, width, internalformat, sink);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMinmax(GLenum target, GLenum internalformat, GLboolean sink)
-{
-    d_1_2_Deprecated->f.Minmax(target, internalformat, sink);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glResetHistogram(GLenum target)
-{
-    d_1_2_Deprecated->f.ResetHistogram(target);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glResetMinmax(GLenum target)
-{
-    d_1_2_Deprecated->f.ResetMinmax(target);
-}
-
-
-// OpenGL 1.3 deprecated functions
-inline void QOpenGLFunctions_4_5_Compatibility::glMultTransposeMatrixd(const GLdouble *m)
-{
-    d_1_3_Deprecated->f.MultTransposeMatrixd(m);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMultTransposeMatrixf(const GLfloat *m)
-{
-    d_1_3_Deprecated->f.MultTransposeMatrixf(m);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glLoadTransposeMatrixd(const GLdouble *m)
-{
-    d_1_3_Deprecated->f.LoadTransposeMatrixd(m);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glLoadTransposeMatrixf(const GLfloat *m)
-{
-    d_1_3_Deprecated->f.LoadTransposeMatrixf(m);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord4sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4sv(target, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4s(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord4iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4iv(target, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4i(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord4fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4fv(target, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4f(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord4dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4dv(target, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
-{
-    d_1_3_Deprecated->f.MultiTexCoord4d(target, s, t, r, q);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord3sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3sv(target, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3s(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord3iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3iv(target, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3i(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord3fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3fv(target, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3f(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord3dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3dv(target, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r)
-{
-    d_1_3_Deprecated->f.MultiTexCoord3d(target, s, t, r);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord2sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2sv(target, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord2s(GLenum target, GLshort s, GLshort t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2s(target, s, t);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord2iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2iv(target, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord2i(GLenum target, GLint s, GLint t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2i(target, s, t);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord2fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2fv(target, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2f(target, s, t);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord2dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2dv(target, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t)
-{
-    d_1_3_Deprecated->f.MultiTexCoord2d(target, s, t);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord1sv(GLenum target, const GLshort *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1sv(target, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord1s(GLenum target, GLshort s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1s(target, s);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord1iv(GLenum target, const GLint *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1iv(target, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord1i(GLenum target, GLint s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1i(target, s);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord1fv(GLenum target, const GLfloat *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1fv(target, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord1f(GLenum target, GLfloat s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1f(target, s);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord1dv(GLenum target, const GLdouble *v)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1dv(target, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord1d(GLenum target, GLdouble s)
-{
-    d_1_3_Deprecated->f.MultiTexCoord1d(target, s);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glClientActiveTexture(GLenum texture)
-{
-    d_1_3_Deprecated->f.ClientActiveTexture(texture);
-}
-
-
-// OpenGL 1.4 deprecated functions
-inline void QOpenGLFunctions_4_5_Compatibility::glWindowPos3sv(const GLshort *v)
-{
-    d_1_4_Deprecated->f.WindowPos3sv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glWindowPos3s(GLshort x, GLshort y, GLshort z)
-{
-    d_1_4_Deprecated->f.WindowPos3s(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glWindowPos3iv(const GLint *v)
-{
-    d_1_4_Deprecated->f.WindowPos3iv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glWindowPos3i(GLint x, GLint y, GLint z)
-{
-    d_1_4_Deprecated->f.WindowPos3i(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glWindowPos3fv(const GLfloat *v)
-{
-    d_1_4_Deprecated->f.WindowPos3fv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glWindowPos3f(GLfloat x, GLfloat y, GLfloat z)
-{
-    d_1_4_Deprecated->f.WindowPos3f(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glWindowPos3dv(const GLdouble *v)
-{
-    d_1_4_Deprecated->f.WindowPos3dv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glWindowPos3d(GLdouble x, GLdouble y, GLdouble z)
-{
-    d_1_4_Deprecated->f.WindowPos3d(x, y, z);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glWindowPos2sv(const GLshort *v)
-{
-    d_1_4_Deprecated->f.WindowPos2sv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glWindowPos2s(GLshort x, GLshort y)
-{
-    d_1_4_Deprecated->f.WindowPos2s(x, y);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glWindowPos2iv(const GLint *v)
-{
-    d_1_4_Deprecated->f.WindowPos2iv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glWindowPos2i(GLint x, GLint y)
-{
-    d_1_4_Deprecated->f.WindowPos2i(x, y);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glWindowPos2fv(const GLfloat *v)
-{
-    d_1_4_Deprecated->f.WindowPos2fv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glWindowPos2f(GLfloat x, GLfloat y)
-{
-    d_1_4_Deprecated->f.WindowPos2f(x, y);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glWindowPos2dv(const GLdouble *v)
-{
-    d_1_4_Deprecated->f.WindowPos2dv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glWindowPos2d(GLdouble x, GLdouble y)
-{
-    d_1_4_Deprecated->f.WindowPos2d(x, y);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
-{
-    d_1_4_Deprecated->f.SecondaryColorPointer(size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glSecondaryColor3usv(const GLushort *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3usv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glSecondaryColor3us(GLushort red, GLushort green, GLushort blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3us(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glSecondaryColor3uiv(const GLuint *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3uiv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3ui(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glSecondaryColor3ubv(const GLubyte *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3ubv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3ub(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glSecondaryColor3sv(const GLshort *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3sv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glSecondaryColor3s(GLshort red, GLshort green, GLshort blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3s(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glSecondaryColor3iv(const GLint *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3iv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glSecondaryColor3i(GLint red, GLint green, GLint blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3i(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glSecondaryColor3fv(const GLfloat *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3fv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3f(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glSecondaryColor3dv(const GLdouble *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3dv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3d(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glSecondaryColor3bv(const GLbyte *v)
-{
-    d_1_4_Deprecated->f.SecondaryColor3bv(v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue)
-{
-    d_1_4_Deprecated->f.SecondaryColor3b(red, green, blue);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glFogCoordPointer(GLenum type, GLsizei stride, const void *pointer)
-{
-    d_1_4_Deprecated->f.FogCoordPointer(type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glFogCoorddv(const GLdouble *coord)
-{
-    d_1_4_Deprecated->f.FogCoorddv(coord);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glFogCoordd(GLdouble coord)
-{
-    d_1_4_Deprecated->f.FogCoordd(coord);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glFogCoordfv(const GLfloat *coord)
-{
-    d_1_4_Deprecated->f.FogCoordfv(coord);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glFogCoordf(GLfloat coord)
-{
-    d_1_4_Deprecated->f.FogCoordf(coord);
-}
-
-
-// OpenGL 1.5 deprecated functions
-
-// OpenGL 2.0 deprecated functions
-
-// OpenGL 2.1 deprecated functions
-
-// OpenGL 3.0 deprecated functions
-
-// OpenGL 3.1 deprecated functions
-
-// OpenGL 3.2 deprecated functions
-
-// OpenGL 3.3 deprecated functions
-inline void QOpenGLFunctions_4_5_Compatibility::glSecondaryColorP3uiv(GLenum type, const GLuint *color)
-{
-    d_3_3_Deprecated->f.SecondaryColorP3uiv(type, color);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glSecondaryColorP3ui(GLenum type, GLuint color)
-{
-    d_3_3_Deprecated->f.SecondaryColorP3ui(type, color);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glColorP4uiv(GLenum type, const GLuint *color)
-{
-    d_3_3_Deprecated->f.ColorP4uiv(type, color);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glColorP4ui(GLenum type, GLuint color)
-{
-    d_3_3_Deprecated->f.ColorP4ui(type, color);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glColorP3uiv(GLenum type, const GLuint *color)
-{
-    d_3_3_Deprecated->f.ColorP3uiv(type, color);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glColorP3ui(GLenum type, GLuint color)
-{
-    d_3_3_Deprecated->f.ColorP3ui(type, color);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glNormalP3uiv(GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.NormalP3uiv(type, coords);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glNormalP3ui(GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.NormalP3ui(type, coords);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP4uiv(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP4ui(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP3uiv(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP3ui(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP2uiv(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP2ui(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP1uiv(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.MultiTexCoordP1ui(texture, type, coords);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexCoordP4uiv(GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.TexCoordP4uiv(type, coords);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexCoordP4ui(GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.TexCoordP4ui(type, coords);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexCoordP3uiv(GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.TexCoordP3uiv(type, coords);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexCoordP3ui(GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.TexCoordP3ui(type, coords);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexCoordP2uiv(GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.TexCoordP2uiv(type, coords);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexCoordP2ui(GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.TexCoordP2ui(type, coords);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexCoordP1uiv(GLenum type, const GLuint *coords)
-{
-    d_3_3_Deprecated->f.TexCoordP1uiv(type, coords);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glTexCoordP1ui(GLenum type, GLuint coords)
-{
-    d_3_3_Deprecated->f.TexCoordP1ui(type, coords);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexP4uiv(GLenum type, const GLuint *value)
-{
-    d_3_3_Deprecated->f.VertexP4uiv(type, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexP4ui(GLenum type, GLuint value)
-{
-    d_3_3_Deprecated->f.VertexP4ui(type, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexP3uiv(GLenum type, const GLuint *value)
-{
-    d_3_3_Deprecated->f.VertexP3uiv(type, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexP3ui(GLenum type, GLuint value)
-{
-    d_3_3_Deprecated->f.VertexP3ui(type, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexP2uiv(GLenum type, const GLuint *value)
-{
-    d_3_3_Deprecated->f.VertexP2uiv(type, value);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glVertexP2ui(GLenum type, GLuint value)
-{
-    d_3_3_Deprecated->f.VertexP2ui(type, value);
-}
-
-
-// OpenGL 4.0 deprecated functions
-
-// OpenGL 4.1 deprecated functions
-
-// OpenGL 4.2 deprecated functions
-
-// OpenGL 4.3 deprecated functions
-
-// OpenGL 4.4 deprecated functions
-
-// OpenGL 4.5 deprecated functions
-inline void QOpenGLFunctions_4_5_Compatibility::glGetnMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, void *values)
-{
-    d_4_5_Deprecated->f.GetnMinmax(target, reset, format, type, bufSize, values);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetnHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, void *values)
-{
-    d_4_5_Deprecated->f.GetnHistogram(target, reset, format, type, bufSize, values);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetnSeparableFilter(GLenum target, GLenum format, GLenum type, GLsizei rowBufSize, void *row, GLsizei columnBufSize, void *column, void *span)
-{
-    d_4_5_Deprecated->f.GetnSeparableFilter(target, format, type, rowBufSize, row, columnBufSize, column, span);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetnConvolutionFilter(GLenum target, GLenum format, GLenum type, GLsizei bufSize, void *image)
-{
-    d_4_5_Deprecated->f.GetnConvolutionFilter(target, format, type, bufSize, image);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetnColorTable(GLenum target, GLenum format, GLenum type, GLsizei bufSize, void *table)
-{
-    d_4_5_Deprecated->f.GetnColorTable(target, format, type, bufSize, table);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetnPolygonStipple(GLsizei bufSize, GLubyte *pattern)
-{
-    d_4_5_Deprecated->f.GetnPolygonStipple(bufSize, pattern);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetnPixelMapusv(GLenum map, GLsizei bufSize, GLushort *values)
-{
-    d_4_5_Deprecated->f.GetnPixelMapusv(map, bufSize, values);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetnPixelMapuiv(GLenum map, GLsizei bufSize, GLuint *values)
-{
-    d_4_5_Deprecated->f.GetnPixelMapuiv(map, bufSize, values);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetnPixelMapfv(GLenum map, GLsizei bufSize, GLfloat *values)
-{
-    d_4_5_Deprecated->f.GetnPixelMapfv(map, bufSize, values);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetnMapiv(GLenum target, GLenum query, GLsizei bufSize, GLint *v)
-{
-    d_4_5_Deprecated->f.GetnMapiv(target, query, bufSize, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetnMapfv(GLenum target, GLenum query, GLsizei bufSize, GLfloat *v)
-{
-    d_4_5_Deprecated->f.GetnMapfv(target, query, bufSize, v);
-}
-
-inline void QOpenGLFunctions_4_5_Compatibility::glGetnMapdv(GLenum target, GLenum query, GLsizei bufSize, GLdouble *v)
-{
-    d_4_5_Deprecated->f.GetnMapdv(target, query, bufSize, v);
-}
-
-
-
-QT_END_NAMESPACE
-
-#ifdef Q_OS_WIN
-#pragma pop_macro("MemoryBarrier")
-#endif
-
-#endif // QT_NO_OPENGL && !QT_OPENGL_ES_2
-
-#endif
diff --git a/src/gui/opengl/qopenglfunctions_4_5_core.cpp b/src/gui/opengl/qopenglfunctions_4_5_core.cpp
deleted file mode 100644
index 9c0369e5f2..0000000000
--- a/src/gui/opengl/qopenglfunctions_4_5_core.cpp
+++ /dev/null
@@ -1,278 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2015 Klaralvdalens Datakonsult AB (KDAB)
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#include "qopenglfunctions_4_5_core.h"
-#include "qopenglcontext.h"
-
-QT_BEGIN_NAMESPACE
-
-/*!
-    \class QOpenGLFunctions_4_5_Core
-    \inmodule QtGui
-    \since 5.5
-    \wrapper
-    \brief The QOpenGLFunctions_4_5_Core class provides all functions for OpenGL 4.5 core profile.
-
-    This class is a wrapper for functions from OpenGL 4.5 core profile.
-    See reference pages on \l {http://www.opengl.org/sdk/docs/}{opengl.org}
-    for function documentation.
-
-    \sa QAbstractOpenGLFunctions
-*/
-
-QOpenGLFunctions_4_5_Core::QOpenGLFunctions_4_5_Core()
- : QAbstractOpenGLFunctions()
- , d_1_0_Core(nullptr)
- , d_1_1_Core(nullptr)
- , d_1_2_Core(nullptr)
- , d_1_3_Core(nullptr)
- , d_1_4_Core(nullptr)
- , d_1_5_Core(nullptr)
- , d_2_0_Core(nullptr)
- , d_2_1_Core(nullptr)
- , d_3_0_Core(nullptr)
- , d_3_1_Core(nullptr)
- , d_3_2_Core(nullptr)
- , d_3_3_Core(nullptr)
- , d_4_0_Core(nullptr)
- , d_4_1_Core(nullptr)
- , d_4_2_Core(nullptr)
- , d_4_3_Core(nullptr)
- , d_4_4_Core(nullptr)
- , d_4_5_Core(nullptr)
-{
-}
-
-QOpenGLFunctions_4_5_Core::~QOpenGLFunctions_4_5_Core()
-{
-    if (d_1_0_Core) {
-        d_1_0_Core->refs.deref();
-        Q_ASSERT(d_1_0_Core->refs.loadRelaxed());
-    }
-    if (d_1_1_Core) {
-        d_1_1_Core->refs.deref();
-        Q_ASSERT(d_1_1_Core->refs.loadRelaxed());
-    }
-    if (d_1_2_Core) {
-        d_1_2_Core->refs.deref();
-        Q_ASSERT(d_1_2_Core->refs.loadRelaxed());
-    }
-    if (d_1_3_Core) {
-        d_1_3_Core->refs.deref();
-        Q_ASSERT(d_1_3_Core->refs.loadRelaxed());
-    }
-    if (d_1_4_Core) {
-        d_1_4_Core->refs.deref();
-        Q_ASSERT(d_1_4_Core->refs.loadRelaxed());
-    }
-    if (d_1_5_Core) {
-        d_1_5_Core->refs.deref();
-        Q_ASSERT(d_1_5_Core->refs.loadRelaxed());
-    }
-    if (d_2_0_Core) {
-        d_2_0_Core->refs.deref();
-        Q_ASSERT(d_2_0_Core->refs.loadRelaxed());
-    }
-    if (d_2_1_Core) {
-        d_2_1_Core->refs.deref();
-        Q_ASSERT(d_2_1_Core->refs.loadRelaxed());
-    }
-    if (d_3_0_Core) {
-        d_3_0_Core->refs.deref();
-        Q_ASSERT(d_3_0_Core->refs.loadRelaxed());
-    }
-    if (d_3_1_Core) {
-        d_3_1_Core->refs.deref();
-        Q_ASSERT(d_3_1_Core->refs.loadRelaxed());
-    }
-    if (d_3_2_Core) {
-        d_3_2_Core->refs.deref();
-        Q_ASSERT(d_3_2_Core->refs.loadRelaxed());
-    }
-    if (d_3_3_Core) {
-        d_3_3_Core->refs.deref();
-        Q_ASSERT(d_3_3_Core->refs.loadRelaxed());
-    }
-    if (d_4_0_Core) {
-        d_4_0_Core->refs.deref();
-        Q_ASSERT(d_4_0_Core->refs.loadRelaxed());
-    }
-    if (d_4_1_Core) {
-        d_4_1_Core->refs.deref();
-        Q_ASSERT(d_4_1_Core->refs.loadRelaxed());
-    }
-    if (d_4_2_Core) {
-        d_4_2_Core->refs.deref();
-        Q_ASSERT(d_4_2_Core->refs.loadRelaxed());
-    }
-    if (d_4_3_Core) {
-        d_4_3_Core->refs.deref();
-        Q_ASSERT(d_4_3_Core->refs.loadRelaxed());
-    }
-    if (d_4_4_Core) {
-        d_4_4_Core->refs.deref();
-        Q_ASSERT(d_4_4_Core->refs.loadRelaxed());
-    }
-    if (d_4_5_Core) {
-        d_4_5_Core->refs.deref();
-        Q_ASSERT(d_4_5_Core->refs.loadRelaxed());
-    }
-}
-
-bool QOpenGLFunctions_4_5_Core::initializeOpenGLFunctions()
-{
-    if ( isInitialized() )
-        return true;
-
-    QOpenGLContext* context = QOpenGLContext::currentContext();
-
-    // If owned by a context object make sure it is current.
-    // Also check that current context is capable of resolving all needed functions
-    if (((owningContext() && owningContext() == context) || !owningContext())
-        && QOpenGLFunctions_4_5_Core::isContextCompatible(context))
-    {
-        // Associate with private implementation, creating if necessary
-        // Function pointers in the backends are resolved at creation time
-        QOpenGLVersionFunctionsBackend* d = nullptr;
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        d_1_3_Core = static_cast<QOpenGLFunctions_1_3_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        d_1_4_Core = static_cast<QOpenGLFunctions_1_4_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        d_1_5_Core = static_cast<QOpenGLFunctions_1_5_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        d_2_0_Core = static_cast<QOpenGLFunctions_2_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        d_2_1_Core = static_cast<QOpenGLFunctions_2_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        d_3_0_Core = static_cast<QOpenGLFunctions_3_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
-        d_3_1_Core = static_cast<QOpenGLFunctions_3_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
-        d_3_2_Core = static_cast<QOpenGLFunctions_3_2_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_CoreBackend::versionStatus());
-        d_3_3_Core = static_cast<QOpenGLFunctions_3_3_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_0_CoreBackend::versionStatus());
-        d_4_0_Core = static_cast<QOpenGLFunctions_4_0_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_1_CoreBackend::versionStatus());
-        d_4_1_Core = static_cast<QOpenGLFunctions_4_1_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_2_CoreBackend::versionStatus());
-        d_4_2_Core = static_cast<QOpenGLFunctions_4_2_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_3_CoreBackend::versionStatus());
-        d_4_3_Core = static_cast<QOpenGLFunctions_4_3_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_4_CoreBackend::versionStatus());
-        d_4_4_Core = static_cast<QOpenGLFunctions_4_4_CoreBackend*>(d);
-        d->refs.ref();
-
-        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_5_CoreBackend::versionStatus());
-        d_4_5_Core = static_cast<QOpenGLFunctions_4_5_CoreBackend*>(d);
-        d->refs.ref();
-
-        QAbstractOpenGLFunctions::initializeOpenGLFunctions();
-    }
-    return isInitialized();
-}
-
-bool QOpenGLFunctions_4_5_Core::isContextCompatible(QOpenGLContext *context)
-{
-    Q_ASSERT(context);
-    QSurfaceFormat f = context->format();
-    const QPair<int, int> v = qMakePair(f.majorVersion(), f.minorVersion());
-    if (v < qMakePair(4, 5))
-        return false;
-
-    return true;
-}
-
-QOpenGLVersionProfile QOpenGLFunctions_4_5_Core::versionProfile()
-{
-    QOpenGLVersionProfile v;
-    v.setVersion(4, 5);
-    v.setProfile(QSurfaceFormat::CoreProfile);
-    return v;
-}
-
-QT_END_NAMESPACE
diff --git a/src/gui/opengl/qopenglfunctions_4_5_core.h b/src/gui/opengl/qopenglfunctions_4_5_core.h
deleted file mode 100644
index bf872c628b..0000000000
--- a/src/gui/opengl/qopenglfunctions_4_5_core.h
+++ /dev/null
@@ -1,4072 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2015 Klaralvdalens Datakonsult AB (KDAB)
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#ifndef QOPENGLVERSIONFUNCTIONS_4_5_CORE_H
-#define QOPENGLVERSIONFUNCTIONS_4_5_CORE_H
-
-#include <QtGui/qtguiglobal.h>
-
-#if !defined(QT_NO_OPENGL) && !defined(QT_OPENGL_ES_2)
-
-#include <QtGui/QOpenGLVersionFunctions>
-#include <QtGui/qopenglcontext.h>
-
-// MemoryBarrier is a macro on some architectures on Windows
-#ifdef Q_OS_WIN
-#pragma push_macro("MemoryBarrier")
-#undef MemoryBarrier
-#endif
-
-QT_BEGIN_NAMESPACE
-
-class Q_GUI_EXPORT QOpenGLFunctions_4_5_Core : public QAbstractOpenGLFunctions
-{
-public:
-    QOpenGLFunctions_4_5_Core();
-    ~QOpenGLFunctions_4_5_Core();
-
-    bool initializeOpenGLFunctions() override;
-
-    // OpenGL 1.0 core functions
-    void glViewport(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glDepthRange(GLdouble nearVal, GLdouble farVal);
-    GLboolean glIsEnabled(GLenum cap);
-    void glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params);
-    void glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params);
-    void glGetTexParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params);
-    void glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, void *pixels);
-    const GLubyte * glGetString(GLenum name);
-    void glGetIntegerv(GLenum pname, GLint *data);
-    void glGetFloatv(GLenum pname, GLfloat *data);
-    GLenum glGetError();
-    void glGetDoublev(GLenum pname, GLdouble *data);
-    void glGetBooleanv(GLenum pname, GLboolean *data);
-    void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels);
-    void glReadBuffer(GLenum src);
-    void glPixelStorei(GLenum pname, GLint param);
-    void glPixelStoref(GLenum pname, GLfloat param);
-    void glDepthFunc(GLenum func);
-    void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass);
-    void glStencilFunc(GLenum func, GLint ref, GLuint mask);
-    void glLogicOp(GLenum opcode);
-    void glBlendFunc(GLenum sfactor, GLenum dfactor);
-    void glFlush();
-    void glFinish();
-    void glEnable(GLenum cap);
-    void glDisable(GLenum cap);
-    void glDepthMask(GLboolean flag);
-    void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
-    void glStencilMask(GLuint mask);
-    void glClearDepth(GLdouble depth);
-    void glClearStencil(GLint s);
-    void glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glClear(GLbitfield mask);
-    void glDrawBuffer(GLenum buf);
-    void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels);
-    void glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels);
-    void glTexParameteriv(GLenum target, GLenum pname, const GLint *params);
-    void glTexParameteri(GLenum target, GLenum pname, GLint param);
-    void glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-    void glTexParameterf(GLenum target, GLenum pname, GLfloat param);
-    void glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glPolygonMode(GLenum face, GLenum mode);
-    void glPointSize(GLfloat size);
-    void glLineWidth(GLfloat width);
-    void glHint(GLenum target, GLenum mode);
-    void glFrontFace(GLenum mode);
-    void glCullFace(GLenum mode);
-
-    // OpenGL 1.1 core functions
-    GLboolean glIsTexture(GLuint texture);
-    void glGenTextures(GLsizei n, GLuint *textures);
-    void glDeleteTextures(GLsizei n, const GLuint *textures);
-    void glBindTexture(GLenum target, GLuint texture);
-    void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels);
-    void glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels);
-    void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
-    void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
-    void glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
-    void glPolygonOffset(GLfloat factor, GLfloat units);
-    void glDrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices);
-    void glDrawArrays(GLenum mode, GLint first, GLsizei count);
-
-    // OpenGL 1.2 core functions
-    void glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void glBlendEquation(GLenum mode);
-    void glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels);
-    void glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels);
-    void glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices);
-
-    // OpenGL 1.3 core functions
-    void glGetCompressedTexImage(GLenum target, GLint level, void *img);
-    void glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data);
-    void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data);
-    void glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data);
-    void glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data);
-    void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data);
-    void glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data);
-    void glSampleCoverage(GLfloat value, GLboolean invert);
-    void glActiveTexture(GLenum texture);
-
-    // OpenGL 1.4 core functions
-    void glPointParameteriv(GLenum pname, const GLint *params);
-    void glPointParameteri(GLenum pname, GLint param);
-    void glPointParameterfv(GLenum pname, const GLfloat *params);
-    void glPointParameterf(GLenum pname, GLfloat param);
-    void glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const void *const *indices, GLsizei drawcount);
-    void glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount);
-    void glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
-
-    // OpenGL 1.5 core functions
-    void glGetBufferPointerv(GLenum target, GLenum pname, void * *params);
-    void glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params);
-    GLboolean glUnmapBuffer(GLenum target);
-    void * glMapBuffer(GLenum target, GLenum access);
-    void glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, void *data);
-    void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void *data);
-    void glBufferData(GLenum target, GLsizeiptr size, const void *data, GLenum usage);
-    GLboolean glIsBuffer(GLuint buffer);
-    void glGenBuffers(GLsizei n, GLuint *buffers);
-    void glDeleteBuffers(GLsizei n, const GLuint *buffers);
-    void glBindBuffer(GLenum target, GLuint buffer);
-    void glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params);
-    void glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params);
-    void glGetQueryiv(GLenum target, GLenum pname, GLint *params);
-    void glEndQuery(GLenum target);
-    void glBeginQuery(GLenum target, GLuint id);
-    GLboolean glIsQuery(GLuint id);
-    void glDeleteQueries(GLsizei n, const GLuint *ids);
-    void glGenQueries(GLsizei n, GLuint *ids);
-
-    // OpenGL 2.0 core functions
-    void glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer);
-    void glVertexAttrib4usv(GLuint index, const GLushort *v);
-    void glVertexAttrib4uiv(GLuint index, const GLuint *v);
-    void glVertexAttrib4ubv(GLuint index, const GLubyte *v);
-    void glVertexAttrib4sv(GLuint index, const GLshort *v);
-    void glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
-    void glVertexAttrib4iv(GLuint index, const GLint *v);
-    void glVertexAttrib4fv(GLuint index, const GLfloat *v);
-    void glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void glVertexAttrib4dv(GLuint index, const GLdouble *v);
-    void glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glVertexAttrib4bv(GLuint index, const GLbyte *v);
-    void glVertexAttrib4Nusv(GLuint index, const GLushort *v);
-    void glVertexAttrib4Nuiv(GLuint index, const GLuint *v);
-    void glVertexAttrib4Nubv(GLuint index, const GLubyte *v);
-    void glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
-    void glVertexAttrib4Nsv(GLuint index, const GLshort *v);
-    void glVertexAttrib4Niv(GLuint index, const GLint *v);
-    void glVertexAttrib4Nbv(GLuint index, const GLbyte *v);
-    void glVertexAttrib3sv(GLuint index, const GLshort *v);
-    void glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z);
-    void glVertexAttrib3fv(GLuint index, const GLfloat *v);
-    void glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z);
-    void glVertexAttrib3dv(GLuint index, const GLdouble *v);
-    void glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z);
-    void glVertexAttrib2sv(GLuint index, const GLshort *v);
-    void glVertexAttrib2s(GLuint index, GLshort x, GLshort y);
-    void glVertexAttrib2fv(GLuint index, const GLfloat *v);
-    void glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y);
-    void glVertexAttrib2dv(GLuint index, const GLdouble *v);
-    void glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y);
-    void glVertexAttrib1sv(GLuint index, const GLshort *v);
-    void glVertexAttrib1s(GLuint index, GLshort x);
-    void glVertexAttrib1fv(GLuint index, const GLfloat *v);
-    void glVertexAttrib1f(GLuint index, GLfloat x);
-    void glVertexAttrib1dv(GLuint index, const GLdouble *v);
-    void glVertexAttrib1d(GLuint index, GLdouble x);
-    void glValidateProgram(GLuint program);
-    void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniform4iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform3iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform2iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform1iv(GLint location, GLsizei count, const GLint *value);
-    void glUniform4fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform3fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform2fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform1fv(GLint location, GLsizei count, const GLfloat *value);
-    void glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
-    void glUniform3i(GLint location, GLint v0, GLint v1, GLint v2);
-    void glUniform2i(GLint location, GLint v0, GLint v1);
-    void glUniform1i(GLint location, GLint v0);
-    void glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
-    void glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
-    void glUniform2f(GLint location, GLfloat v0, GLfloat v1);
-    void glUniform1f(GLint location, GLfloat v0);
-    void glUseProgram(GLuint program);
-    void glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length);
-    void glLinkProgram(GLuint program);
-    GLboolean glIsShader(GLuint shader);
-    GLboolean glIsProgram(GLuint program);
-    void glGetVertexAttribPointerv(GLuint index, GLenum pname, void * *pointer);
-    void glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params);
-    void glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params);
-    void glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params);
-    void glGetUniformiv(GLuint program, GLint location, GLint *params);
-    void glGetUniformfv(GLuint program, GLint location, GLfloat *params);
-    GLint glGetUniformLocation(GLuint program, const GLchar *name);
-    void glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source);
-    void glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void glGetShaderiv(GLuint shader, GLenum pname, GLint *params);
-    void glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void glGetProgramiv(GLuint program, GLenum pname, GLint *params);
-    GLint glGetAttribLocation(GLuint program, const GLchar *name);
-    void glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders);
-    void glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
-    void glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
-    void glEnableVertexAttribArray(GLuint index);
-    void glDisableVertexAttribArray(GLuint index);
-    void glDetachShader(GLuint program, GLuint shader);
-    void glDeleteShader(GLuint shader);
-    void glDeleteProgram(GLuint program);
-    GLuint glCreateShader(GLenum type);
-    GLuint glCreateProgram();
-    void glCompileShader(GLuint shader);
-    void glBindAttribLocation(GLuint program, GLuint index, const GLchar *name);
-    void glAttachShader(GLuint program, GLuint shader);
-    void glStencilMaskSeparate(GLenum face, GLuint mask);
-    void glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask);
-    void glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);
-    void glDrawBuffers(GLsizei n, const GLenum *bufs);
-    void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha);
-
-    // OpenGL 2.1 core functions
-    void glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-
-    // OpenGL 3.0 core functions
-    GLboolean glIsVertexArray(GLuint array);
-    void glGenVertexArrays(GLsizei n, GLuint *arrays);
-    void glDeleteVertexArrays(GLsizei n, const GLuint *arrays);
-    void glBindVertexArray(GLuint array);
-    void glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length);
-    void * glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
-    void glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
-    void glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
-    void glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
-    void glGenerateMipmap(GLenum target);
-    void glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params);
-    void glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
-    void glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset);
-    void glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
-    void glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
-    GLenum glCheckFramebufferStatus(GLenum target);
-    void glGenFramebuffers(GLsizei n, GLuint *framebuffers);
-    void glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers);
-    void glBindFramebuffer(GLenum target, GLuint framebuffer);
-    GLboolean glIsFramebuffer(GLuint framebuffer);
-    void glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
-    void glGenRenderbuffers(GLsizei n, GLuint *renderbuffers);
-    void glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers);
-    void glBindRenderbuffer(GLenum target, GLuint renderbuffer);
-    GLboolean glIsRenderbuffer(GLuint renderbuffer);
-    const GLubyte * glGetStringi(GLenum name, GLuint index);
-    void glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
-    void glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value);
-    void glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value);
-    void glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value);
-    void glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params);
-    void glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params);
-    void glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params);
-    void glTexParameterIiv(GLenum target, GLenum pname, const GLint *params);
-    void glUniform4uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform3uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform2uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform1uiv(GLint location, GLsizei count, const GLuint *value);
-    void glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
-    void glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2);
-    void glUniform2ui(GLint location, GLuint v0, GLuint v1);
-    void glUniform1ui(GLint location, GLuint v0);
-    GLint glGetFragDataLocation(GLuint program, const GLchar *name);
-    void glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name);
-    void glGetUniformuiv(GLuint program, GLint location, GLuint *params);
-    void glVertexAttribI4usv(GLuint index, const GLushort *v);
-    void glVertexAttribI4ubv(GLuint index, const GLubyte *v);
-    void glVertexAttribI4sv(GLuint index, const GLshort *v);
-    void glVertexAttribI4bv(GLuint index, const GLbyte *v);
-    void glVertexAttribI4uiv(GLuint index, const GLuint *v);
-    void glVertexAttribI3uiv(GLuint index, const GLuint *v);
-    void glVertexAttribI2uiv(GLuint index, const GLuint *v);
-    void glVertexAttribI1uiv(GLuint index, const GLuint *v);
-    void glVertexAttribI4iv(GLuint index, const GLint *v);
-    void glVertexAttribI3iv(GLuint index, const GLint *v);
-    void glVertexAttribI2iv(GLuint index, const GLint *v);
-    void glVertexAttribI1iv(GLuint index, const GLint *v);
-    void glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
-    void glVertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z);
-    void glVertexAttribI2ui(GLuint index, GLuint x, GLuint y);
-    void glVertexAttribI1ui(GLuint index, GLuint x);
-    void glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w);
-    void glVertexAttribI3i(GLuint index, GLint x, GLint y, GLint z);
-    void glVertexAttribI2i(GLuint index, GLint x, GLint y);
-    void glVertexAttribI1i(GLuint index, GLint x);
-    void glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params);
-    void glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params);
-    void glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer);
-    void glEndConditionalRender();
-    void glBeginConditionalRender(GLuint id, GLenum mode);
-    void glClampColor(GLenum target, GLenum clamp);
-    void glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name);
-    void glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode);
-    void glBindBufferBase(GLenum target, GLuint index, GLuint buffer);
-    void glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
-    void glEndTransformFeedback();
-    void glBeginTransformFeedback(GLenum primitiveMode);
-    GLboolean glIsEnabledi(GLenum target, GLuint index);
-    void glDisablei(GLenum target, GLuint index);
-    void glEnablei(GLenum target, GLuint index);
-    void glGetIntegeri_v(GLenum target, GLuint index, GLint *data);
-    void glGetBooleani_v(GLenum target, GLuint index, GLboolean *data);
-    void glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a);
-
-    // OpenGL 3.1 core functions
-    void glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);
-    void glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName);
-    void glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params);
-    GLuint glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName);
-    void glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName);
-    void glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params);
-    void glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar *const *uniformNames, GLuint *uniformIndices);
-    void glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
-    void glPrimitiveRestartIndex(GLuint index);
-    void glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer);
-    void glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount);
-    void glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount);
-
-    // OpenGL 3.2 core functions
-    void glSampleMaski(GLuint maskNumber, GLbitfield mask);
-    void glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val);
-    void glTexImage3DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
-    void glTexImage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
-    void glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level);
-    void glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params);
-    void glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data);
-    void glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values);
-    void glGetInteger64v(GLenum pname, GLint64 *data);
-    void glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout);
-    GLenum glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout);
-    void glDeleteSync(GLsync sync);
-    GLboolean glIsSync(GLsync sync);
-    GLsync glFenceSync(GLenum condition, GLbitfield flags);
-    void glProvokingVertex(GLenum mode);
-    void glMultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count, GLenum type, const void *const *indices, GLsizei drawcount, const GLint *basevertex);
-    void glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex);
-    void glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex);
-    void glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex);
-
-    // OpenGL 3.3 core functions
-    void glVertexAttribP4uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glVertexAttribP3uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glVertexAttribP2uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glVertexAttribP1uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void glVertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void glVertexAttribDivisor(GLuint index, GLuint divisor);
-    void glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params);
-    void glGetQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params);
-    void glQueryCounter(GLuint id, GLenum target);
-    void glGetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params);
-    void glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params);
-    void glGetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params);
-    void glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params);
-    void glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param);
-    void glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param);
-    void glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param);
-    void glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param);
-    void glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param);
-    void glSamplerParameteri(GLuint sampler, GLenum pname, GLint param);
-    void glBindSampler(GLuint unit, GLuint sampler);
-    GLboolean glIsSampler(GLuint sampler);
-    void glDeleteSamplers(GLsizei count, const GLuint *samplers);
-    void glGenSamplers(GLsizei count, GLuint *samplers);
-    GLint glGetFragDataIndex(GLuint program, const GLchar *name);
-    void glBindFragDataLocationIndexed(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name);
-
-    // OpenGL 4.0 core functions
-    void glGetQueryIndexediv(GLenum target, GLuint index, GLenum pname, GLint *params);
-    void glEndQueryIndexed(GLenum target, GLuint index);
-    void glBeginQueryIndexed(GLenum target, GLuint index, GLuint id);
-    void glDrawTransformFeedbackStream(GLenum mode, GLuint id, GLuint stream);
-    void glDrawTransformFeedback(GLenum mode, GLuint id);
-    void glResumeTransformFeedback();
-    void glPauseTransformFeedback();
-    GLboolean glIsTransformFeedback(GLuint id);
-    void glGenTransformFeedbacks(GLsizei n, GLuint *ids);
-    void glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids);
-    void glBindTransformFeedback(GLenum target, GLuint id);
-    void glPatchParameterfv(GLenum pname, const GLfloat *values);
-    void glPatchParameteri(GLenum pname, GLint value);
-    void glGetProgramStageiv(GLuint program, GLenum shadertype, GLenum pname, GLint *values);
-    void glGetUniformSubroutineuiv(GLenum shadertype, GLint location, GLuint *params);
-    void glUniformSubroutinesuiv(GLenum shadertype, GLsizei count, const GLuint *indices);
-    void glGetActiveSubroutineName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name);
-    void glGetActiveSubroutineUniformName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name);
-    void glGetActiveSubroutineUniformiv(GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values);
-    GLuint glGetSubroutineIndex(GLuint program, GLenum shadertype, const GLchar *name);
-    GLint glGetSubroutineUniformLocation(GLuint program, GLenum shadertype, const GLchar *name);
-    void glGetUniformdv(GLuint program, GLint location, GLdouble *params);
-    void glUniformMatrix4x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix4x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix3x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix3x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix2x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix2x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniformMatrix2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glUniform4dv(GLint location, GLsizei count, const GLdouble *value);
-    void glUniform3dv(GLint location, GLsizei count, const GLdouble *value);
-    void glUniform2dv(GLint location, GLsizei count, const GLdouble *value);
-    void glUniform1dv(GLint location, GLsizei count, const GLdouble *value);
-    void glUniform4d(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glUniform3d(GLint location, GLdouble x, GLdouble y, GLdouble z);
-    void glUniform2d(GLint location, GLdouble x, GLdouble y);
-    void glUniform1d(GLint location, GLdouble x);
-    void glDrawElementsIndirect(GLenum mode, GLenum type, const void *indirect);
-    void glDrawArraysIndirect(GLenum mode, const void *indirect);
-    void glBlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
-    void glBlendFunci(GLuint buf, GLenum src, GLenum dst);
-    void glBlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha);
-    void glBlendEquationi(GLuint buf, GLenum mode);
-    void glMinSampleShading(GLfloat value);
-
-    // OpenGL 4.1 core functions
-    void glGetDoublei_v(GLenum target, GLuint index, GLdouble *data);
-    void glGetFloati_v(GLenum target, GLuint index, GLfloat *data);
-    void glDepthRangeIndexed(GLuint index, GLdouble n, GLdouble f);
-    void glDepthRangeArrayv(GLuint first, GLsizei count, const GLdouble *v);
-    void glScissorIndexedv(GLuint index, const GLint *v);
-    void glScissorIndexed(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height);
-    void glScissorArrayv(GLuint first, GLsizei count, const GLint *v);
-    void glViewportIndexedfv(GLuint index, const GLfloat *v);
-    void glViewportIndexedf(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h);
-    void glViewportArrayv(GLuint first, GLsizei count, const GLfloat *v);
-    void glGetVertexAttribLdv(GLuint index, GLenum pname, GLdouble *params);
-    void glVertexAttribLPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer);
-    void glVertexAttribL4dv(GLuint index, const GLdouble *v);
-    void glVertexAttribL3dv(GLuint index, const GLdouble *v);
-    void glVertexAttribL2dv(GLuint index, const GLdouble *v);
-    void glVertexAttribL1dv(GLuint index, const GLdouble *v);
-    void glVertexAttribL4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void glVertexAttribL3d(GLuint index, GLdouble x, GLdouble y, GLdouble z);
-    void glVertexAttribL2d(GLuint index, GLdouble x, GLdouble y);
-    void glVertexAttribL1d(GLuint index, GLdouble x);
-    void glGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void glValidateProgramPipeline(GLuint pipeline);
-    void glProgramUniformMatrix4x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix3x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix4x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix2x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix3x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix2x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix4x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix3x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix4x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix2x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix3x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix2x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void glProgramUniformMatrix4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniformMatrix2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void glProgramUniform4uiv(GLuint program, GLint location, GLsizei count, const GLuint *value);
-    void glProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
-    void glProgramUniform4dv(GLuint program, GLint location, GLsizei count, const GLdouble *value);
-    void glProgramUniform4d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3);
-    void glProgramUniform4fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-    void glProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
-    void glProgramUniform4iv(GLuint program, GLint location, GLsizei count, const GLint *value);
-    void glProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
-    void glProgramUniform3uiv(GLuint program, GLint location, GLsizei count, const GLuint *value);
-    void glProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2);
-    void glProgramUniform3dv(GLuint program, GLint location, GLsizei count, const GLdouble *value);
-    void glProgramUniform3d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2);
-    void glProgramUniform3fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-    void glProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
-    void glProgramUniform3iv(GLuint program, GLint location, GLsizei count, const GLint *value);
-    void glProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2);
-    void glProgramUniform2uiv(GLuint program, GLint location, GLsizei count, const GLuint *value);
-    void glProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1);
-    void glProgramUniform2dv(GLuint program, GLint location, GLsizei count, const GLdouble *value);
-    void glProgramUniform2d(GLuint program, GLint location, GLdouble v0, GLdouble v1);
-    void glProgramUniform2fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-    void glProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1);
-    void glProgramUniform2iv(GLuint program, GLint location, GLsizei count, const GLint *value);
-    void glProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1);
-    void glProgramUniform1uiv(GLuint program, GLint location, GLsizei count, const GLuint *value);
-    void glProgramUniform1ui(GLuint program, GLint location, GLuint v0);
-    void glProgramUniform1dv(GLuint program, GLint location, GLsizei count, const GLdouble *value);
-    void glProgramUniform1d(GLuint program, GLint location, GLdouble v0);
-    void glProgramUniform1fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-    void glProgramUniform1f(GLuint program, GLint location, GLfloat v0);
-    void glProgramUniform1iv(GLuint program, GLint location, GLsizei count, const GLint *value);
-    void glProgramUniform1i(GLuint program, GLint location, GLint v0);
-    void glGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params);
-    GLboolean glIsProgramPipeline(GLuint pipeline);
-    void glGenProgramPipelines(GLsizei n, GLuint *pipelines);
-    void glDeleteProgramPipelines(GLsizei n, const GLuint *pipelines);
-    void glBindProgramPipeline(GLuint pipeline);
-    GLuint glCreateShaderProgramv(GLenum type, GLsizei count, const GLchar* const *strings);
-    void glActiveShaderProgram(GLuint pipeline, GLuint program);
-    void glUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program);
-    void glProgramParameteri(GLuint program, GLenum pname, GLint value);
-    void glProgramBinary(GLuint program, GLenum binaryFormat, const void *binary, GLsizei length);
-    void glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, void *binary);
-    void glClearDepthf(GLfloat dd);
-    void glDepthRangef(GLfloat n, GLfloat f);
-    void glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision);
-    void glShaderBinary(GLsizei count, const GLuint *shaders, GLenum binaryformat, const void *binary, GLsizei length);
-    void glReleaseShaderCompiler();
-
-    // OpenGL 4.2 core functions
-    void glDrawTransformFeedbackStreamInstanced(GLenum mode, GLuint id, GLuint stream, GLsizei instancecount);
-    void glDrawTransformFeedbackInstanced(GLenum mode, GLuint id, GLsizei instancecount);
-    void glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
-    void glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);
-    void glTexStorage1D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width);
-    void glMemoryBarrier(GLbitfield barriers);
-    void glBindImageTexture(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format);
-    void glGetActiveAtomicCounterBufferiv(GLuint program, GLuint bufferIndex, GLenum pname, GLint *params);
-    void glGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params);
-    void glDrawElementsInstancedBaseVertexBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance);
-    void glDrawElementsInstancedBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLuint baseinstance);
-    void glDrawArraysInstancedBaseInstance(GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance);
-
-    // OpenGL 4.3 core functions
-    void glGetObjectPtrLabel(const void *ptr, GLsizei bufSize, GLsizei *length, GLchar *label);
-    void glObjectPtrLabel(const void *ptr, GLsizei length, const GLchar *label);
-    void glGetObjectLabel(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label);
-    void glObjectLabel(GLenum identifier, GLuint name, GLsizei length, const GLchar *label);
-    void glPopDebugGroup();
-    void glPushDebugGroup(GLenum source, GLuint id, GLsizei length, const GLchar *message);
-    GLuint glGetDebugMessageLog(GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog);
-    void glDebugMessageCallback(GLDEBUGPROC callback, const void *userParam);
-    void glDebugMessageInsert(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf);
-    void glDebugMessageControl(GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled);
-    void glVertexBindingDivisor(GLuint bindingindex, GLuint divisor);
-    void glVertexAttribBinding(GLuint attribindex, GLuint bindingindex);
-    void glVertexAttribLFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);
-    void glVertexAttribIFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);
-    void glVertexAttribFormat(GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset);
-    void glBindVertexBuffer(GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride);
-    void glTextureView(GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers);
-    void glTexStorage3DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
-    void glTexStorage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
-    void glTexBufferRange(GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size);
-    void glShaderStorageBlockBinding(GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding);
-    GLint glGetProgramResourceLocationIndex(GLuint program, GLenum programInterface, const GLchar *name);
-    GLint glGetProgramResourceLocation(GLuint program, GLenum programInterface, const GLchar *name);
-    void glGetProgramResourceiv(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params);
-    void glGetProgramResourceName(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name);
-    GLuint glGetProgramResourceIndex(GLuint program, GLenum programInterface, const GLchar *name);
-    void glGetProgramInterfaceiv(GLuint program, GLenum programInterface, GLenum pname, GLint *params);
-    void glMultiDrawElementsIndirect(GLenum mode, GLenum type, const void *indirect, GLsizei drawcount, GLsizei stride);
-    void glMultiDrawArraysIndirect(GLenum mode, const void *indirect, GLsizei drawcount, GLsizei stride);
-    void glInvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glInvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments);
-    void glInvalidateBufferData(GLuint buffer);
-    void glInvalidateBufferSubData(GLuint buffer, GLintptr offset, GLsizeiptr length);
-    void glInvalidateTexImage(GLuint texture, GLint level);
-    void glInvalidateTexSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth);
-    void glGetInternalformati64v(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint64 *params);
-    void glGetFramebufferParameteriv(GLenum target, GLenum pname, GLint *params);
-    void glFramebufferParameteri(GLenum target, GLenum pname, GLint param);
-    void glCopyImageSubData(GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth);
-    void glDispatchComputeIndirect(GLintptr indirect);
-    void glDispatchCompute(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z);
-    void glClearBufferSubData(GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data);
-    void glClearBufferData(GLenum target, GLenum internalformat, GLenum format, GLenum type, const void *data);
-
-    // OpenGL 4.4 core functions
-    void glBindVertexBuffers(GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides);
-    void glBindImageTextures(GLuint first, GLsizei count, const GLuint *textures);
-    void glBindSamplers(GLuint first, GLsizei count, const GLuint *samplers);
-    void glBindTextures(GLuint first, GLsizei count, const GLuint *textures);
-    void glBindBuffersRange(GLenum target, GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizeiptr *sizes);
-    void glBindBuffersBase(GLenum target, GLuint first, GLsizei count, const GLuint *buffers);
-    void glClearTexSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *data);
-    void glClearTexImage(GLuint texture, GLint level, GLenum format, GLenum type, const void *data);
-    void glBufferStorage(GLenum target, GLsizeiptr size, const void *data, GLbitfield flags);
-
-    // OpenGL 4.5 core functions
-    void glTextureBarrier();
-    void glReadnPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data);
-    void glGetnUniformuiv(GLuint program, GLint location, GLsizei bufSize, GLuint *params);
-    void glGetnUniformiv(GLuint program, GLint location, GLsizei bufSize, GLint *params);
-    void glGetnUniformfv(GLuint program, GLint location, GLsizei bufSize, GLfloat *params);
-    void glGetnUniformdv(GLuint program, GLint location, GLsizei bufSize, GLdouble *params);
-    void glGetnTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, void *pixels);
-    void glGetnCompressedTexImage(GLenum target, GLint lod, GLsizei bufSize, void *pixels);
-    GLenum glGetGraphicsResetStatus();
-    void glGetCompressedTextureSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei bufSize, void *pixels);
-    void glGetTextureSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLsizei bufSize, void *pixels);
-    void glMemoryBarrierByRegion(GLbitfield barriers);
-    void glCreateQueries(GLenum target, GLsizei n, GLuint *ids);
-    void glCreateProgramPipelines(GLsizei n, GLuint *pipelines);
-    void glCreateSamplers(GLsizei n, GLuint *samplers);
-    void glGetVertexArrayIndexed64iv(GLuint vaobj, GLuint index, GLenum pname, GLint64 *param);
-    void glGetVertexArrayIndexediv(GLuint vaobj, GLuint index, GLenum pname, GLint *param);
-    void glGetVertexArrayiv(GLuint vaobj, GLenum pname, GLint *param);
-    void glVertexArrayBindingDivisor(GLuint vaobj, GLuint bindingindex, GLuint divisor);
-    void glVertexArrayAttribLFormat(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);
-    void glVertexArrayAttribIFormat(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);
-    void glVertexArrayAttribFormat(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset);
-    void glVertexArrayAttribBinding(GLuint vaobj, GLuint attribindex, GLuint bindingindex);
-    void glVertexArrayVertexBuffers(GLuint vaobj, GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides);
-    void glVertexArrayVertexBuffer(GLuint vaobj, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride);
-    void glVertexArrayElementBuffer(GLuint vaobj, GLuint buffer);
-    void glEnableVertexArrayAttrib(GLuint vaobj, GLuint index);
-    void glDisableVertexArrayAttrib(GLuint vaobj, GLuint index);
-    void glCreateVertexArrays(GLsizei n, GLuint *arrays);
-    void glGetTextureParameteriv(GLuint texture, GLenum pname, GLint *params);
-    void glGetTextureParameterIuiv(GLuint texture, GLenum pname, GLuint *params);
-    void glGetTextureParameterIiv(GLuint texture, GLenum pname, GLint *params);
-    void glGetTextureParameterfv(GLuint texture, GLenum pname, GLfloat *params);
-    void glGetTextureLevelParameteriv(GLuint texture, GLint level, GLenum pname, GLint *params);
-    void glGetTextureLevelParameterfv(GLuint texture, GLint level, GLenum pname, GLfloat *params);
-    void glGetCompressedTextureImage(GLuint texture, GLint level, GLsizei bufSize, void *pixels);
-    void glGetTextureImage(GLuint texture, GLint level, GLenum format, GLenum type, GLsizei bufSize, void *pixels);
-    void glBindTextureUnit(GLuint unit, GLuint texture);
-    void glGenerateTextureMipmap(GLuint texture);
-    void glTextureParameteriv(GLuint texture, GLenum pname, const GLint *param);
-    void glTextureParameterIuiv(GLuint texture, GLenum pname, const GLuint *params);
-    void glTextureParameterIiv(GLuint texture, GLenum pname, const GLint *params);
-    void glTextureParameteri(GLuint texture, GLenum pname, GLint param);
-    void glTextureParameterfv(GLuint texture, GLenum pname, const GLfloat *param);
-    void glTextureParameterf(GLuint texture, GLenum pname, GLfloat param);
-    void glCopyTextureSubImage3D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glCopyTextureSubImage2D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glCopyTextureSubImage1D(GLuint texture, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
-    void glCompressedTextureSubImage3D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data);
-    void glCompressedTextureSubImage2D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data);
-    void glCompressedTextureSubImage1D(GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data);
-    void glTextureSubImage3D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels);
-    void glTextureSubImage2D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels);
-    void glTextureSubImage1D(GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels);
-    void glTextureStorage3DMultisample(GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
-    void glTextureStorage2DMultisample(GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
-    void glTextureStorage3D(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
-    void glTextureStorage2D(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);
-    void glTextureStorage1D(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width);
-    void glTextureBufferRange(GLuint texture, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizei size);
-    void glTextureBuffer(GLuint texture, GLenum internalformat, GLuint buffer);
-    void glCreateTextures(GLenum target, GLsizei n, GLuint *textures);
-    void glGetNamedRenderbufferParameteriv(GLuint renderbuffer, GLenum pname, GLint *params);
-    void glNamedRenderbufferStorageMultisample(GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
-    void glNamedRenderbufferStorage(GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height);
-    void glCreateRenderbuffers(GLsizei n, GLuint *renderbuffers);
-    void glGetNamedFramebufferAttachmentParameteriv(GLuint framebuffer, GLenum attachment, GLenum pname, GLint *params);
-    void glGetNamedFramebufferParameteriv(GLuint framebuffer, GLenum pname, GLint *param);
-    GLenum glCheckNamedFramebufferStatus(GLuint framebuffer, GLenum target);
-    void glBlitNamedFramebuffer(GLuint readFramebuffer, GLuint drawFramebuffer, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
-    void glClearNamedFramebufferfi(GLuint framebuffer, GLenum buffer, GLfloat depth, GLint stencil);
-    void glClearNamedFramebufferfv(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLfloat *value);
-    void glClearNamedFramebufferuiv(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLuint *value);
-    void glClearNamedFramebufferiv(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLint *value);
-    void glInvalidateNamedFramebufferSubData(GLuint framebuffer, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height);
-    void glInvalidateNamedFramebufferData(GLuint framebuffer, GLsizei numAttachments, const GLenum *attachments);
-    void glNamedFramebufferReadBuffer(GLuint framebuffer, GLenum src);
-    void glNamedFramebufferDrawBuffers(GLuint framebuffer, GLsizei n, const GLenum *bufs);
-    void glNamedFramebufferDrawBuffer(GLuint framebuffer, GLenum buf);
-    void glNamedFramebufferTextureLayer(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer);
-    void glNamedFramebufferTexture(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level);
-    void glNamedFramebufferParameteri(GLuint framebuffer, GLenum pname, GLint param);
-    void glNamedFramebufferRenderbuffer(GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
-    void glCreateFramebuffers(GLsizei n, GLuint *framebuffers);
-    void glGetNamedBufferSubData(GLuint buffer, GLintptr offset, GLsizei size, void *data);
-    void glGetNamedBufferPointerv(GLuint buffer, GLenum pname, void * *params);
-    void glGetNamedBufferParameteri64v(GLuint buffer, GLenum pname, GLint64 *params);
-    void glGetNamedBufferParameteriv(GLuint buffer, GLenum pname, GLint *params);
-    void glFlushMappedNamedBufferRange(GLuint buffer, GLintptr offset, GLsizei length);
-    GLboolean glUnmapNamedBuffer(GLuint buffer);
-    void * glMapNamedBufferRange(GLuint buffer, GLintptr offset, GLsizei length, GLbitfield access);
-    void * glMapNamedBuffer(GLuint buffer, GLenum access);
-    void glClearNamedBufferSubData(GLuint buffer, GLenum internalformat, GLintptr offset, GLsizei size, GLenum format, GLenum type, const void *data);
-    void glClearNamedBufferData(GLuint buffer, GLenum internalformat, GLenum format, GLenum type, const void *data);
-    void glCopyNamedBufferSubData(GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizei size);
-    void glNamedBufferSubData(GLuint buffer, GLintptr offset, GLsizei size, const void *data);
-    void glNamedBufferData(GLuint buffer, GLsizei size, const void *data, GLenum usage);
-    void glNamedBufferStorage(GLuint buffer, GLsizei size, const void *data, GLbitfield flags);
-    void glCreateBuffers(GLsizei n, GLuint *buffers);
-    void glGetTransformFeedbacki64_v(GLuint xfb, GLenum pname, GLuint index, GLint64 *param);
-    void glGetTransformFeedbacki_v(GLuint xfb, GLenum pname, GLuint index, GLint *param);
-    void glGetTransformFeedbackiv(GLuint xfb, GLenum pname, GLint *param);
-    void glTransformFeedbackBufferRange(GLuint xfb, GLuint index, GLuint buffer, GLintptr offset, GLsizei size);
-    void glTransformFeedbackBufferBase(GLuint xfb, GLuint index, GLuint buffer);
-    void glCreateTransformFeedbacks(GLsizei n, GLuint *ids);
-    void glClipControl(GLenum origin, GLenum depth);
-
-private:
-    friend class QOpenGLContext;
-
-    static bool isContextCompatible(QOpenGLContext *context);
-    static QOpenGLVersionProfile versionProfile();
-
-    QOpenGLFunctions_1_0_CoreBackend* d_1_0_Core;
-    QOpenGLFunctions_1_1_CoreBackend* d_1_1_Core;
-    QOpenGLFunctions_1_2_CoreBackend* d_1_2_Core;
-    QOpenGLFunctions_1_3_CoreBackend* d_1_3_Core;
-    QOpenGLFunctions_1_4_CoreBackend* d_1_4_Core;
-    QOpenGLFunctions_1_5_CoreBackend* d_1_5_Core;
-    QOpenGLFunctions_2_0_CoreBackend* d_2_0_Core;
-    QOpenGLFunctions_2_1_CoreBackend* d_2_1_Core;
-    QOpenGLFunctions_3_0_CoreBackend* d_3_0_Core;
-    QOpenGLFunctions_3_1_CoreBackend* d_3_1_Core;
-    QOpenGLFunctions_3_2_CoreBackend* d_3_2_Core;
-    QOpenGLFunctions_3_3_CoreBackend* d_3_3_Core;
-    QOpenGLFunctions_4_0_CoreBackend* d_4_0_Core;
-    QOpenGLFunctions_4_1_CoreBackend* d_4_1_Core;
-    QOpenGLFunctions_4_2_CoreBackend* d_4_2_Core;
-    QOpenGLFunctions_4_3_CoreBackend* d_4_3_Core;
-    QOpenGLFunctions_4_4_CoreBackend* d_4_4_Core;
-    QOpenGLFunctions_4_5_CoreBackend* d_4_5_Core;
-};
-
-// OpenGL 1.0 core functions
-inline void QOpenGLFunctions_4_5_Core::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_0_Core->f.Viewport(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glDepthRange(GLdouble nearVal, GLdouble farVal)
-{
-    d_1_0_Core->f.DepthRange(nearVal, farVal);
-}
-
-inline GLboolean QOpenGLFunctions_4_5_Core::glIsEnabled(GLenum cap)
-{
-    return d_1_0_Core->f.IsEnabled(cap);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_0_Core->f.GetTexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-    d_1_0_Core->f.GetTexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, void *pixels)
-{
-    d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
-}
-
-inline const GLubyte * QOpenGLFunctions_4_5_Core::glGetString(GLenum name)
-{
-    return d_1_0_Core->f.GetString(name);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetIntegerv(GLenum pname, GLint *data)
-{
-    d_1_0_Core->f.GetIntegerv(pname, data);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetFloatv(GLenum pname, GLfloat *data)
-{
-    d_1_0_Core->f.GetFloatv(pname, data);
-}
-
-inline GLenum QOpenGLFunctions_4_5_Core::glGetError()
-{
-    return d_1_0_Core->f.GetError();
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetDoublev(GLenum pname, GLdouble *data)
-{
-    d_1_0_Core->f.GetDoublev(pname, data);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetBooleanv(GLenum pname, GLboolean *data)
-{
-    d_1_0_Core->f.GetBooleanv(pname, data);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels)
-{
-    d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glReadBuffer(GLenum src)
-{
-    d_1_0_Core->f.ReadBuffer(src);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glPixelStorei(GLenum pname, GLint param)
-{
-    d_1_0_Core->f.PixelStorei(pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glPixelStoref(GLenum pname, GLfloat param)
-{
-    d_1_0_Core->f.PixelStoref(pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glDepthFunc(GLenum func)
-{
-    d_1_0_Core->f.DepthFunc(func);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
-{
-    d_1_0_Core->f.StencilOp(fail, zfail, zpass);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glStencilFunc(GLenum func, GLint ref, GLuint mask)
-{
-    d_1_0_Core->f.StencilFunc(func, ref, mask);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glLogicOp(GLenum opcode)
-{
-    d_1_0_Core->f.LogicOp(opcode);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glBlendFunc(GLenum sfactor, GLenum dfactor)
-{
-    d_1_0_Core->f.BlendFunc(sfactor, dfactor);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glFlush()
-{
-    d_1_0_Core->f.Flush();
-}
-
-inline void QOpenGLFunctions_4_5_Core::glFinish()
-{
-    d_1_0_Core->f.Finish();
-}
-
-inline void QOpenGLFunctions_4_5_Core::glEnable(GLenum cap)
-{
-    d_1_0_Core->f.Enable(cap);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glDisable(GLenum cap)
-{
-    d_1_0_Core->f.Disable(cap);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glDepthMask(GLboolean flag)
-{
-    d_1_0_Core->f.DepthMask(flag);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
-{
-    d_1_0_Core->f.ColorMask(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glStencilMask(GLuint mask)
-{
-    d_1_0_Core->f.StencilMask(mask);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glClearDepth(GLdouble depth)
-{
-    d_1_0_Core->f.ClearDepth(depth);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glClearStencil(GLint s)
-{
-    d_1_0_Core->f.ClearStencil(s);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_0_Core->f.ClearColor(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glClear(GLbitfield mask)
-{
-    d_1_0_Core->f.Clear(mask);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glDrawBuffer(GLenum buf)
-{
-    d_1_0_Core->f.DrawBuffer(buf);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels)
-{
-    d_1_0_Core->f.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels)
-{
-    d_1_0_Core->f.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_1_0_Core->f.TexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glTexParameteri(GLenum target, GLenum pname, GLint param)
-{
-    d_1_0_Core->f.TexParameteri(target, pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-    d_1_0_Core->f.TexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
-{
-    d_1_0_Core->f.TexParameterf(target, pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_0_Core->f.Scissor(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glPolygonMode(GLenum face, GLenum mode)
-{
-    d_1_0_Core->f.PolygonMode(face, mode);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glPointSize(GLfloat size)
-{
-    d_1_0_Core->f.PointSize(size);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glLineWidth(GLfloat width)
-{
-    d_1_0_Core->f.LineWidth(width);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glHint(GLenum target, GLenum mode)
-{
-    d_1_0_Core->f.Hint(target, mode);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glFrontFace(GLenum mode)
-{
-    d_1_0_Core->f.FrontFace(mode);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glCullFace(GLenum mode)
-{
-    d_1_0_Core->f.CullFace(mode);
-}
-
-
-// OpenGL 1.1 core functions
-inline GLboolean QOpenGLFunctions_4_5_Core::glIsTexture(GLuint texture)
-{
-    return d_1_1_Core->f.IsTexture(texture);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGenTextures(GLsizei n, GLuint *textures)
-{
-    d_1_1_Core->f.GenTextures(n, textures);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glDeleteTextures(GLsizei n, const GLuint *textures)
-{
-    d_1_1_Core->f.DeleteTextures(n, textures);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glBindTexture(GLenum target, GLuint texture)
-{
-    d_1_1_Core->f.BindTexture(target, texture);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)
-{
-    d_1_1_Core->f.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels)
-{
-    d_1_1_Core->f.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_1_Core->f.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
-{
-    d_1_1_Core->f.CopyTexSubImage1D(target, level, xoffset, x, y, width);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
-{
-    d_1_1_Core->f.CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
-{
-    d_1_1_Core->f.CopyTexImage1D(target, level, internalformat, x, y, width, border);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glPolygonOffset(GLfloat factor, GLfloat units)
-{
-    d_1_1_Core->f.PolygonOffset(factor, units);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glDrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices)
-{
-    d_1_1_Core->f.DrawElements(mode, count, type, indices);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glDrawArrays(GLenum mode, GLint first, GLsizei count)
-{
-    d_1_1_Core->f.DrawArrays(mode, first, count);
-}
-
-
-// OpenGL 1.2 core functions
-inline void QOpenGLFunctions_4_5_Core::glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    d_1_2_Core->f.BlendColor(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glBlendEquation(GLenum mode)
-{
-    d_1_2_Core->f.BlendEquation(mode);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_1_2_Core->f.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels)
-{
-    d_1_2_Core->f.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels)
-{
-    d_1_2_Core->f.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices)
-{
-    d_1_2_Core->f.DrawRangeElements(mode, start, end, count, type, indices);
-}
-
-
-// OpenGL 1.3 core functions
-inline void QOpenGLFunctions_4_5_Core::glGetCompressedTexImage(GLenum target, GLint level, void *img)
-{
-    d_1_3_Core->f.GetCompressedTexImage(target, level, img);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data)
-{
-    d_1_3_Core->f.CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data)
-{
-    d_1_3_Core->f.CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data)
-{
-    d_1_3_Core->f.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data)
-{
-    d_1_3_Core->f.CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glSampleCoverage(GLfloat value, GLboolean invert)
-{
-    d_1_3_Core->f.SampleCoverage(value, invert);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glActiveTexture(GLenum texture)
-{
-    d_1_3_Core->f.ActiveTexture(texture);
-}
-
-
-// OpenGL 1.4 core functions
-inline void QOpenGLFunctions_4_5_Core::glPointParameteriv(GLenum pname, const GLint *params)
-{
-    d_1_4_Core->f.PointParameteriv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glPointParameteri(GLenum pname, GLint param)
-{
-    d_1_4_Core->f.PointParameteri(pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glPointParameterfv(GLenum pname, const GLfloat *params)
-{
-    d_1_4_Core->f.PointParameterfv(pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glPointParameterf(GLenum pname, GLfloat param)
-{
-    d_1_4_Core->f.PointParameterf(pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const void *const *indices, GLsizei drawcount)
-{
-    d_1_4_Core->f.MultiDrawElements(mode, count, type, indices, drawcount);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
-{
-    d_1_4_Core->f.MultiDrawArrays(mode, first, count, drawcount);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
-{
-    d_1_4_Core->f.BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
-}
-
-
-// OpenGL 1.5 core functions
-inline void QOpenGLFunctions_4_5_Core::glGetBufferPointerv(GLenum target, GLenum pname, void * *params)
-{
-    d_1_5_Core->f.GetBufferPointerv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetBufferParameteriv(target, pname, params);
-}
-
-inline GLboolean QOpenGLFunctions_4_5_Core::glUnmapBuffer(GLenum target)
-{
-    return d_1_5_Core->f.UnmapBuffer(target);
-}
-
-inline void * QOpenGLFunctions_4_5_Core::glMapBuffer(GLenum target, GLenum access)
-{
-    return d_1_5_Core->f.MapBuffer(target, access);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, void *data)
-{
-    d_1_5_Core->f.GetBufferSubData(target, offset, size, data);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void *data)
-{
-    d_1_5_Core->f.BufferSubData(target, offset, size, data);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glBufferData(GLenum target, GLsizeiptr size, const void *data, GLenum usage)
-{
-    d_1_5_Core->f.BufferData(target, size, data, usage);
-}
-
-inline GLboolean QOpenGLFunctions_4_5_Core::glIsBuffer(GLuint buffer)
-{
-    return d_1_5_Core->f.IsBuffer(buffer);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGenBuffers(GLsizei n, GLuint *buffers)
-{
-    d_1_5_Core->f.GenBuffers(n, buffers);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glDeleteBuffers(GLsizei n, const GLuint *buffers)
-{
-    d_1_5_Core->f.DeleteBuffers(n, buffers);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glBindBuffer(GLenum target, GLuint buffer)
-{
-    d_1_5_Core->f.BindBuffer(target, buffer);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
-{
-    d_1_5_Core->f.GetQueryObjectuiv(id, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetQueryObjectiv(id, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetQueryiv(GLenum target, GLenum pname, GLint *params)
-{
-    d_1_5_Core->f.GetQueryiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glEndQuery(GLenum target)
-{
-    d_1_5_Core->f.EndQuery(target);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glBeginQuery(GLenum target, GLuint id)
-{
-    d_1_5_Core->f.BeginQuery(target, id);
-}
-
-inline GLboolean QOpenGLFunctions_4_5_Core::glIsQuery(GLuint id)
-{
-    return d_1_5_Core->f.IsQuery(id);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glDeleteQueries(GLsizei n, const GLuint *ids)
-{
-    d_1_5_Core->f.DeleteQueries(n, ids);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGenQueries(GLsizei n, GLuint *ids)
-{
-    d_1_5_Core->f.GenQueries(n, ids);
-}
-
-
-// OpenGL 2.0 core functions
-inline void QOpenGLFunctions_4_5_Core::glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer)
-{
-    d_2_0_Core->f.VertexAttribPointer(index, size, type, normalized, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttrib4usv(GLuint index, const GLushort *v)
-{
-    d_2_0_Core->f.VertexAttrib4usv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttrib4uiv(GLuint index, const GLuint *v)
-{
-    d_2_0_Core->f.VertexAttrib4uiv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttrib4ubv(GLuint index, const GLubyte *v)
-{
-    d_2_0_Core->f.VertexAttrib4ubv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttrib4sv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib4sv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
-{
-    d_2_0_Core->f.VertexAttrib4s(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttrib4iv(GLuint index, const GLint *v)
-{
-    d_2_0_Core->f.VertexAttrib4iv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttrib4fv(GLuint index, const GLfloat *v)
-{
-    d_2_0_Core->f.VertexAttrib4fv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    d_2_0_Core->f.VertexAttrib4f(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttrib4dv(GLuint index, const GLdouble *v)
-{
-    d_2_0_Core->f.VertexAttrib4dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_2_0_Core->f.VertexAttrib4d(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttrib4bv(GLuint index, const GLbyte *v)
-{
-    d_2_0_Core->f.VertexAttrib4bv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttrib4Nusv(GLuint index, const GLushort *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nusv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttrib4Nuiv(GLuint index, const GLuint *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nuiv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttrib4Nubv(GLuint index, const GLubyte *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nubv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
-{
-    d_2_0_Core->f.VertexAttrib4Nub(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttrib4Nsv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nsv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttrib4Niv(GLuint index, const GLint *v)
-{
-    d_2_0_Core->f.VertexAttrib4Niv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttrib4Nbv(GLuint index, const GLbyte *v)
-{
-    d_2_0_Core->f.VertexAttrib4Nbv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttrib3sv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib3sv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
-{
-    d_2_0_Core->f.VertexAttrib3s(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttrib3fv(GLuint index, const GLfloat *v)
-{
-    d_2_0_Core->f.VertexAttrib3fv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
-{
-    d_2_0_Core->f.VertexAttrib3f(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttrib3dv(GLuint index, const GLdouble *v)
-{
-    d_2_0_Core->f.VertexAttrib3dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
-{
-    d_2_0_Core->f.VertexAttrib3d(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttrib2sv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib2sv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttrib2s(GLuint index, GLshort x, GLshort y)
-{
-    d_2_0_Core->f.VertexAttrib2s(index, x, y);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttrib2fv(GLuint index, const GLfloat *v)
-{
-    d_2_0_Core->f.VertexAttrib2fv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
-{
-    d_2_0_Core->f.VertexAttrib2f(index, x, y);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttrib2dv(GLuint index, const GLdouble *v)
-{
-    d_2_0_Core->f.VertexAttrib2dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
-{
-    d_2_0_Core->f.VertexAttrib2d(index, x, y);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttrib1sv(GLuint index, const GLshort *v)
-{
-    d_2_0_Core->f.VertexAttrib1sv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttrib1s(GLuint index, GLshort x)
-{
-    d_2_0_Core->f.VertexAttrib1s(index, x);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttrib1fv(GLuint index, const GLfloat *v)
-{
-    d_2_0_Core->f.VertexAttrib1fv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttrib1f(GLuint index, GLfloat x)
-{
-    d_2_0_Core->f.VertexAttrib1f(index, x);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttrib1dv(GLuint index, const GLdouble *v)
-{
-    d_2_0_Core->f.VertexAttrib1dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttrib1d(GLuint index, GLdouble x)
-{
-    d_2_0_Core->f.VertexAttrib1d(index, x);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glValidateProgram(GLuint program)
-{
-    d_2_0_Core->f.ValidateProgram(program);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix3fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_0_Core->f.UniformMatrix2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glUniform4iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform4iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glUniform3iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform3iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glUniform2iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform2iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glUniform1iv(GLint location, GLsizei count, const GLint *value)
-{
-    d_2_0_Core->f.Uniform1iv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glUniform4fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform4fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glUniform3fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform3fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glUniform2fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform2fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glUniform1fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    d_2_0_Core->f.Uniform1fv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
-{
-    d_2_0_Core->f.Uniform4i(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glUniform3i(GLint location, GLint v0, GLint v1, GLint v2)
-{
-    d_2_0_Core->f.Uniform3i(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glUniform2i(GLint location, GLint v0, GLint v1)
-{
-    d_2_0_Core->f.Uniform2i(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glUniform1i(GLint location, GLint v0)
-{
-    d_2_0_Core->f.Uniform1i(location, v0);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
-{
-    d_2_0_Core->f.Uniform4f(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
-{
-    d_2_0_Core->f.Uniform3f(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glUniform2f(GLint location, GLfloat v0, GLfloat v1)
-{
-    d_2_0_Core->f.Uniform2f(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glUniform1f(GLint location, GLfloat v0)
-{
-    d_2_0_Core->f.Uniform1f(location, v0);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glUseProgram(GLuint program)
-{
-    d_2_0_Core->f.UseProgram(program);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glShaderSource(GLuint shader, GLsizei count, const GLchar *const *string, const GLint *length)
-{
-    d_2_0_Core->f.ShaderSource(shader, count, string, length);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glLinkProgram(GLuint program)
-{
-    d_2_0_Core->f.LinkProgram(program);
-}
-
-inline GLboolean QOpenGLFunctions_4_5_Core::glIsShader(GLuint shader)
-{
-    return d_2_0_Core->f.IsShader(shader);
-}
-
-inline GLboolean QOpenGLFunctions_4_5_Core::glIsProgram(GLuint program)
-{
-    return d_2_0_Core->f.IsProgram(program);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetVertexAttribPointerv(GLuint index, GLenum pname, void * *pointer)
-{
-    d_2_0_Core->f.GetVertexAttribPointerv(index, pname, pointer);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetVertexAttribiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
-{
-    d_2_0_Core->f.GetVertexAttribfv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
-{
-    d_2_0_Core->f.GetVertexAttribdv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetUniformiv(GLuint program, GLint location, GLint *params)
-{
-    d_2_0_Core->f.GetUniformiv(program, location, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetUniformfv(GLuint program, GLint location, GLfloat *params)
-{
-    d_2_0_Core->f.GetUniformfv(program, location, params);
-}
-
-inline GLint QOpenGLFunctions_4_5_Core::glGetUniformLocation(GLuint program, const GLchar *name)
-{
-    return d_2_0_Core->f.GetUniformLocation(program, name);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
-{
-    d_2_0_Core->f.GetShaderSource(shader, bufSize, length, source);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-{
-    d_2_0_Core->f.GetShaderInfoLog(shader, bufSize, length, infoLog);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetShaderiv(GLuint shader, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetShaderiv(shader, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-{
-    d_2_0_Core->f.GetProgramInfoLog(program, bufSize, length, infoLog);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetProgramiv(GLuint program, GLenum pname, GLint *params)
-{
-    d_2_0_Core->f.GetProgramiv(program, pname, params);
-}
-
-inline GLint QOpenGLFunctions_4_5_Core::glGetAttribLocation(GLuint program, const GLchar *name)
-{
-    return d_2_0_Core->f.GetAttribLocation(program, name);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders)
-{
-    d_2_0_Core->f.GetAttachedShaders(program, maxCount, count, shaders);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
-{
-    d_2_0_Core->f.GetActiveUniform(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
-{
-    d_2_0_Core->f.GetActiveAttrib(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glEnableVertexAttribArray(GLuint index)
-{
-    d_2_0_Core->f.EnableVertexAttribArray(index);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glDisableVertexAttribArray(GLuint index)
-{
-    d_2_0_Core->f.DisableVertexAttribArray(index);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glDetachShader(GLuint program, GLuint shader)
-{
-    d_2_0_Core->f.DetachShader(program, shader);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glDeleteShader(GLuint shader)
-{
-    d_2_0_Core->f.DeleteShader(shader);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glDeleteProgram(GLuint program)
-{
-    d_2_0_Core->f.DeleteProgram(program);
-}
-
-inline GLuint QOpenGLFunctions_4_5_Core::glCreateShader(GLenum type)
-{
-    return d_2_0_Core->f.CreateShader(type);
-}
-
-inline GLuint QOpenGLFunctions_4_5_Core::glCreateProgram()
-{
-    return d_2_0_Core->f.CreateProgram();
-}
-
-inline void QOpenGLFunctions_4_5_Core::glCompileShader(GLuint shader)
-{
-    d_2_0_Core->f.CompileShader(shader);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glBindAttribLocation(GLuint program, GLuint index, const GLchar *name)
-{
-    d_2_0_Core->f.BindAttribLocation(program, index, name);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glAttachShader(GLuint program, GLuint shader)
-{
-    d_2_0_Core->f.AttachShader(program, shader);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glStencilMaskSeparate(GLenum face, GLuint mask)
-{
-    d_2_0_Core->f.StencilMaskSeparate(face, mask);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
-{
-    d_2_0_Core->f.StencilFuncSeparate(face, func, ref, mask);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
-{
-    d_2_0_Core->f.StencilOpSeparate(face, sfail, dpfail, dppass);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glDrawBuffers(GLsizei n, const GLenum *bufs)
-{
-    d_2_0_Core->f.DrawBuffers(n, bufs);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
-{
-    d_2_0_Core->f.BlendEquationSeparate(modeRGB, modeAlpha);
-}
-
-
-// OpenGL 2.1 core functions
-inline void QOpenGLFunctions_4_5_Core::glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix4x3fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix3x4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix4x2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix2x4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix3x2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_2_1_Core->f.UniformMatrix2x3fv(location, count, transpose, value);
-}
-
-
-// OpenGL 3.0 core functions
-inline GLboolean QOpenGLFunctions_4_5_Core::glIsVertexArray(GLuint array)
-{
-    return d_3_0_Core->f.IsVertexArray(array);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGenVertexArrays(GLsizei n, GLuint *arrays)
-{
-    d_3_0_Core->f.GenVertexArrays(n, arrays);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glDeleteVertexArrays(GLsizei n, const GLuint *arrays)
-{
-    d_3_0_Core->f.DeleteVertexArrays(n, arrays);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glBindVertexArray(GLuint array)
-{
-    d_3_0_Core->f.BindVertexArray(array);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
-{
-    d_3_0_Core->f.FlushMappedBufferRange(target, offset, length);
-}
-
-inline void * QOpenGLFunctions_4_5_Core::glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
-{
-    return d_3_0_Core->f.MapBufferRange(target, offset, length, access);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
-{
-    d_3_0_Core->f.FramebufferTextureLayer(target, attachment, texture, level, layer);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    d_3_0_Core->f.RenderbufferStorageMultisample(target, samples, internalformat, width, height);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
-{
-    d_3_0_Core->f.BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGenerateMipmap(GLenum target)
-{
-    d_3_0_Core->f.GenerateMipmap(target);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
-{
-    d_3_0_Core->f.FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
-{
-    d_3_0_Core->f.FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
-{
-    d_3_0_Core->f.FramebufferTexture2D(target, attachment, textarget, texture, level);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
-{
-    d_3_0_Core->f.FramebufferTexture1D(target, attachment, textarget, texture, level);
-}
-
-inline GLenum QOpenGLFunctions_4_5_Core::glCheckFramebufferStatus(GLenum target)
-{
-    return d_3_0_Core->f.CheckFramebufferStatus(target);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGenFramebuffers(GLsizei n, GLuint *framebuffers)
-{
-    d_3_0_Core->f.GenFramebuffers(n, framebuffers);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
-{
-    d_3_0_Core->f.DeleteFramebuffers(n, framebuffers);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glBindFramebuffer(GLenum target, GLuint framebuffer)
-{
-    d_3_0_Core->f.BindFramebuffer(target, framebuffer);
-}
-
-inline GLboolean QOpenGLFunctions_4_5_Core::glIsFramebuffer(GLuint framebuffer)
-{
-    return d_3_0_Core->f.IsFramebuffer(framebuffer);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetRenderbufferParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    d_3_0_Core->f.RenderbufferStorage(target, internalformat, width, height);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGenRenderbuffers(GLsizei n, GLuint *renderbuffers)
-{
-    d_3_0_Core->f.GenRenderbuffers(n, renderbuffers);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
-{
-    d_3_0_Core->f.DeleteRenderbuffers(n, renderbuffers);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glBindRenderbuffer(GLenum target, GLuint renderbuffer)
-{
-    d_3_0_Core->f.BindRenderbuffer(target, renderbuffer);
-}
-
-inline GLboolean QOpenGLFunctions_4_5_Core::glIsRenderbuffer(GLuint renderbuffer)
-{
-    return d_3_0_Core->f.IsRenderbuffer(renderbuffer);
-}
-
-inline const GLubyte * QOpenGLFunctions_4_5_Core::glGetStringi(GLenum name, GLuint index)
-{
-    return d_3_0_Core->f.GetStringi(name, index);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
-{
-    d_3_0_Core->f.ClearBufferfi(buffer, drawbuffer, depth, stencil);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
-{
-    d_3_0_Core->f.ClearBufferfv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
-{
-    d_3_0_Core->f.ClearBufferuiv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
-{
-    d_3_0_Core->f.ClearBufferiv(buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params)
-{
-    d_3_0_Core->f.GetTexParameterIuiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetTexParameterIiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params)
-{
-    d_3_0_Core->f.TexParameterIuiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glTexParameterIiv(GLenum target, GLenum pname, const GLint *params)
-{
-    d_3_0_Core->f.TexParameterIiv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glUniform4uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform4uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glUniform3uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform3uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glUniform2uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform2uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glUniform1uiv(GLint location, GLsizei count, const GLuint *value)
-{
-    d_3_0_Core->f.Uniform1uiv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
-{
-    d_3_0_Core->f.Uniform4ui(location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
-{
-    d_3_0_Core->f.Uniform3ui(location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glUniform2ui(GLint location, GLuint v0, GLuint v1)
-{
-    d_3_0_Core->f.Uniform2ui(location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glUniform1ui(GLint location, GLuint v0)
-{
-    d_3_0_Core->f.Uniform1ui(location, v0);
-}
-
-inline GLint QOpenGLFunctions_4_5_Core::glGetFragDataLocation(GLuint program, const GLchar *name)
-{
-    return d_3_0_Core->f.GetFragDataLocation(program, name);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name)
-{
-    d_3_0_Core->f.BindFragDataLocation(program, color, name);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetUniformuiv(GLuint program, GLint location, GLuint *params)
-{
-    d_3_0_Core->f.GetUniformuiv(program, location, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttribI4usv(GLuint index, const GLushort *v)
-{
-    d_3_0_Core->f.VertexAttribI4usv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttribI4ubv(GLuint index, const GLubyte *v)
-{
-    d_3_0_Core->f.VertexAttribI4ubv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttribI4sv(GLuint index, const GLshort *v)
-{
-    d_3_0_Core->f.VertexAttribI4sv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttribI4bv(GLuint index, const GLbyte *v)
-{
-    d_3_0_Core->f.VertexAttribI4bv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttribI4uiv(GLuint index, const GLuint *v)
-{
-    d_3_0_Core->f.VertexAttribI4uiv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttribI3uiv(GLuint index, const GLuint *v)
-{
-    d_3_0_Core->f.VertexAttribI3uiv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttribI2uiv(GLuint index, const GLuint *v)
-{
-    d_3_0_Core->f.VertexAttribI2uiv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttribI1uiv(GLuint index, const GLuint *v)
-{
-    d_3_0_Core->f.VertexAttribI1uiv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttribI4iv(GLuint index, const GLint *v)
-{
-    d_3_0_Core->f.VertexAttribI4iv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttribI3iv(GLuint index, const GLint *v)
-{
-    d_3_0_Core->f.VertexAttribI3iv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttribI2iv(GLuint index, const GLint *v)
-{
-    d_3_0_Core->f.VertexAttribI2iv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttribI1iv(GLuint index, const GLint *v)
-{
-    d_3_0_Core->f.VertexAttribI1iv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
-{
-    d_3_0_Core->f.VertexAttribI4ui(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z)
-{
-    d_3_0_Core->f.VertexAttribI3ui(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttribI2ui(GLuint index, GLuint x, GLuint y)
-{
-    d_3_0_Core->f.VertexAttribI2ui(index, x, y);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttribI1ui(GLuint index, GLuint x)
-{
-    d_3_0_Core->f.VertexAttribI1ui(index, x);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
-{
-    d_3_0_Core->f.VertexAttribI4i(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttribI3i(GLuint index, GLint x, GLint y, GLint z)
-{
-    d_3_0_Core->f.VertexAttribI3i(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttribI2i(GLuint index, GLint x, GLint y)
-{
-    d_3_0_Core->f.VertexAttribI2i(index, x, y);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttribI1i(GLuint index, GLint x)
-{
-    d_3_0_Core->f.VertexAttribI1i(index, x);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
-{
-    d_3_0_Core->f.GetVertexAttribIuiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
-{
-    d_3_0_Core->f.GetVertexAttribIiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer)
-{
-    d_3_0_Core->f.VertexAttribIPointer(index, size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glEndConditionalRender()
-{
-    d_3_0_Core->f.EndConditionalRender();
-}
-
-inline void QOpenGLFunctions_4_5_Core::glBeginConditionalRender(GLuint id, GLenum mode)
-{
-    d_3_0_Core->f.BeginConditionalRender(id, mode);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glClampColor(GLenum target, GLenum clamp)
-{
-    d_3_0_Core->f.ClampColor(target, clamp);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
-{
-    d_3_0_Core->f.GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar *const *varyings, GLenum bufferMode)
-{
-    d_3_0_Core->f.TransformFeedbackVaryings(program, count, varyings, bufferMode);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
-{
-    d_3_0_Core->f.BindBufferBase(target, index, buffer);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
-{
-    d_3_0_Core->f.BindBufferRange(target, index, buffer, offset, size);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glEndTransformFeedback()
-{
-    d_3_0_Core->f.EndTransformFeedback();
-}
-
-inline void QOpenGLFunctions_4_5_Core::glBeginTransformFeedback(GLenum primitiveMode)
-{
-    d_3_0_Core->f.BeginTransformFeedback(primitiveMode);
-}
-
-inline GLboolean QOpenGLFunctions_4_5_Core::glIsEnabledi(GLenum target, GLuint index)
-{
-    return d_3_0_Core->f.IsEnabledi(target, index);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glDisablei(GLenum target, GLuint index)
-{
-    d_3_0_Core->f.Disablei(target, index);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glEnablei(GLenum target, GLuint index)
-{
-    d_3_0_Core->f.Enablei(target, index);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetIntegeri_v(GLenum target, GLuint index, GLint *data)
-{
-    d_3_0_Core->f.GetIntegeri_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetBooleani_v(GLenum target, GLuint index, GLboolean *data)
-{
-    d_3_0_Core->f.GetBooleani_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
-{
-    d_3_0_Core->f.ColorMaski(index, r, g, b, a);
-}
-
-
-// OpenGL 3.1 core functions
-inline void QOpenGLFunctions_4_5_Core::glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
-{
-    d_3_1_Core->f.UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
-{
-    d_3_1_Core->f.GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params)
-{
-    d_3_1_Core->f.GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
-}
-
-inline GLuint QOpenGLFunctions_4_5_Core::glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName)
-{
-    return d_3_1_Core->f.GetUniformBlockIndex(program, uniformBlockName);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName)
-{
-    d_3_1_Core->f.GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params)
-{
-    d_3_1_Core->f.GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar *const *uniformNames, GLuint *uniformIndices)
-{
-    d_3_1_Core->f.GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
-{
-    d_3_1_Core->f.CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glPrimitiveRestartIndex(GLuint index)
-{
-    d_3_1_Core->f.PrimitiveRestartIndex(index);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer)
-{
-    d_3_1_Core->f.TexBuffer(target, internalformat, buffer);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount)
-{
-    d_3_1_Core->f.DrawElementsInstanced(mode, count, type, indices, instancecount);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount)
-{
-    d_3_1_Core->f.DrawArraysInstanced(mode, first, count, instancecount);
-}
-
-
-// OpenGL 3.2 core functions
-inline void QOpenGLFunctions_4_5_Core::glSampleMaski(GLuint maskNumber, GLbitfield mask)
-{
-    d_3_2_Core->f.SampleMaski(maskNumber, mask);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val)
-{
-    d_3_2_Core->f.GetMultisamplefv(pname, index, val);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glTexImage3DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
-{
-    d_3_2_Core->f.TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glTexImage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
-{
-    d_3_2_Core->f.TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level)
-{
-    d_3_2_Core->f.FramebufferTexture(target, attachment, texture, level);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params)
-{
-    d_3_2_Core->f.GetBufferParameteri64v(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data)
-{
-    d_3_2_Core->f.GetInteger64i_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values)
-{
-    d_3_2_Core->f.GetSynciv(sync, pname, bufSize, length, values);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetInteger64v(GLenum pname, GLint64 *data)
-{
-    d_3_2_Core->f.GetInteger64v(pname, data);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
-{
-    d_3_2_Core->f.WaitSync(sync, flags, timeout);
-}
-
-inline GLenum QOpenGLFunctions_4_5_Core::glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
-{
-    return d_3_2_Core->f.ClientWaitSync(sync, flags, timeout);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glDeleteSync(GLsync sync)
-{
-    d_3_2_Core->f.DeleteSync(sync);
-}
-
-inline GLboolean QOpenGLFunctions_4_5_Core::glIsSync(GLsync sync)
-{
-    return d_3_2_Core->f.IsSync(sync);
-}
-
-inline GLsync QOpenGLFunctions_4_5_Core::glFenceSync(GLenum condition, GLbitfield flags)
-{
-    return d_3_2_Core->f.FenceSync(condition, flags);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProvokingVertex(GLenum mode)
-{
-    d_3_2_Core->f.ProvokingVertex(mode);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glMultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count, GLenum type, const void *const *indices, GLsizei drawcount, const GLint *basevertex)
-{
-    d_3_2_Core->f.MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex)
-{
-    d_3_2_Core->f.DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex)
-{
-    d_3_2_Core->f.DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex)
-{
-    d_3_2_Core->f.DrawElementsBaseVertex(mode, count, type, indices, basevertex);
-}
-
-
-// OpenGL 3.3 core functions
-inline void QOpenGLFunctions_4_5_Core::glVertexAttribP4uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP4uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP4ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttribP3uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP3uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP3ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttribP2uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP2uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP2ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttribP1uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
-{
-    d_3_3_Core->f.VertexAttribP1uiv(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
-{
-    d_3_3_Core->f.VertexAttribP1ui(index, type, normalized, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttribDivisor(GLuint index, GLuint divisor)
-{
-    d_3_3_Core->f.VertexAttribDivisor(index, divisor);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params)
-{
-    d_3_3_Core->f.GetQueryObjectui64v(id, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params)
-{
-    d_3_3_Core->f.GetQueryObjecti64v(id, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glQueryCounter(GLuint id, GLenum target)
-{
-    d_3_3_Core->f.QueryCounter(id, target);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params)
-{
-    d_3_3_Core->f.GetSamplerParameterIuiv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params)
-{
-    d_3_3_Core->f.GetSamplerParameterfv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params)
-{
-    d_3_3_Core->f.GetSamplerParameterIiv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params)
-{
-    d_3_3_Core->f.GetSamplerParameteriv(sampler, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param)
-{
-    d_3_3_Core->f.SamplerParameterIuiv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param)
-{
-    d_3_3_Core->f.SamplerParameterIiv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param)
-{
-    d_3_3_Core->f.SamplerParameterfv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
-{
-    d_3_3_Core->f.SamplerParameterf(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param)
-{
-    d_3_3_Core->f.SamplerParameteriv(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glSamplerParameteri(GLuint sampler, GLenum pname, GLint param)
-{
-    d_3_3_Core->f.SamplerParameteri(sampler, pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glBindSampler(GLuint unit, GLuint sampler)
-{
-    d_3_3_Core->f.BindSampler(unit, sampler);
-}
-
-inline GLboolean QOpenGLFunctions_4_5_Core::glIsSampler(GLuint sampler)
-{
-    return d_3_3_Core->f.IsSampler(sampler);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glDeleteSamplers(GLsizei count, const GLuint *samplers)
-{
-    d_3_3_Core->f.DeleteSamplers(count, samplers);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGenSamplers(GLsizei count, GLuint *samplers)
-{
-    d_3_3_Core->f.GenSamplers(count, samplers);
-}
-
-inline GLint QOpenGLFunctions_4_5_Core::glGetFragDataIndex(GLuint program, const GLchar *name)
-{
-    return d_3_3_Core->f.GetFragDataIndex(program, name);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glBindFragDataLocationIndexed(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name)
-{
-    d_3_3_Core->f.BindFragDataLocationIndexed(program, colorNumber, index, name);
-}
-
-
-// OpenGL 4.0 core functions
-inline void QOpenGLFunctions_4_5_Core::glGetQueryIndexediv(GLenum target, GLuint index, GLenum pname, GLint *params)
-{
-    d_4_0_Core->f.GetQueryIndexediv(target, index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glEndQueryIndexed(GLenum target, GLuint index)
-{
-    d_4_0_Core->f.EndQueryIndexed(target, index);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glBeginQueryIndexed(GLenum target, GLuint index, GLuint id)
-{
-    d_4_0_Core->f.BeginQueryIndexed(target, index, id);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glDrawTransformFeedbackStream(GLenum mode, GLuint id, GLuint stream)
-{
-    d_4_0_Core->f.DrawTransformFeedbackStream(mode, id, stream);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glDrawTransformFeedback(GLenum mode, GLuint id)
-{
-    d_4_0_Core->f.DrawTransformFeedback(mode, id);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glResumeTransformFeedback()
-{
-    d_4_0_Core->f.ResumeTransformFeedback();
-}
-
-inline void QOpenGLFunctions_4_5_Core::glPauseTransformFeedback()
-{
-    d_4_0_Core->f.PauseTransformFeedback();
-}
-
-inline GLboolean QOpenGLFunctions_4_5_Core::glIsTransformFeedback(GLuint id)
-{
-    return d_4_0_Core->f.IsTransformFeedback(id);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGenTransformFeedbacks(GLsizei n, GLuint *ids)
-{
-    d_4_0_Core->f.GenTransformFeedbacks(n, ids);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids)
-{
-    d_4_0_Core->f.DeleteTransformFeedbacks(n, ids);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glBindTransformFeedback(GLenum target, GLuint id)
-{
-    d_4_0_Core->f.BindTransformFeedback(target, id);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glPatchParameterfv(GLenum pname, const GLfloat *values)
-{
-    d_4_0_Core->f.PatchParameterfv(pname, values);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glPatchParameteri(GLenum pname, GLint value)
-{
-    d_4_0_Core->f.PatchParameteri(pname, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetProgramStageiv(GLuint program, GLenum shadertype, GLenum pname, GLint *values)
-{
-    d_4_0_Core->f.GetProgramStageiv(program, shadertype, pname, values);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetUniformSubroutineuiv(GLenum shadertype, GLint location, GLuint *params)
-{
-    d_4_0_Core->f.GetUniformSubroutineuiv(shadertype, location, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glUniformSubroutinesuiv(GLenum shadertype, GLsizei count, const GLuint *indices)
-{
-    d_4_0_Core->f.UniformSubroutinesuiv(shadertype, count, indices);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetActiveSubroutineName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
-{
-    d_4_0_Core->f.GetActiveSubroutineName(program, shadertype, index, bufsize, length, name);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetActiveSubroutineUniformName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
-{
-    d_4_0_Core->f.GetActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetActiveSubroutineUniformiv(GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values)
-{
-    d_4_0_Core->f.GetActiveSubroutineUniformiv(program, shadertype, index, pname, values);
-}
-
-inline GLuint QOpenGLFunctions_4_5_Core::glGetSubroutineIndex(GLuint program, GLenum shadertype, const GLchar *name)
-{
-    return d_4_0_Core->f.GetSubroutineIndex(program, shadertype, name);
-}
-
-inline GLint QOpenGLFunctions_4_5_Core::glGetSubroutineUniformLocation(GLuint program, GLenum shadertype, const GLchar *name)
-{
-    return d_4_0_Core->f.GetSubroutineUniformLocation(program, shadertype, name);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetUniformdv(GLuint program, GLint location, GLdouble *params)
-{
-    d_4_0_Core->f.GetUniformdv(program, location, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glUniformMatrix4x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix4x3dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glUniformMatrix4x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix4x2dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glUniformMatrix3x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix3x4dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glUniformMatrix3x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix3x2dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glUniformMatrix2x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix2x4dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glUniformMatrix2x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix2x3dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glUniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix4dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glUniformMatrix3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix3dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glUniformMatrix2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_0_Core->f.UniformMatrix2dv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glUniform4dv(GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_0_Core->f.Uniform4dv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glUniform3dv(GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_0_Core->f.Uniform3dv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glUniform2dv(GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_0_Core->f.Uniform2dv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glUniform1dv(GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_0_Core->f.Uniform1dv(location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glUniform4d(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_4_0_Core->f.Uniform4d(location, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glUniform3d(GLint location, GLdouble x, GLdouble y, GLdouble z)
-{
-    d_4_0_Core->f.Uniform3d(location, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glUniform2d(GLint location, GLdouble x, GLdouble y)
-{
-    d_4_0_Core->f.Uniform2d(location, x, y);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glUniform1d(GLint location, GLdouble x)
-{
-    d_4_0_Core->f.Uniform1d(location, x);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glDrawElementsIndirect(GLenum mode, GLenum type, const void *indirect)
-{
-    d_4_0_Core->f.DrawElementsIndirect(mode, type, indirect);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glDrawArraysIndirect(GLenum mode, const void *indirect)
-{
-    d_4_0_Core->f.DrawArraysIndirect(mode, indirect);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glBlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
-{
-    d_4_0_Core->f.BlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glBlendFunci(GLuint buf, GLenum src, GLenum dst)
-{
-    d_4_0_Core->f.BlendFunci(buf, src, dst);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glBlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha)
-{
-    d_4_0_Core->f.BlendEquationSeparatei(buf, modeRGB, modeAlpha);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glBlendEquationi(GLuint buf, GLenum mode)
-{
-    d_4_0_Core->f.BlendEquationi(buf, mode);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glMinSampleShading(GLfloat value)
-{
-    d_4_0_Core->f.MinSampleShading(value);
-}
-
-
-// OpenGL 4.1 core functions
-inline void QOpenGLFunctions_4_5_Core::glGetDoublei_v(GLenum target, GLuint index, GLdouble *data)
-{
-    d_4_1_Core->f.GetDoublei_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetFloati_v(GLenum target, GLuint index, GLfloat *data)
-{
-    d_4_1_Core->f.GetFloati_v(target, index, data);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glDepthRangeIndexed(GLuint index, GLdouble n, GLdouble f)
-{
-    d_4_1_Core->f.DepthRangeIndexed(index, n, f);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glDepthRangeArrayv(GLuint first, GLsizei count, const GLdouble *v)
-{
-    d_4_1_Core->f.DepthRangeArrayv(first, count, v);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glScissorIndexedv(GLuint index, const GLint *v)
-{
-    d_4_1_Core->f.ScissorIndexedv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glScissorIndexed(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height)
-{
-    d_4_1_Core->f.ScissorIndexed(index, left, bottom, width, height);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glScissorArrayv(GLuint first, GLsizei count, const GLint *v)
-{
-    d_4_1_Core->f.ScissorArrayv(first, count, v);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glViewportIndexedfv(GLuint index, const GLfloat *v)
-{
-    d_4_1_Core->f.ViewportIndexedfv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glViewportIndexedf(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h)
-{
-    d_4_1_Core->f.ViewportIndexedf(index, x, y, w, h);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glViewportArrayv(GLuint first, GLsizei count, const GLfloat *v)
-{
-    d_4_1_Core->f.ViewportArrayv(first, count, v);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetVertexAttribLdv(GLuint index, GLenum pname, GLdouble *params)
-{
-    d_4_1_Core->f.GetVertexAttribLdv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttribLPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer)
-{
-    d_4_1_Core->f.VertexAttribLPointer(index, size, type, stride, pointer);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttribL4dv(GLuint index, const GLdouble *v)
-{
-    d_4_1_Core->f.VertexAttribL4dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttribL3dv(GLuint index, const GLdouble *v)
-{
-    d_4_1_Core->f.VertexAttribL3dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttribL2dv(GLuint index, const GLdouble *v)
-{
-    d_4_1_Core->f.VertexAttribL2dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttribL1dv(GLuint index, const GLdouble *v)
-{
-    d_4_1_Core->f.VertexAttribL1dv(index, v);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttribL4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-    d_4_1_Core->f.VertexAttribL4d(index, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttribL3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
-{
-    d_4_1_Core->f.VertexAttribL3d(index, x, y, z);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttribL2d(GLuint index, GLdouble x, GLdouble y)
-{
-    d_4_1_Core->f.VertexAttribL2d(index, x, y);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttribL1d(GLuint index, GLdouble x)
-{
-    d_4_1_Core->f.VertexAttribL1d(index, x);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-{
-    d_4_1_Core->f.GetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glValidateProgramPipeline(GLuint pipeline)
-{
-    d_4_1_Core->f.ValidateProgramPipeline(pipeline);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProgramUniformMatrix4x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4x3dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProgramUniformMatrix3x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3x4dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProgramUniformMatrix4x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4x2dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProgramUniformMatrix2x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2x4dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProgramUniformMatrix3x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3x2dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProgramUniformMatrix2x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2x3dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProgramUniformMatrix4x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4x3fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProgramUniformMatrix3x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3x4fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProgramUniformMatrix4x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4x2fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProgramUniformMatrix2x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2x4fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProgramUniformMatrix3x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3x2fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProgramUniformMatrix2x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2x3fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProgramUniformMatrix4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProgramUniformMatrix3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProgramUniformMatrix2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2dv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProgramUniformMatrix4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix4fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProgramUniformMatrix3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix3fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProgramUniformMatrix2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniformMatrix2fv(program, location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProgramUniform4uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
-{
-    d_4_1_Core->f.ProgramUniform4uiv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
-{
-    d_4_1_Core->f.ProgramUniform4ui(program, location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProgramUniform4dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniform4dv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProgramUniform4d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3)
-{
-    d_4_1_Core->f.ProgramUniform4d(program, location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProgramUniform4fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniform4fv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
-{
-    d_4_1_Core->f.ProgramUniform4f(program, location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProgramUniform4iv(GLuint program, GLint location, GLsizei count, const GLint *value)
-{
-    d_4_1_Core->f.ProgramUniform4iv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
-{
-    d_4_1_Core->f.ProgramUniform4i(program, location, v0, v1, v2, v3);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProgramUniform3uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
-{
-    d_4_1_Core->f.ProgramUniform3uiv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2)
-{
-    d_4_1_Core->f.ProgramUniform3ui(program, location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProgramUniform3dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniform3dv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProgramUniform3d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2)
-{
-    d_4_1_Core->f.ProgramUniform3d(program, location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProgramUniform3fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniform3fv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
-{
-    d_4_1_Core->f.ProgramUniform3f(program, location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProgramUniform3iv(GLuint program, GLint location, GLsizei count, const GLint *value)
-{
-    d_4_1_Core->f.ProgramUniform3iv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2)
-{
-    d_4_1_Core->f.ProgramUniform3i(program, location, v0, v1, v2);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProgramUniform2uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
-{
-    d_4_1_Core->f.ProgramUniform2uiv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1)
-{
-    d_4_1_Core->f.ProgramUniform2ui(program, location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProgramUniform2dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniform2dv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProgramUniform2d(GLuint program, GLint location, GLdouble v0, GLdouble v1)
-{
-    d_4_1_Core->f.ProgramUniform2d(program, location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProgramUniform2fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniform2fv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1)
-{
-    d_4_1_Core->f.ProgramUniform2f(program, location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProgramUniform2iv(GLuint program, GLint location, GLsizei count, const GLint *value)
-{
-    d_4_1_Core->f.ProgramUniform2iv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1)
-{
-    d_4_1_Core->f.ProgramUniform2i(program, location, v0, v1);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProgramUniform1uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
-{
-    d_4_1_Core->f.ProgramUniform1uiv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProgramUniform1ui(GLuint program, GLint location, GLuint v0)
-{
-    d_4_1_Core->f.ProgramUniform1ui(program, location, v0);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProgramUniform1dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
-{
-    d_4_1_Core->f.ProgramUniform1dv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProgramUniform1d(GLuint program, GLint location, GLdouble v0)
-{
-    d_4_1_Core->f.ProgramUniform1d(program, location, v0);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProgramUniform1fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
-{
-    d_4_1_Core->f.ProgramUniform1fv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProgramUniform1f(GLuint program, GLint location, GLfloat v0)
-{
-    d_4_1_Core->f.ProgramUniform1f(program, location, v0);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProgramUniform1iv(GLuint program, GLint location, GLsizei count, const GLint *value)
-{
-    d_4_1_Core->f.ProgramUniform1iv(program, location, count, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProgramUniform1i(GLuint program, GLint location, GLint v0)
-{
-    d_4_1_Core->f.ProgramUniform1i(program, location, v0);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params)
-{
-    d_4_1_Core->f.GetProgramPipelineiv(pipeline, pname, params);
-}
-
-inline GLboolean QOpenGLFunctions_4_5_Core::glIsProgramPipeline(GLuint pipeline)
-{
-    return d_4_1_Core->f.IsProgramPipeline(pipeline);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGenProgramPipelines(GLsizei n, GLuint *pipelines)
-{
-    d_4_1_Core->f.GenProgramPipelines(n, pipelines);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glDeleteProgramPipelines(GLsizei n, const GLuint *pipelines)
-{
-    d_4_1_Core->f.DeleteProgramPipelines(n, pipelines);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glBindProgramPipeline(GLuint pipeline)
-{
-    d_4_1_Core->f.BindProgramPipeline(pipeline);
-}
-
-inline GLuint QOpenGLFunctions_4_5_Core::glCreateShaderProgramv(GLenum type, GLsizei count, const GLchar *const *strings)
-{
-    return d_4_1_Core->f.CreateShaderProgramv(type, count, strings);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glActiveShaderProgram(GLuint pipeline, GLuint program)
-{
-    d_4_1_Core->f.ActiveShaderProgram(pipeline, program);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program)
-{
-    d_4_1_Core->f.UseProgramStages(pipeline, stages, program);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProgramParameteri(GLuint program, GLenum pname, GLint value)
-{
-    d_4_1_Core->f.ProgramParameteri(program, pname, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glProgramBinary(GLuint program, GLenum binaryFormat, const void *binary, GLsizei length)
-{
-    d_4_1_Core->f.ProgramBinary(program, binaryFormat, binary, length);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, void *binary)
-{
-    d_4_1_Core->f.GetProgramBinary(program, bufSize, length, binaryFormat, binary);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glClearDepthf(GLfloat dd)
-{
-    d_4_1_Core->f.ClearDepthf(dd);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glDepthRangef(GLfloat n, GLfloat f)
-{
-    d_4_1_Core->f.DepthRangef(n, f);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision)
-{
-    d_4_1_Core->f.GetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glShaderBinary(GLsizei count, const GLuint *shaders, GLenum binaryformat, const void *binary, GLsizei length)
-{
-    d_4_1_Core->f.ShaderBinary(count, shaders, binaryformat, binary, length);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glReleaseShaderCompiler()
-{
-    d_4_1_Core->f.ReleaseShaderCompiler();
-}
-
-
-// OpenGL 4.2 core functions
-inline void QOpenGLFunctions_4_5_Core::glDrawTransformFeedbackStreamInstanced(GLenum mode, GLuint id, GLuint stream, GLsizei instancecount)
-{
-    d_4_2_Core->f.DrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glDrawTransformFeedbackInstanced(GLenum mode, GLuint id, GLsizei instancecount)
-{
-    d_4_2_Core->f.DrawTransformFeedbackInstanced(mode, id, instancecount);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
-{
-    d_4_2_Core->f.TexStorage3D(target, levels, internalformat, width, height, depth);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    d_4_2_Core->f.TexStorage2D(target, levels, internalformat, width, height);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glTexStorage1D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width)
-{
-    d_4_2_Core->f.TexStorage1D(target, levels, internalformat, width);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glMemoryBarrier(GLbitfield barriers)
-{
-    d_4_2_Core->f.MemoryBarrier(barriers);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glBindImageTexture(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format)
-{
-    d_4_2_Core->f.BindImageTexture(unit, texture, level, layered, layer, access, format);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetActiveAtomicCounterBufferiv(GLuint program, GLuint bufferIndex, GLenum pname, GLint *params)
-{
-    d_4_2_Core->f.GetActiveAtomicCounterBufferiv(program, bufferIndex, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params)
-{
-    d_4_2_Core->f.GetInternalformativ(target, internalformat, pname, bufSize, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glDrawElementsInstancedBaseVertexBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance)
-{
-    d_4_2_Core->f.DrawElementsInstancedBaseVertexBaseInstance(mode, count, type, indices, instancecount, basevertex, baseinstance);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glDrawElementsInstancedBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLuint baseinstance)
-{
-    d_4_2_Core->f.DrawElementsInstancedBaseInstance(mode, count, type, indices, instancecount, baseinstance);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glDrawArraysInstancedBaseInstance(GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance)
-{
-    d_4_2_Core->f.DrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);
-}
-
-
-// OpenGL 4.3 core functions
-inline void QOpenGLFunctions_4_5_Core::glGetObjectPtrLabel(const void *ptr, GLsizei bufSize, GLsizei *length, GLchar *label)
-{
-    d_4_3_Core->f.GetObjectPtrLabel(ptr, bufSize, length, label);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glObjectPtrLabel(const void *ptr, GLsizei length, const GLchar *label)
-{
-    d_4_3_Core->f.ObjectPtrLabel(ptr, length, label);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetObjectLabel(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label)
-{
-    d_4_3_Core->f.GetObjectLabel(identifier, name, bufSize, length, label);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glObjectLabel(GLenum identifier, GLuint name, GLsizei length, const GLchar *label)
-{
-    d_4_3_Core->f.ObjectLabel(identifier, name, length, label);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glPopDebugGroup()
-{
-    d_4_3_Core->f.PopDebugGroup();
-}
-
-inline void QOpenGLFunctions_4_5_Core::glPushDebugGroup(GLenum source, GLuint id, GLsizei length, const GLchar *message)
-{
-    d_4_3_Core->f.PushDebugGroup(source, id, length, message);
-}
-
-inline GLuint QOpenGLFunctions_4_5_Core::glGetDebugMessageLog(GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog)
-{
-    return d_4_3_Core->f.GetDebugMessageLog(count, bufSize, sources, types, ids, severities, lengths, messageLog);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glDebugMessageCallback(GLDEBUGPROC callback, const void *userParam)
-{
-    d_4_3_Core->f.DebugMessageCallback(callback, userParam);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glDebugMessageInsert(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf)
-{
-    d_4_3_Core->f.DebugMessageInsert(source, type, id, severity, length, buf);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glDebugMessageControl(GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled)
-{
-    d_4_3_Core->f.DebugMessageControl(source, type, severity, count, ids, enabled);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexBindingDivisor(GLuint bindingindex, GLuint divisor)
-{
-    d_4_3_Core->f.VertexBindingDivisor(bindingindex, divisor);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttribBinding(GLuint attribindex, GLuint bindingindex)
-{
-    d_4_3_Core->f.VertexAttribBinding(attribindex, bindingindex);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttribLFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
-{
-    d_4_3_Core->f.VertexAttribLFormat(attribindex, size, type, relativeoffset);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttribIFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
-{
-    d_4_3_Core->f.VertexAttribIFormat(attribindex, size, type, relativeoffset);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexAttribFormat(GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset)
-{
-    d_4_3_Core->f.VertexAttribFormat(attribindex, size, type, normalized, relativeoffset);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glBindVertexBuffer(GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride)
-{
-    d_4_3_Core->f.BindVertexBuffer(bindingindex, buffer, offset, stride);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glTextureView(GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers)
-{
-    d_4_3_Core->f.TextureView(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glTexStorage3DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
-{
-    d_4_3_Core->f.TexStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glTexStorage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
-{
-    d_4_3_Core->f.TexStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glTexBufferRange(GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size)
-{
-    d_4_3_Core->f.TexBufferRange(target, internalformat, buffer, offset, size);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glShaderStorageBlockBinding(GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding)
-{
-    d_4_3_Core->f.ShaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding);
-}
-
-inline GLint QOpenGLFunctions_4_5_Core::glGetProgramResourceLocationIndex(GLuint program, GLenum programInterface, const GLchar *name)
-{
-    return d_4_3_Core->f.GetProgramResourceLocationIndex(program, programInterface, name);
-}
-
-inline GLint QOpenGLFunctions_4_5_Core::glGetProgramResourceLocation(GLuint program, GLenum programInterface, const GLchar *name)
-{
-    return d_4_3_Core->f.GetProgramResourceLocation(program, programInterface, name);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetProgramResourceiv(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params)
-{
-    d_4_3_Core->f.GetProgramResourceiv(program, programInterface, index, propCount, props, bufSize, length, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetProgramResourceName(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name)
-{
-    d_4_3_Core->f.GetProgramResourceName(program, programInterface, index, bufSize, length, name);
-}
-
-inline GLuint QOpenGLFunctions_4_5_Core::glGetProgramResourceIndex(GLuint program, GLenum programInterface, const GLchar *name)
-{
-    return d_4_3_Core->f.GetProgramResourceIndex(program, programInterface, name);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetProgramInterfaceiv(GLuint program, GLenum programInterface, GLenum pname, GLint *params)
-{
-    d_4_3_Core->f.GetProgramInterfaceiv(program, programInterface, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glMultiDrawElementsIndirect(GLenum mode, GLenum type, const void *indirect, GLsizei drawcount, GLsizei stride)
-{
-    d_4_3_Core->f.MultiDrawElementsIndirect(mode, type, indirect, drawcount, stride);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glMultiDrawArraysIndirect(GLenum mode, const void *indirect, GLsizei drawcount, GLsizei stride)
-{
-    d_4_3_Core->f.MultiDrawArraysIndirect(mode, indirect, drawcount, stride);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glInvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_4_3_Core->f.InvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glInvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments)
-{
-    d_4_3_Core->f.InvalidateFramebuffer(target, numAttachments, attachments);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glInvalidateBufferData(GLuint buffer)
-{
-    d_4_3_Core->f.InvalidateBufferData(buffer);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glInvalidateBufferSubData(GLuint buffer, GLintptr offset, GLsizeiptr length)
-{
-    d_4_3_Core->f.InvalidateBufferSubData(buffer, offset, length);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glInvalidateTexImage(GLuint texture, GLint level)
-{
-    d_4_3_Core->f.InvalidateTexImage(texture, level);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glInvalidateTexSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth)
-{
-    d_4_3_Core->f.InvalidateTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetInternalformati64v(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint64 *params)
-{
-    d_4_3_Core->f.GetInternalformati64v(target, internalformat, pname, bufSize, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetFramebufferParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-    d_4_3_Core->f.GetFramebufferParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glFramebufferParameteri(GLenum target, GLenum pname, GLint param)
-{
-    d_4_3_Core->f.FramebufferParameteri(target, pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glCopyImageSubData(GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth)
-{
-    d_4_3_Core->f.CopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glDispatchComputeIndirect(GLintptr indirect)
-{
-    d_4_3_Core->f.DispatchComputeIndirect(indirect);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glDispatchCompute(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z)
-{
-    d_4_3_Core->f.DispatchCompute(num_groups_x, num_groups_y, num_groups_z);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glClearBufferSubData(GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data)
-{
-    d_4_3_Core->f.ClearBufferSubData(target, internalformat, offset, size, format, type, data);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glClearBufferData(GLenum target, GLenum internalformat, GLenum format, GLenum type, const void *data)
-{
-    d_4_3_Core->f.ClearBufferData(target, internalformat, format, type, data);
-}
-
-
-// OpenGL 4.4 core functions
-inline void QOpenGLFunctions_4_5_Core::glBindVertexBuffers(GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides)
-{
-    d_4_4_Core->f.BindVertexBuffers(first, count, buffers, offsets, strides);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glBindImageTextures(GLuint first, GLsizei count, const GLuint *textures)
-{
-    d_4_4_Core->f.BindImageTextures(first, count, textures);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glBindSamplers(GLuint first, GLsizei count, const GLuint *samplers)
-{
-    d_4_4_Core->f.BindSamplers(first, count, samplers);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glBindTextures(GLuint first, GLsizei count, const GLuint *textures)
-{
-    d_4_4_Core->f.BindTextures(first, count, textures);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glBindBuffersRange(GLenum target, GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizeiptr *sizes)
-{
-    d_4_4_Core->f.BindBuffersRange(target, first, count, buffers, offsets, sizes);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glBindBuffersBase(GLenum target, GLuint first, GLsizei count, const GLuint *buffers)
-{
-    d_4_4_Core->f.BindBuffersBase(target, first, count, buffers);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glClearTexSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *data)
-{
-    d_4_4_Core->f.ClearTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glClearTexImage(GLuint texture, GLint level, GLenum format, GLenum type, const void *data)
-{
-    d_4_4_Core->f.ClearTexImage(texture, level, format, type, data);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glBufferStorage(GLenum target, GLsizeiptr size, const void *data, GLbitfield flags)
-{
-    d_4_4_Core->f.BufferStorage(target, size, data, flags);
-}
-
-
-// OpenGL 4.5 core functions
-inline void QOpenGLFunctions_4_5_Core::glTextureBarrier()
-{
-    d_4_5_Core->f.TextureBarrier();
-}
-
-inline void QOpenGLFunctions_4_5_Core::glReadnPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data)
-{
-    d_4_5_Core->f.ReadnPixels(x, y, width, height, format, type, bufSize, data);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetnUniformuiv(GLuint program, GLint location, GLsizei bufSize, GLuint *params)
-{
-    d_4_5_Core->f.GetnUniformuiv(program, location, bufSize, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetnUniformiv(GLuint program, GLint location, GLsizei bufSize, GLint *params)
-{
-    d_4_5_Core->f.GetnUniformiv(program, location, bufSize, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetnUniformfv(GLuint program, GLint location, GLsizei bufSize, GLfloat *params)
-{
-    d_4_5_Core->f.GetnUniformfv(program, location, bufSize, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetnUniformdv(GLuint program, GLint location, GLsizei bufSize, GLdouble *params)
-{
-    d_4_5_Core->f.GetnUniformdv(program, location, bufSize, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetnTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, void *pixels)
-{
-    d_4_5_Core->f.GetnTexImage(target, level, format, type, bufSize, pixels);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetnCompressedTexImage(GLenum target, GLint lod, GLsizei bufSize, void *pixels)
-{
-    d_4_5_Core->f.GetnCompressedTexImage(target, lod, bufSize, pixels);
-}
-
-inline GLenum QOpenGLFunctions_4_5_Core::glGetGraphicsResetStatus()
-{
-    return d_4_5_Core->f.GetGraphicsResetStatus();
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetCompressedTextureSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei bufSize, void *pixels)
-{
-    d_4_5_Core->f.GetCompressedTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, bufSize, pixels);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetTextureSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLsizei bufSize, void *pixels)
-{
-    d_4_5_Core->f.GetTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bufSize, pixels);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glMemoryBarrierByRegion(GLbitfield barriers)
-{
-    d_4_5_Core->f.MemoryBarrierByRegion(barriers);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glCreateQueries(GLenum target, GLsizei n, GLuint *ids)
-{
-    d_4_5_Core->f.CreateQueries(target, n, ids);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glCreateProgramPipelines(GLsizei n, GLuint *pipelines)
-{
-    d_4_5_Core->f.CreateProgramPipelines(n, pipelines);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glCreateSamplers(GLsizei n, GLuint *samplers)
-{
-    d_4_5_Core->f.CreateSamplers(n, samplers);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetVertexArrayIndexed64iv(GLuint vaobj, GLuint index, GLenum pname, GLint64 *param)
-{
-    d_4_5_Core->f.GetVertexArrayIndexed64iv(vaobj, index, pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetVertexArrayIndexediv(GLuint vaobj, GLuint index, GLenum pname, GLint *param)
-{
-    d_4_5_Core->f.GetVertexArrayIndexediv(vaobj, index, pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetVertexArrayiv(GLuint vaobj, GLenum pname, GLint *param)
-{
-    d_4_5_Core->f.GetVertexArrayiv(vaobj, pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexArrayBindingDivisor(GLuint vaobj, GLuint bindingindex, GLuint divisor)
-{
-    d_4_5_Core->f.VertexArrayBindingDivisor(vaobj, bindingindex, divisor);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexArrayAttribLFormat(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
-{
-    d_4_5_Core->f.VertexArrayAttribLFormat(vaobj, attribindex, size, type, relativeoffset);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexArrayAttribIFormat(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
-{
-    d_4_5_Core->f.VertexArrayAttribIFormat(vaobj, attribindex, size, type, relativeoffset);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexArrayAttribFormat(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset)
-{
-    d_4_5_Core->f.VertexArrayAttribFormat(vaobj, attribindex, size, type, normalized, relativeoffset);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexArrayAttribBinding(GLuint vaobj, GLuint attribindex, GLuint bindingindex)
-{
-    d_4_5_Core->f.VertexArrayAttribBinding(vaobj, attribindex, bindingindex);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexArrayVertexBuffers(GLuint vaobj, GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides)
-{
-    d_4_5_Core->f.VertexArrayVertexBuffers(vaobj, first, count, buffers, offsets, strides);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexArrayVertexBuffer(GLuint vaobj, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride)
-{
-    d_4_5_Core->f.VertexArrayVertexBuffer(vaobj, bindingindex, buffer, offset, stride);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glVertexArrayElementBuffer(GLuint vaobj, GLuint buffer)
-{
-    d_4_5_Core->f.VertexArrayElementBuffer(vaobj, buffer);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glEnableVertexArrayAttrib(GLuint vaobj, GLuint index)
-{
-    d_4_5_Core->f.EnableVertexArrayAttrib(vaobj, index);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glDisableVertexArrayAttrib(GLuint vaobj, GLuint index)
-{
-    d_4_5_Core->f.DisableVertexArrayAttrib(vaobj, index);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glCreateVertexArrays(GLsizei n, GLuint *arrays)
-{
-    d_4_5_Core->f.CreateVertexArrays(n, arrays);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetTextureParameteriv(GLuint texture, GLenum pname, GLint *params)
-{
-    d_4_5_Core->f.GetTextureParameteriv(texture, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetTextureParameterIuiv(GLuint texture, GLenum pname, GLuint *params)
-{
-    d_4_5_Core->f.GetTextureParameterIuiv(texture, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetTextureParameterIiv(GLuint texture, GLenum pname, GLint *params)
-{
-    d_4_5_Core->f.GetTextureParameterIiv(texture, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetTextureParameterfv(GLuint texture, GLenum pname, GLfloat *params)
-{
-    d_4_5_Core->f.GetTextureParameterfv(texture, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetTextureLevelParameteriv(GLuint texture, GLint level, GLenum pname, GLint *params)
-{
-    d_4_5_Core->f.GetTextureLevelParameteriv(texture, level, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetTextureLevelParameterfv(GLuint texture, GLint level, GLenum pname, GLfloat *params)
-{
-    d_4_5_Core->f.GetTextureLevelParameterfv(texture, level, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetCompressedTextureImage(GLuint texture, GLint level, GLsizei bufSize, void *pixels)
-{
-    d_4_5_Core->f.GetCompressedTextureImage(texture, level, bufSize, pixels);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetTextureImage(GLuint texture, GLint level, GLenum format, GLenum type, GLsizei bufSize, void *pixels)
-{
-    d_4_5_Core->f.GetTextureImage(texture, level, format, type, bufSize, pixels);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glBindTextureUnit(GLuint unit, GLuint texture)
-{
-    d_4_5_Core->f.BindTextureUnit(unit, texture);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGenerateTextureMipmap(GLuint texture)
-{
-    d_4_5_Core->f.GenerateTextureMipmap(texture);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glTextureParameteriv(GLuint texture, GLenum pname, const GLint *param)
-{
-    d_4_5_Core->f.TextureParameteriv(texture, pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glTextureParameterIuiv(GLuint texture, GLenum pname, const GLuint *params)
-{
-    d_4_5_Core->f.TextureParameterIuiv(texture, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glTextureParameterIiv(GLuint texture, GLenum pname, const GLint *params)
-{
-    d_4_5_Core->f.TextureParameterIiv(texture, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glTextureParameteri(GLuint texture, GLenum pname, GLint param)
-{
-    d_4_5_Core->f.TextureParameteri(texture, pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glTextureParameterfv(GLuint texture, GLenum pname, const GLfloat *param)
-{
-    d_4_5_Core->f.TextureParameterfv(texture, pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glTextureParameterf(GLuint texture, GLenum pname, GLfloat param)
-{
-    d_4_5_Core->f.TextureParameterf(texture, pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glCopyTextureSubImage3D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_4_5_Core->f.CopyTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glCopyTextureSubImage2D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_4_5_Core->f.CopyTextureSubImage2D(texture, level, xoffset, yoffset, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glCopyTextureSubImage1D(GLuint texture, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
-{
-    d_4_5_Core->f.CopyTextureSubImage1D(texture, level, xoffset, x, y, width);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glCompressedTextureSubImage3D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data)
-{
-    d_4_5_Core->f.CompressedTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glCompressedTextureSubImage2D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data)
-{
-    d_4_5_Core->f.CompressedTextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glCompressedTextureSubImage1D(GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data)
-{
-    d_4_5_Core->f.CompressedTextureSubImage1D(texture, level, xoffset, width, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glTextureSubImage3D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels)
-{
-    d_4_5_Core->f.TextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glTextureSubImage2D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)
-{
-    d_4_5_Core->f.TextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glTextureSubImage1D(GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels)
-{
-    d_4_5_Core->f.TextureSubImage1D(texture, level, xoffset, width, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glTextureStorage3DMultisample(GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
-{
-    d_4_5_Core->f.TextureStorage3DMultisample(texture, samples, internalformat, width, height, depth, fixedsamplelocations);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glTextureStorage2DMultisample(GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
-{
-    d_4_5_Core->f.TextureStorage2DMultisample(texture, samples, internalformat, width, height, fixedsamplelocations);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glTextureStorage3D(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
-{
-    d_4_5_Core->f.TextureStorage3D(texture, levels, internalformat, width, height, depth);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glTextureStorage2D(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    d_4_5_Core->f.TextureStorage2D(texture, levels, internalformat, width, height);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glTextureStorage1D(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width)
-{
-    d_4_5_Core->f.TextureStorage1D(texture, levels, internalformat, width);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glTextureBufferRange(GLuint texture, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizei size)
-{
-    d_4_5_Core->f.TextureBufferRange(texture, internalformat, buffer, offset, size);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glTextureBuffer(GLuint texture, GLenum internalformat, GLuint buffer)
-{
-    d_4_5_Core->f.TextureBuffer(texture, internalformat, buffer);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glCreateTextures(GLenum target, GLsizei n, GLuint *textures)
-{
-    d_4_5_Core->f.CreateTextures(target, n, textures);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetNamedRenderbufferParameteriv(GLuint renderbuffer, GLenum pname, GLint *params)
-{
-    d_4_5_Core->f.GetNamedRenderbufferParameteriv(renderbuffer, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glNamedRenderbufferStorageMultisample(GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    d_4_5_Core->f.NamedRenderbufferStorageMultisample(renderbuffer, samples, internalformat, width, height);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glNamedRenderbufferStorage(GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    d_4_5_Core->f.NamedRenderbufferStorage(renderbuffer, internalformat, width, height);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glCreateRenderbuffers(GLsizei n, GLuint *renderbuffers)
-{
-    d_4_5_Core->f.CreateRenderbuffers(n, renderbuffers);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetNamedFramebufferAttachmentParameteriv(GLuint framebuffer, GLenum attachment, GLenum pname, GLint *params)
-{
-    d_4_5_Core->f.GetNamedFramebufferAttachmentParameteriv(framebuffer, attachment, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetNamedFramebufferParameteriv(GLuint framebuffer, GLenum pname, GLint *param)
-{
-    d_4_5_Core->f.GetNamedFramebufferParameteriv(framebuffer, pname, param);
-}
-
-inline GLenum QOpenGLFunctions_4_5_Core::glCheckNamedFramebufferStatus(GLuint framebuffer, GLenum target)
-{
-    return d_4_5_Core->f.CheckNamedFramebufferStatus(framebuffer, target);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glBlitNamedFramebuffer(GLuint readFramebuffer, GLuint drawFramebuffer, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
-{
-    d_4_5_Core->f.BlitNamedFramebuffer(readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glClearNamedFramebufferfi(GLuint framebuffer, GLenum buffer, GLfloat depth, GLint stencil)
-{
-    d_4_5_Core->f.ClearNamedFramebufferfi(framebuffer, buffer, depth, stencil);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glClearNamedFramebufferfv(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLfloat *value)
-{
-    d_4_5_Core->f.ClearNamedFramebufferfv(framebuffer, buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glClearNamedFramebufferuiv(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLuint *value)
-{
-    d_4_5_Core->f.ClearNamedFramebufferuiv(framebuffer, buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glClearNamedFramebufferiv(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLint *value)
-{
-    d_4_5_Core->f.ClearNamedFramebufferiv(framebuffer, buffer, drawbuffer, value);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glInvalidateNamedFramebufferSubData(GLuint framebuffer, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    d_4_5_Core->f.InvalidateNamedFramebufferSubData(framebuffer, numAttachments, attachments, x, y, width, height);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glInvalidateNamedFramebufferData(GLuint framebuffer, GLsizei numAttachments, const GLenum *attachments)
-{
-    d_4_5_Core->f.InvalidateNamedFramebufferData(framebuffer, numAttachments, attachments);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glNamedFramebufferReadBuffer(GLuint framebuffer, GLenum src)
-{
-    d_4_5_Core->f.NamedFramebufferReadBuffer(framebuffer, src);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glNamedFramebufferDrawBuffers(GLuint framebuffer, GLsizei n, const GLenum *bufs)
-{
-    d_4_5_Core->f.NamedFramebufferDrawBuffers(framebuffer, n, bufs);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glNamedFramebufferDrawBuffer(GLuint framebuffer, GLenum buf)
-{
-    d_4_5_Core->f.NamedFramebufferDrawBuffer(framebuffer, buf);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glNamedFramebufferTextureLayer(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer)
-{
-    d_4_5_Core->f.NamedFramebufferTextureLayer(framebuffer, attachment, texture, level, layer);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glNamedFramebufferTexture(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level)
-{
-    d_4_5_Core->f.NamedFramebufferTexture(framebuffer, attachment, texture, level);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glNamedFramebufferParameteri(GLuint framebuffer, GLenum pname, GLint param)
-{
-    d_4_5_Core->f.NamedFramebufferParameteri(framebuffer, pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glNamedFramebufferRenderbuffer(GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
-{
-    d_4_5_Core->f.NamedFramebufferRenderbuffer(framebuffer, attachment, renderbuffertarget, renderbuffer);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glCreateFramebuffers(GLsizei n, GLuint *framebuffers)
-{
-    d_4_5_Core->f.CreateFramebuffers(n, framebuffers);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetNamedBufferSubData(GLuint buffer, GLintptr offset, GLsizei size, void *data)
-{
-    d_4_5_Core->f.GetNamedBufferSubData(buffer, offset, size, data);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetNamedBufferPointerv(GLuint buffer, GLenum pname, void * *params)
-{
-    d_4_5_Core->f.GetNamedBufferPointerv(buffer, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetNamedBufferParameteri64v(GLuint buffer, GLenum pname, GLint64 *params)
-{
-    d_4_5_Core->f.GetNamedBufferParameteri64v(buffer, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetNamedBufferParameteriv(GLuint buffer, GLenum pname, GLint *params)
-{
-    d_4_5_Core->f.GetNamedBufferParameteriv(buffer, pname, params);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glFlushMappedNamedBufferRange(GLuint buffer, GLintptr offset, GLsizei length)
-{
-    d_4_5_Core->f.FlushMappedNamedBufferRange(buffer, offset, length);
-}
-
-inline GLboolean QOpenGLFunctions_4_5_Core::glUnmapNamedBuffer(GLuint buffer)
-{
-    return d_4_5_Core->f.UnmapNamedBuffer(buffer);
-}
-
-inline void * QOpenGLFunctions_4_5_Core::glMapNamedBufferRange(GLuint buffer, GLintptr offset, GLsizei length, GLbitfield access)
-{
-    return d_4_5_Core->f.MapNamedBufferRange(buffer, offset, length, access);
-}
-
-inline void * QOpenGLFunctions_4_5_Core::glMapNamedBuffer(GLuint buffer, GLenum access)
-{
-    return d_4_5_Core->f.MapNamedBuffer(buffer, access);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glClearNamedBufferSubData(GLuint buffer, GLenum internalformat, GLintptr offset, GLsizei size, GLenum format, GLenum type, const void *data)
-{
-    d_4_5_Core->f.ClearNamedBufferSubData(buffer, internalformat, offset, size, format, type, data);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glClearNamedBufferData(GLuint buffer, GLenum internalformat, GLenum format, GLenum type, const void *data)
-{
-    d_4_5_Core->f.ClearNamedBufferData(buffer, internalformat, format, type, data);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glCopyNamedBufferSubData(GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizei size)
-{
-    d_4_5_Core->f.CopyNamedBufferSubData(readBuffer, writeBuffer, readOffset, writeOffset, size);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glNamedBufferSubData(GLuint buffer, GLintptr offset, GLsizei size, const void *data)
-{
-    d_4_5_Core->f.NamedBufferSubData(buffer, offset, size, data);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glNamedBufferData(GLuint buffer, GLsizei size, const void *data, GLenum usage)
-{
-    d_4_5_Core->f.NamedBufferData(buffer, size, data, usage);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glNamedBufferStorage(GLuint buffer, GLsizei size, const void *data, GLbitfield flags)
-{
-    d_4_5_Core->f.NamedBufferStorage(buffer, size, data, flags);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glCreateBuffers(GLsizei n, GLuint *buffers)
-{
-    d_4_5_Core->f.CreateBuffers(n, buffers);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetTransformFeedbacki64_v(GLuint xfb, GLenum pname, GLuint index, GLint64 *param)
-{
-    d_4_5_Core->f.GetTransformFeedbacki64_v(xfb, pname, index, param);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetTransformFeedbacki_v(GLuint xfb, GLenum pname, GLuint index, GLint *param)
-{
-    d_4_5_Core->f.GetTransformFeedbacki_v(xfb, pname, index, param);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glGetTransformFeedbackiv(GLuint xfb, GLenum pname, GLint *param)
-{
-    d_4_5_Core->f.GetTransformFeedbackiv(xfb, pname, param);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glTransformFeedbackBufferRange(GLuint xfb, GLuint index, GLuint buffer, GLintptr offset, GLsizei size)
-{
-    d_4_5_Core->f.TransformFeedbackBufferRange(xfb, index, buffer, offset, size);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glTransformFeedbackBufferBase(GLuint xfb, GLuint index, GLuint buffer)
-{
-    d_4_5_Core->f.TransformFeedbackBufferBase(xfb, index, buffer);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glCreateTransformFeedbacks(GLsizei n, GLuint *ids)
-{
-    d_4_5_Core->f.CreateTransformFeedbacks(n, ids);
-}
-
-inline void QOpenGLFunctions_4_5_Core::glClipControl(GLenum origin, GLenum depth)
-{
-    d_4_5_Core->f.ClipControl(origin, depth);
-}
-
-
-
-QT_END_NAMESPACE
-
-#ifdef Q_OS_WIN
-#pragma pop_macro("MemoryBarrier")
-#endif
-
-
-#endif // QT_NO_OPENGL && !QT_OPENGL_ES_2
-
-#endif
diff --git a/src/gui/opengl/qopenglfunctions_es2.cpp b/src/gui/opengl/qopenglfunctions_es2.cpp
deleted file mode 100644
index dd2b3af80b..0000000000
--- a/src/gui/opengl/qopenglfunctions_es2.cpp
+++ /dev/null
@@ -1,106 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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 "qopenglfunctions_es2.h"
-#include "qopenglcontext.h"
-
-QT_BEGIN_NAMESPACE
-
-/*!
-    \class QOpenGLFunctions_ES2
-    \inmodule QtGui
-    \since 5.1
-    \wrapper
-    \brief The QOpenGLFunctions_ES2 class provides all functions for OpenGL ES 2.
-
-    This class is a wrapper for OpenGL ES 2 functions. See reference pages on
-    \l {http://www.khronos.org/opengles/sdk/docs/man/}{khronos.org} for
-    function documentation.
-
-    \sa QAbstractOpenGLFunctions
-*/
-
-QOpenGLFunctions_ES2::QOpenGLFunctions_ES2()
- : QAbstractOpenGLFunctions()
- , d_es2(0)
-{
-}
-
-QOpenGLFunctions_ES2::~QOpenGLFunctions_ES2()
-{
-}
-
-bool QOpenGLFunctions_ES2::initializeOpenGLFunctions()
-{
-    if ( isInitialized() )
-        return true;
-
-    QOpenGLContext* context = QOpenGLContext::currentContext();
-
-    // If owned by a context object make sure it is current.
-    // Also check that current context is compatible
-    if (((owningContext() && owningContext() == context) || !owningContext())
-        && QOpenGLFunctions_ES2::isContextCompatible(context))
-    {
-        // Nothing to do, just flag that we are initialized
-        QAbstractOpenGLFunctions::initializeOpenGLFunctions();
-    }
-    return isInitialized();
-}
-
-bool QOpenGLFunctions_ES2::isContextCompatible(QOpenGLContext *context)
-{
-    Q_ASSERT(context);
-    QSurfaceFormat f = context->format();
-    const QPair<int, int> v = qMakePair(f.majorVersion(), f.minorVersion());
-    if (v < qMakePair(2, 0))
-        return false;
-    if (f.renderableType() != QSurfaceFormat::OpenGLES)
-        return false;
-
-    return true;
-}
-
-QOpenGLVersionProfile QOpenGLFunctions_ES2::versionProfile()
-{
-    QOpenGLVersionProfile v;
-    return v;
-}
-
-QT_END_NAMESPACE
diff --git a/src/gui/opengl/qopenglfunctions_es2.h b/src/gui/opengl/qopenglfunctions_es2.h
deleted file mode 100644
index 851eb5951b..0000000000
--- a/src/gui/opengl/qopenglfunctions_es2.h
+++ /dev/null
@@ -1,931 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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 QOPENGLVERSIONFUNCTIONS_ES2_H
-#define QOPENGLVERSIONFUNCTIONS_ES2_H
-
-#include <QtGui/qtguiglobal.h>
-
-#if defined(QT_OPENGL_ES_2) || defined(Q_QDOC)
-
-#include <QtGui/QOpenGLVersionFunctions>
-#include <QtGui/qopenglcontext.h>
-
-QT_BEGIN_NAMESPACE
-
-class QOpenGLFunctions_ES2Private;
-
-class Q_GUI_EXPORT QOpenGLFunctions_ES2 : public QAbstractOpenGLFunctions
-{
-public:
-    QOpenGLFunctions_ES2();
-    ~QOpenGLFunctions_ES2();
-
-    bool initializeOpenGLFunctions() override;
-
-    // OpenGL ES2 core functions
-    void glActiveTexture(GLenum texture);
-    void glAttachShader(GLuint program, GLuint shader);
-    void glBindAttribLocation(GLuint program, GLuint index, const GLchar* name);
-    void glBindBuffer(GLenum target, GLuint buffer);
-    void glBindFramebuffer(GLenum target, GLuint framebuffer);
-    void glBindRenderbuffer(GLenum target, GLuint renderbuffer);
-    void glBindTexture(GLenum target, GLuint texture);
-    void glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
-    void glBlendEquation(GLenum mode);
-    void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha);
-    void glBlendFunc(GLenum sfactor, GLenum dfactor);
-    void glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
-    void glBufferData(GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage);
-    void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data);
-    GLenum glCheckFramebufferStatus(GLenum target);
-    void glClear(GLbitfield mask);
-    void glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
-    void glClearDepthf(GLclampf depth);
-    void glClearStencil(GLint s);
-    void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
-    void glCompileShader(GLuint shader);
-    void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data);
-    void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data);
-    void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
-    void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    GLuint glCreateProgram(void);
-    GLuint glCreateShader(GLenum type);
-    void glCullFace(GLenum mode);
-    void glDeleteBuffers(GLsizei n, const GLuint* buffers);
-    void glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers);
-    void glDeleteProgram(GLuint program);
-    void glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers);
-    void glDeleteShader(GLuint shader);
-    void glDeleteTextures(GLsizei n, const GLuint* textures);
-    void glDepthFunc(GLenum func);
-    void glDepthMask(GLboolean flag);
-    void glDepthRangef(GLclampf zNear, GLclampf zFar);
-    void glDetachShader(GLuint program, GLuint shader);
-    void glDisable(GLenum cap);
-    void glDisableVertexAttribArray(GLuint index);
-    void glDrawArrays(GLenum mode, GLint first, GLsizei count);
-    void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices);
-    void glEnable(GLenum cap);
-    void glEnableVertexAttribArray(GLuint index);
-    void glFinish(void);
-    void glFlush(void);
-    void glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
-    void glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
-    void glFrontFace(GLenum mode);
-    void glGenBuffers(GLsizei n, GLuint* buffers);
-    void glGenerateMipmap(GLenum target);
-    void glGenFramebuffers(GLsizei n, GLuint* framebuffers);
-    void glGenRenderbuffers(GLsizei n, GLuint* renderbuffers);
-    void glGenTextures(GLsizei n, GLuint* textures);
-    void glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name);
-    void glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name);
-    void glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders);
-    int glGetAttribLocation(GLuint program, const GLchar* name);
-    void glGetBooleanv(GLenum pname, GLboolean* params);
-    void glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params);
-    GLenum glGetError(void);
-    void glGetFloatv(GLenum pname, GLfloat* params);
-    void glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params);
-    void glGetIntegerv(GLenum pname, GLint* params);
-    void glGetProgramiv(GLuint program, GLenum pname, GLint* params);
-    void glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, GLchar* infolog);
-    void glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params);
-    void glGetShaderiv(GLuint shader, GLenum pname, GLint* params);
-    void glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* infolog);
-    void glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision);
-    void glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* source);
-    const GLubyte* glGetString(GLenum name);
-    void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params);
-    void glGetTexParameteriv(GLenum target, GLenum pname, GLint* params);
-    void glGetUniformfv(GLuint program, GLint location, GLfloat* params);
-    void glGetUniformiv(GLuint program, GLint location, GLint* params);
-    int glGetUniformLocation(GLuint program, const GLchar* name);
-    void glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params);
-    void glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params);
-    void glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid** pointer);
-    void glHint(GLenum target, GLenum mode);
-    GLboolean glIsBuffer(GLuint buffer);
-    GLboolean glIsEnabled(GLenum cap);
-    GLboolean glIsFramebuffer(GLuint framebuffer);
-    GLboolean glIsProgram(GLuint program);
-    GLboolean glIsRenderbuffer(GLuint renderbuffer);
-    GLboolean glIsShader(GLuint shader);
-    GLboolean glIsTexture(GLuint texture);
-    void glLineWidth(GLfloat width);
-    void glLinkProgram(GLuint program);
-    void glPixelStorei(GLenum pname, GLint param);
-    void glPolygonOffset(GLfloat factor, GLfloat units);
-    void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels);
-    void glReleaseShaderCompiler(void);
-    void glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
-    void glSampleCoverage(GLclampf value, GLboolean invert);
-    void glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
-    void glShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const GLvoid* binary, GLsizei length);
-    void glShaderSource(GLuint shader, GLsizei count, const GLchar* *string, const GLint* length);
-    void glStencilFunc(GLenum func, GLint ref, GLuint mask);
-    void glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask);
-    void glStencilMask(GLuint mask);
-    void glStencilMaskSeparate(GLenum face, GLuint mask);
-    void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass);
-    void glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass);
-    void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pixels);
-    void glTexParameterf(GLenum target, GLenum pname, GLfloat param);
-    void glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params);
-    void glTexParameteri(GLenum target, GLenum pname, GLint param);
-    void glTexParameteriv(GLenum target, GLenum pname, const GLint* params);
-    void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels);
-    void glUniform1f(GLint location, GLfloat x);
-    void glUniform1fv(GLint location, GLsizei count, const GLfloat* v);
-    void glUniform1i(GLint location, GLint x);
-    void glUniform1iv(GLint location, GLsizei count, const GLint* v);
-    void glUniform2f(GLint location, GLfloat x, GLfloat y);
-    void glUniform2fv(GLint location, GLsizei count, const GLfloat* v);
-    void glUniform2i(GLint location, GLint x, GLint y);
-    void glUniform2iv(GLint location, GLsizei count, const GLint* v);
-    void glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z);
-    void glUniform3fv(GLint location, GLsizei count, const GLfloat* v);
-    void glUniform3i(GLint location, GLint x, GLint y, GLint z);
-    void glUniform3iv(GLint location, GLsizei count, const GLint* v);
-    void glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void glUniform4fv(GLint location, GLsizei count, const GLfloat* v);
-    void glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w);
-    void glUniform4iv(GLint location, GLsizei count, const GLint* v);
-    void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
-    void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
-    void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
-    void glUseProgram(GLuint program);
-    void glValidateProgram(GLuint program);
-    void glVertexAttrib1f(GLuint indx, GLfloat x);
-    void glVertexAttrib1fv(GLuint indx, const GLfloat* values);
-    void glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y);
-    void glVertexAttrib2fv(GLuint indx, const GLfloat* values);
-    void glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z);
-    void glVertexAttrib3fv(GLuint indx, const GLfloat* values);
-    void glVertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void glVertexAttrib4fv(GLuint indx, const GLfloat* values);
-    void glVertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid* ptr);
-    void glViewport(GLint x, GLint y, GLsizei width, GLsizei height);
-
-private:
-    friend class QOpenGLContext;
-
-    static bool isContextCompatible(QOpenGLContext *context);
-    static QOpenGLVersionProfile versionProfile();
-
-    // For future expansion - not used
-    QOpenGLFunctions_ES2Private* d_es2;
-};
-
-// OpenGL ES2 core functions
-inline void QOpenGLFunctions_ES2::glActiveTexture(GLenum texture)
-{
-    ::glActiveTexture(texture);
-}
-
-inline void QOpenGLFunctions_ES2::glAttachShader(GLuint program, GLuint shader)
-{
-    ::glAttachShader(program, shader);
-}
-
-inline void QOpenGLFunctions_ES2::glBindAttribLocation(GLuint program, GLuint index, const GLchar* name)
-{
-    ::glBindAttribLocation(program, index, name);
-}
-
-inline void QOpenGLFunctions_ES2::glBindBuffer(GLenum target, GLuint buffer)
-{
-    ::glBindBuffer(target, buffer);
-}
-
-inline void QOpenGLFunctions_ES2::glBindFramebuffer(GLenum target, GLuint framebuffer)
-{
-    ::glBindFramebuffer(target, framebuffer);
-}
-
-inline void QOpenGLFunctions_ES2::glBindRenderbuffer(GLenum target, GLuint renderbuffer)
-{
-    ::glBindRenderbuffer(target, renderbuffer);
-}
-
-inline void QOpenGLFunctions_ES2::glBindTexture(GLenum target, GLuint texture)
-{
-    ::glBindTexture(target, texture);
-}
-
-inline void QOpenGLFunctions_ES2::glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
-{
-    ::glBlendColor(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_ES2::glBlendEquation(GLenum mode)
-{
-    ::glBlendEquation(mode);
-}
-
-inline void QOpenGLFunctions_ES2::glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
-{
-    ::glBlendEquationSeparate(modeRGB, modeAlpha);
-}
-
-inline void QOpenGLFunctions_ES2::glBlendFunc(GLenum sfactor, GLenum dfactor)
-{
-    ::glBlendFunc(sfactor, dfactor);
-}
-
-inline void QOpenGLFunctions_ES2::glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
-{
-    ::glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
-}
-
-inline void QOpenGLFunctions_ES2::glBufferData(GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage)
-{
-    ::glBufferData(target, size, data, usage);
-}
-
-inline void QOpenGLFunctions_ES2::glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data)
-{
-    ::glBufferSubData(target, offset, size, data);
-}
-
-inline GLenum QOpenGLFunctions_ES2::glCheckFramebufferStatus(GLenum target)
-{
-    return ::glCheckFramebufferStatus(target);
-}
-
-inline void QOpenGLFunctions_ES2::glClear(GLbitfield mask)
-{
-    ::glClear(mask);
-}
-
-inline void QOpenGLFunctions_ES2::glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
-{
-    ::glClearColor(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_ES2::glClearDepthf(GLclampf depth)
-{
-    ::glClearDepthf(depth);
-}
-
-inline void QOpenGLFunctions_ES2::glClearStencil(GLint s)
-{
-    ::glClearStencil(s);
-}
-
-inline void QOpenGLFunctions_ES2::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
-{
-    ::glColorMask(red, green, blue, alpha);
-}
-
-inline void QOpenGLFunctions_ES2::glCompileShader(GLuint shader)
-{
-    ::glCompileShader(shader);
-}
-
-inline void QOpenGLFunctions_ES2::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data)
-{
-    ::glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
-}
-
-inline void QOpenGLFunctions_ES2::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data)
-{
-    ::glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
-}
-
-inline void QOpenGLFunctions_ES2::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
-{
-    ::glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
-}
-
-inline void QOpenGLFunctions_ES2::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    ::glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
-}
-
-inline GLuint QOpenGLFunctions_ES2::glCreateProgram(void)
-{
-    return ::glCreateProgram();
-}
-
-inline GLuint QOpenGLFunctions_ES2::glCreateShader(GLenum type)
-{
-    return ::glCreateShader(type);
-}
-
-inline void QOpenGLFunctions_ES2::glCullFace(GLenum mode)
-{
-    ::glCullFace(mode);
-}
-
-inline void QOpenGLFunctions_ES2::glDeleteBuffers(GLsizei n, const GLuint* buffers)
-{
-    ::glDeleteBuffers(n, buffers);
-}
-
-inline void QOpenGLFunctions_ES2::glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers)
-{
-    ::glDeleteFramebuffers(n, framebuffers);
-}
-
-inline void QOpenGLFunctions_ES2::glDeleteProgram(GLuint program)
-{
-    ::glDeleteProgram(program);
-}
-
-inline void QOpenGLFunctions_ES2::glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers)
-{
-    ::glDeleteRenderbuffers(n, renderbuffers);
-}
-
-inline void QOpenGLFunctions_ES2::glDeleteShader(GLuint shader)
-{
-    ::glDeleteShader(shader);
-}
-
-inline void QOpenGLFunctions_ES2::glDeleteTextures(GLsizei n, const GLuint* textures)
-{
-    ::glDeleteTextures(n, textures);
-}
-
-inline void QOpenGLFunctions_ES2::glDepthFunc(GLenum func)
-{
-    ::glDepthFunc(func);
-}
-
-inline void QOpenGLFunctions_ES2::glDepthMask(GLboolean flag)
-{
-    ::glDepthMask(flag);
-}
-
-inline void QOpenGLFunctions_ES2::glDepthRangef(GLclampf zNear, GLclampf zFar)
-{
-    ::glDepthRangef(zNear, zFar);
-}
-
-inline void QOpenGLFunctions_ES2::glDetachShader(GLuint program, GLuint shader)
-{
-    ::glDetachShader(program, shader);
-}
-
-inline void QOpenGLFunctions_ES2::glDisable(GLenum cap)
-{
-    ::glDisable(cap);
-}
-
-inline void QOpenGLFunctions_ES2::glDisableVertexAttribArray(GLuint index)
-{
-    ::glDisableVertexAttribArray(index);
-}
-
-inline void QOpenGLFunctions_ES2::glDrawArrays(GLenum mode, GLint first, GLsizei count)
-{
-    ::glDrawArrays(mode, first, count);
-}
-
-inline void QOpenGLFunctions_ES2::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices)
-{
-    ::glDrawElements(mode, count, type, indices);
-}
-
-inline void QOpenGLFunctions_ES2::glEnable(GLenum cap)
-{
-    ::glEnable(cap);
-}
-
-inline void QOpenGLFunctions_ES2::glEnableVertexAttribArray(GLuint index)
-{
-    ::glEnableVertexAttribArray(index);
-}
-
-inline void QOpenGLFunctions_ES2::glFinish(void)
-{
-    ::glFinish();
-}
-
-inline void QOpenGLFunctions_ES2::glFlush(void)
-{
-    ::glFlush();
-}
-
-inline void QOpenGLFunctions_ES2::glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
-{
-    ::glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
-}
-
-inline void QOpenGLFunctions_ES2::glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
-{
-    ::glFramebufferTexture2D(target, attachment, textarget, texture, level);
-}
-
-inline void QOpenGLFunctions_ES2::glFrontFace(GLenum mode)
-{
-    ::glFrontFace(mode);
-}
-
-inline void QOpenGLFunctions_ES2::glGenBuffers(GLsizei n, GLuint* buffers)
-{
-    ::glGenBuffers(n, buffers);
-}
-
-inline void QOpenGLFunctions_ES2::glGenerateMipmap(GLenum target)
-{
-    ::glGenerateMipmap(target);
-}
-
-inline void QOpenGLFunctions_ES2::glGenFramebuffers(GLsizei n, GLuint* framebuffers)
-{
-    ::glGenFramebuffers(n, framebuffers);
-}
-
-inline void QOpenGLFunctions_ES2::glGenRenderbuffers(GLsizei n, GLuint* renderbuffers)
-{
-    ::glGenRenderbuffers(n, renderbuffers);
-}
-
-inline void QOpenGLFunctions_ES2::glGenTextures(GLsizei n, GLuint* textures)
-{
-    ::glGenTextures(n, textures);
-}
-
-inline void QOpenGLFunctions_ES2::glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name)
-{
-    ::glGetActiveAttrib(program, index, bufsize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_ES2::glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name)
-{
-    ::glGetActiveUniform(program, index, bufsize, length, size, type, name);
-}
-
-inline void QOpenGLFunctions_ES2::glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders)
-{
-    ::glGetAttachedShaders(program, maxcount, count, shaders);
-}
-
-inline int QOpenGLFunctions_ES2::glGetAttribLocation(GLuint program, const GLchar* name)
-{
-    return ::glGetAttribLocation(program, name);
-}
-
-inline void QOpenGLFunctions_ES2::glGetBooleanv(GLenum pname, GLboolean* params)
-{
-    ::glGetBooleanv(pname, params);
-}
-
-inline void QOpenGLFunctions_ES2::glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params)
-{
-    ::glGetBufferParameteriv(target, pname, params);
-}
-
-inline GLenum QOpenGLFunctions_ES2::glGetError(void)
-{
-    return ::glGetError();
-}
-
-inline void QOpenGLFunctions_ES2::glGetFloatv(GLenum pname, GLfloat* params)
-{
-    ::glGetFloatv(pname, params);
-}
-
-inline void QOpenGLFunctions_ES2::glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params)
-{
-    ::glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);
-}
-
-inline void QOpenGLFunctions_ES2::glGetIntegerv(GLenum pname, GLint* params)
-{
-    ::glGetIntegerv(pname, params);
-}
-
-inline void QOpenGLFunctions_ES2::glGetProgramiv(GLuint program, GLenum pname, GLint* params)
-{
-    ::glGetProgramiv(program, pname, params);
-}
-
-inline void QOpenGLFunctions_ES2::glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, GLchar* infolog)
-{
-    ::glGetProgramInfoLog(program, bufsize, length, infolog);
-}
-
-inline void QOpenGLFunctions_ES2::glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params)
-{
-    ::glGetRenderbufferParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_ES2::glGetShaderiv(GLuint shader, GLenum pname, GLint* params)
-{
-    ::glGetShaderiv(shader, pname, params);
-}
-
-inline void QOpenGLFunctions_ES2::glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* infolog)
-{
-    ::glGetShaderInfoLog(shader, bufsize, length, infolog);
-}
-
-inline void QOpenGLFunctions_ES2::glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision)
-{
-    ::glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
-}
-
-inline void QOpenGLFunctions_ES2::glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* source)
-{
-    ::glGetShaderSource(shader, bufsize, length, source);
-}
-
-inline const GLubyte* QOpenGLFunctions_ES2::glGetString(GLenum name)
-{
-    return ::glGetString(name);
-}
-
-inline void QOpenGLFunctions_ES2::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
-{
-    ::glGetTexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_ES2::glGetTexParameteriv(GLenum target, GLenum pname, GLint* params)
-{
-    ::glGetTexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_ES2::glGetUniformfv(GLuint program, GLint location, GLfloat* params)
-{
-    ::glGetUniformfv(program, location, params);
-}
-
-inline void QOpenGLFunctions_ES2::glGetUniformiv(GLuint program, GLint location, GLint* params)
-{
-    ::glGetUniformiv(program, location, params);
-}
-
-inline int QOpenGLFunctions_ES2::glGetUniformLocation(GLuint program, const GLchar* name)
-{
-    return ::glGetUniformLocation(program, name);
-}
-
-inline void QOpenGLFunctions_ES2::glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params)
-{
-    ::glGetVertexAttribfv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_ES2::glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params)
-{
-    ::glGetVertexAttribiv(index, pname, params);
-}
-
-inline void QOpenGLFunctions_ES2::glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid** pointer)
-{
-    ::glGetVertexAttribPointerv(index, pname, pointer);
-}
-
-inline void QOpenGLFunctions_ES2::glHint(GLenum target, GLenum mode)
-{
-    ::glHint(target, mode);
-}
-
-inline GLboolean QOpenGLFunctions_ES2::glIsBuffer(GLuint buffer)
-{
-    return ::glIsBuffer(buffer);
-}
-
-inline GLboolean QOpenGLFunctions_ES2::glIsEnabled(GLenum cap)
-{
-    return ::glIsEnabled(cap);
-}
-
-inline GLboolean QOpenGLFunctions_ES2::glIsFramebuffer(GLuint framebuffer)
-{
-    return ::glIsFramebuffer(framebuffer);
-}
-
-inline GLboolean QOpenGLFunctions_ES2::glIsProgram(GLuint program)
-{
-    return ::glIsProgram(program);
-}
-
-inline GLboolean QOpenGLFunctions_ES2::glIsRenderbuffer(GLuint renderbuffer)
-{
-    return ::glIsRenderbuffer(renderbuffer);
-}
-
-inline GLboolean QOpenGLFunctions_ES2::glIsShader(GLuint shader)
-{
-    return ::glIsShader(shader);
-}
-
-inline GLboolean QOpenGLFunctions_ES2::glIsTexture(GLuint texture)
-{
-    return ::glIsTexture(texture);
-}
-
-inline void QOpenGLFunctions_ES2::glLineWidth(GLfloat width)
-{
-    ::glLineWidth(width);
-}
-
-inline void QOpenGLFunctions_ES2::glLinkProgram(GLuint program)
-{
-    ::glLinkProgram(program);
-}
-
-inline void QOpenGLFunctions_ES2::glPixelStorei(GLenum pname, GLint param)
-{
-    ::glPixelStorei(pname, param);
-}
-
-inline void QOpenGLFunctions_ES2::glPolygonOffset(GLfloat factor, GLfloat units)
-{
-    ::glPolygonOffset(factor, units);
-}
-
-inline void QOpenGLFunctions_ES2::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels)
-{
-    ::glReadPixels(x, y, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_ES2::glReleaseShaderCompiler(void)
-{
-    ::glReleaseShaderCompiler();
-}
-
-inline void QOpenGLFunctions_ES2::glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    ::glRenderbufferStorage(target, internalformat, width, height);
-}
-
-inline void QOpenGLFunctions_ES2::glSampleCoverage(GLclampf value, GLboolean invert)
-{
-    ::glSampleCoverage(value, invert);
-}
-
-inline void QOpenGLFunctions_ES2::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    ::glScissor(x, y, width, height);
-}
-
-inline void QOpenGLFunctions_ES2::glShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const GLvoid* binary, GLsizei length)
-{
-    ::glShaderBinary(n, shaders, binaryformat, binary, length);
-}
-
-inline void QOpenGLFunctions_ES2::glShaderSource(GLuint shader, GLsizei count, const GLchar* *string, const GLint* length)
-{
-    ::glShaderSource(shader, count, string, length);
-}
-
-inline void QOpenGLFunctions_ES2::glStencilFunc(GLenum func, GLint ref, GLuint mask)
-{
-    ::glStencilFunc(func, ref, mask);
-}
-
-inline void QOpenGLFunctions_ES2::glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
-{
-    ::glStencilFuncSeparate(face, func, ref, mask);
-}
-
-inline void QOpenGLFunctions_ES2::glStencilMask(GLuint mask)
-{
-    ::glStencilMask(mask);
-}
-
-inline void QOpenGLFunctions_ES2::glStencilMaskSeparate(GLenum face, GLuint mask)
-{
-    ::glStencilMaskSeparate(face, mask);
-}
-
-inline void QOpenGLFunctions_ES2::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
-{
-    ::glStencilOp(fail, zfail, zpass);
-}
-
-inline void QOpenGLFunctions_ES2::glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
-{
-    ::glStencilOpSeparate(face, fail, zfail, zpass);
-}
-
-inline void QOpenGLFunctions_ES2::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pixels)
-{
-    ::glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_ES2::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
-{
-    ::glTexParameterf(target, pname, param);
-}
-
-inline void QOpenGLFunctions_ES2::glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params)
-{
-    ::glTexParameterfv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_ES2::glTexParameteri(GLenum target, GLenum pname, GLint param)
-{
-    ::glTexParameteri(target, pname, param);
-}
-
-inline void QOpenGLFunctions_ES2::glTexParameteriv(GLenum target, GLenum pname, const GLint* params)
-{
-    ::glTexParameteriv(target, pname, params);
-}
-
-inline void QOpenGLFunctions_ES2::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels)
-{
-    ::glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
-}
-
-inline void QOpenGLFunctions_ES2::glUniform1f(GLint location, GLfloat x)
-{
-    ::glUniform1f(location, x);
-}
-
-inline void QOpenGLFunctions_ES2::glUniform1fv(GLint location, GLsizei count, const GLfloat* v)
-{
-    ::glUniform1fv(location, count, v);
-}
-
-inline void QOpenGLFunctions_ES2::glUniform1i(GLint location, GLint x)
-{
-    ::glUniform1i(location, x);
-}
-
-inline void QOpenGLFunctions_ES2::glUniform1iv(GLint location, GLsizei count, const GLint* v)
-{
-    ::glUniform1iv(location, count, v);
-}
-
-inline void QOpenGLFunctions_ES2::glUniform2f(GLint location, GLfloat x, GLfloat y)
-{
-    ::glUniform2f(location, x, y);
-}
-
-inline void QOpenGLFunctions_ES2::glUniform2fv(GLint location, GLsizei count, const GLfloat* v)
-{
-    ::glUniform2fv(location, count, v);
-}
-
-inline void QOpenGLFunctions_ES2::glUniform2i(GLint location, GLint x, GLint y)
-{
-    ::glUniform2i(location, x, y);
-}
-
-inline void QOpenGLFunctions_ES2::glUniform2iv(GLint location, GLsizei count, const GLint* v)
-{
-    ::glUniform2iv(location, count, v);
-}
-
-inline void QOpenGLFunctions_ES2::glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z)
-{
-    ::glUniform3f(location, x, y, z);
-}
-
-inline void QOpenGLFunctions_ES2::glUniform3fv(GLint location, GLsizei count, const GLfloat* v)
-{
-    ::glUniform3fv(location, count, v);
-}
-
-inline void QOpenGLFunctions_ES2::glUniform3i(GLint location, GLint x, GLint y, GLint z)
-{
-    ::glUniform3i(location, x, y, z);
-}
-
-inline void QOpenGLFunctions_ES2::glUniform3iv(GLint location, GLsizei count, const GLint* v)
-{
-    ::glUniform3iv(location, count, v);
-}
-
-inline void QOpenGLFunctions_ES2::glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    ::glUniform4f(location, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_ES2::glUniform4fv(GLint location, GLsizei count, const GLfloat* v)
-{
-    ::glUniform4fv(location, count, v);
-}
-
-inline void QOpenGLFunctions_ES2::glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w)
-{
-    ::glUniform4i(location, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_ES2::glUniform4iv(GLint location, GLsizei count, const GLint* v)
-{
-    ::glUniform4iv(location, count, v);
-}
-
-inline void QOpenGLFunctions_ES2::glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
-{
-    ::glUniformMatrix2fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_ES2::glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
-{
-    ::glUniformMatrix3fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_ES2::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
-{
-    ::glUniformMatrix4fv(location, count, transpose, value);
-}
-
-inline void QOpenGLFunctions_ES2::glUseProgram(GLuint program)
-{
-    ::glUseProgram(program);
-}
-
-inline void QOpenGLFunctions_ES2::glValidateProgram(GLuint program)
-{
-    ::glValidateProgram(program);
-}
-
-inline void QOpenGLFunctions_ES2::glVertexAttrib1f(GLuint indx, GLfloat x)
-{
-    ::glVertexAttrib1f(indx, x);
-}
-
-inline void QOpenGLFunctions_ES2::glVertexAttrib1fv(GLuint indx, const GLfloat* values)
-{
-    ::glVertexAttrib1fv(indx, values);
-}
-
-inline void QOpenGLFunctions_ES2::glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y)
-{
-    ::glVertexAttrib2f(indx, x, y);
-}
-
-inline void QOpenGLFunctions_ES2::glVertexAttrib2fv(GLuint indx, const GLfloat* values)
-{
-    ::glVertexAttrib2fv(indx, values);
-}
-
-inline void QOpenGLFunctions_ES2::glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z)
-{
-    ::glVertexAttrib3f(indx, x, y, z);
-}
-
-inline void QOpenGLFunctions_ES2::glVertexAttrib3fv(GLuint indx, const GLfloat* values)
-{
-    ::glVertexAttrib3fv(indx, values);
-}
-
-inline void QOpenGLFunctions_ES2::glVertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    ::glVertexAttrib4f(indx, x, y, z, w);
-}
-
-inline void QOpenGLFunctions_ES2::glVertexAttrib4fv(GLuint indx, const GLfloat* values)
-{
-    ::glVertexAttrib4fv(indx, values);
-}
-
-inline void QOpenGLFunctions_ES2::glVertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid* ptr)
-{
-    ::glVertexAttribPointer(indx, size, type, normalized, stride, ptr);
-}
-
-inline void QOpenGLFunctions_ES2::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    ::glViewport(x, y, width, height);
-}
-
-QT_END_NAMESPACE
-
-#endif // QT_OPENGL_ES_2
-
-#endif
diff --git a/src/gui/opengl/qopenglgradientcache.cpp b/src/gui/opengl/qopenglgradientcache.cpp
deleted file mode 100644
index 3aa4c0d2e6..0000000000
--- a/src/gui/opengl/qopenglgradientcache.cpp
+++ /dev/null
@@ -1,276 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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 "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/gui/opengl/qopenglgradientcache_p.h b/src/gui/opengl/qopenglgradientcache_p.h
deleted file mode 100644
index 1d34223bdd..0000000000
--- a/src/gui/opengl/qopenglgradientcache_p.h
+++ /dev/null
@@ -1,108 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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 <QtGui/private/qtguiglobal_p.h>
-#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/gui/opengl/qopenglpaintdevice.cpp b/src/gui/opengl/qopenglpaintdevice.cpp
deleted file mode 100644
index 3920a10467..0000000000
--- a/src/gui/opengl/qopenglpaintdevice.cpp
+++ /dev/null
@@ -1,372 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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 QtGui
-
-    \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/gui/opengl/qopenglpaintdevice.h b/src/gui/opengl/qopenglpaintdevice.h
deleted file mode 100644
index 54118f2926..0000000000
--- a/src/gui/opengl/qopenglpaintdevice.h
+++ /dev/null
@@ -1,95 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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 <QtGui/qtguiglobal.h>
-
-#ifndef QT_NO_OPENGL
-
-#include <QtGui/qpaintdevice.h>
-#include <QtGui/qopengl.h>
-#include <QtGui/qopenglcontext.h>
-
-QT_BEGIN_NAMESPACE
-
-class QOpenGLPaintDevicePrivate;
-
-class Q_GUI_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/gui/opengl/qopenglpaintdevice_p.h b/src/gui/opengl/qopenglpaintdevice_p.h
deleted file mode 100644
index 3683ebebac..0000000000
--- a/src/gui/opengl/qopenglpaintdevice_p.h
+++ /dev/null
@@ -1,88 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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 <QtGui/private/qtguiglobal_p.h>
-#include <qopenglpaintdevice.h>
-
-QT_BEGIN_NAMESPACE
-
-class QOpenGLContext;
-class QPaintEngine;
-
-class Q_GUI_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/gui/opengl/qopenglpaintengine.cpp b/src/gui/opengl/qopenglpaintengine.cpp
deleted file mode 100644
index a82edbb073..0000000000
--- a/src/gui/opengl/qopenglpaintengine.cpp
+++ /dev/null
@@ -1,2701 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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 "qopenglgradientcache_p.h"
-#include "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 "qopenglengineshadermanager_p.h"
-#include "qopengl2pexvertexarray_p.h"
-#include "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_GUI_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)))
-{
-}
-
-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 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/gui/opengl/qopenglpaintengine_p.h b/src/gui/opengl/qopenglpaintengine_p.h
deleted file mode 100644
index 81f17572b2..0000000000
--- a/src/gui/opengl/qopenglpaintengine_p.h
+++ /dev/null
@@ -1,396 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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 <QtGui/private/qtguiglobal_p.h>
-#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_GUI_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/gui/opengl/qopenglpixeltransferoptions.cpp b/src/gui/opengl/qopenglpixeltransferoptions.cpp
deleted file mode 100644
index b0d953d76b..0000000000
--- a/src/gui/opengl/qopenglpixeltransferoptions.cpp
+++ /dev/null
@@ -1,263 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB).
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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 "qopenglpixeltransferoptions.h"
-#include <QSharedData>
-
-QT_BEGIN_NAMESPACE
-
-/*!
- * \class QOpenGLPixelTransferOptions
- *
- * \brief The QOpenGLPixelTransferOptions class describes the pixel storage
- * modes that affect the unpacking of pixels during texture upload.
- */
-
-/*!
- * \fn QOpenGLPixelTransferOptions & QOpenGLPixelTransferOptions::operator=(QOpenGLPixelTransferOptions &&other)
- * \internal
- */
-
-/*!
- * \fn void QOpenGLPixelTransferOptions::swap(QOpenGLPixelTransferOptions &other)
- * \internal
- */
-
-class QOpenGLPixelTransferOptionsData : public QSharedData
-{
-public:
-    QOpenGLPixelTransferOptionsData()
-        : alignment(4)
-        , skipImages(0)
-        , skipRows(0)
-        , skipPixels(0)
-        , imageHeight(0)
-        , rowLength(0)
-        , lsbFirst(false)
-        , swapBytes(false)
-    {}
-
-    int alignment;
-    int skipImages;
-    int skipRows;
-    int skipPixels;
-    int imageHeight;
-    int rowLength;
-    bool lsbFirst;
-    bool swapBytes;
-};
-
-/*!
- * Constructs a new QOpenGLPixelTransferOptions instance with the default settings.
- */
-QOpenGLPixelTransferOptions::QOpenGLPixelTransferOptions()
-    : data(new QOpenGLPixelTransferOptionsData)
-{
-}
-
-/*!
- * \internal
- */
-QOpenGLPixelTransferOptions::QOpenGLPixelTransferOptions(const QOpenGLPixelTransferOptions &rhs)
-    : data(rhs.data)
-{
-}
-
-/*!
- * \internal
- */
-QOpenGLPixelTransferOptions &QOpenGLPixelTransferOptions::operator=(const QOpenGLPixelTransferOptions &rhs)
-{
-    if (this != &rhs)
-        data.operator=(rhs.data);
-    return *this;
-}
-
-/*!
- * Destructor.
- */
-QOpenGLPixelTransferOptions::~QOpenGLPixelTransferOptions()
-{
-}
-
-/*!
- * Sets the \a alignment requirements for each pixel row. Corresponds to \c GL_UNPACK_ALIGNMENT.
- * The default value is 4, as specified by OpenGL.
- */
-void QOpenGLPixelTransferOptions::setAlignment(int alignment)
-{
-    data->alignment = alignment;
-}
-
-/*!
- * \return the current alignment requirement for each pixel row.
- */
-int QOpenGLPixelTransferOptions::alignment() const
-{
-    return data->alignment;
-}
-
-/*!
- * Sets the number of images that are skipped to \a skipImages.
- * Corresponds to \c GL_UNPACK_SKIP_IMAGES. Equivalent to incrementing the pointer
- * passed to QOpenGLTexture::setData(). The default value is 0.
- */
-void QOpenGLPixelTransferOptions::setSkipImages(int skipImages)
-{
-    data->skipImages = skipImages;
-}
-
-/*!
- * \return the number of images that are skipped.
- */
-int QOpenGLPixelTransferOptions::skipImages() const
-{
-    return data->skipImages;
-}
-
-/*!
- * Sets the number of rows that are skipped to \a skipRows.
- * Corresponds to \c GL_UNPACK_SKIP_ROWS. Equivalent to incrementing the pointer
- * passed to QOpenGLTexture::setData(). The default value is 0.
- */
-void QOpenGLPixelTransferOptions::setSkipRows(int skipRows)
-{
-    data->skipRows = skipRows;
-}
-
-/*!
- * \return the number of rows that are skipped.
- */
-int QOpenGLPixelTransferOptions::skipRows() const
-{
-    return data->skipRows;
-}
-
-/*!
- * Sets the number of pixels that are skipped to \a skipPixels.
- * Corresponds to \c GL_UNPACK_SKIP_PIXELS. Equivalent to incrementing the pointer
- * passed to QOpenGLTexture::setData(). The default value is 0.
- */
-void QOpenGLPixelTransferOptions::setSkipPixels(int skipPixels)
-{
-    data->skipPixels = skipPixels;
-}
-
-/*!
- * \return the number of pixels that are skipped.
- */
-int QOpenGLPixelTransferOptions::skipPixels() const
-{
-    return data->skipPixels;
-}
-
-/*!
- * Sets the image height for 3D textures to \a imageHeight.
- * Corresponds to \c GL_UNPACK_IMAGE_HEIGHT.
- * The default value is 0.
- */
-void QOpenGLPixelTransferOptions::setImageHeight(int imageHeight)
-{
-    data->imageHeight = imageHeight;
-}
-
-/*!
- * \return the currently set image height.
- */
-int QOpenGLPixelTransferOptions::imageHeight() const
-{
-    return data->imageHeight;
-}
-
-/*!
- * Sets the number of pixels in a row to \a rowLength.
- * Corresponds to \c GL_UNPACK_ROW_LENGTH.
- * The default value is 0.
- */
-void QOpenGLPixelTransferOptions::setRowLength(int rowLength)
-{
-    data->rowLength = rowLength;
-}
-
-/*!
- * \return the currently set row length.
- */
-int QOpenGLPixelTransferOptions::rowLength() const
-{
-    return data->rowLength;
-}
-
-/*!
- * \a lsbFirst specifies if bits within a byte are ordered from least to most significat.
- * The default value is \c false, meaning that the first bit in each byte is the
- * most significant one. This is significant for bitmap data only.
- * Corresponds to \c GL_UNPACK_LSB_FIRST.
- */
-void QOpenGLPixelTransferOptions::setLeastSignificantByteFirst(bool lsbFirst)
-{
-    data->lsbFirst = lsbFirst;
-}
-
-/*!
- * \return \c true if bits within a byte are ordered from least to most significant.
- */
-bool QOpenGLPixelTransferOptions::isLeastSignificantBitFirst() const
-{
-    return data->lsbFirst;
-}
-
-/*!
- * \a swapBytes specifies if the byte ordering for multibyte components is reversed.
- * The default value is \c false.
- * Corresponds to \c GL_UNPACK_SWAP_BYTES.
- */
-void QOpenGLPixelTransferOptions::setSwapBytesEnabled(bool swapBytes)
-{
-    data->swapBytes = swapBytes;
-}
-
-/*!
- * \return \c true if the byte ordering for multibyte components is reversed.
- */
-bool QOpenGLPixelTransferOptions::isSwapBytesEnabled() const
-{
-    return data->swapBytes;
-}
-
-QT_END_NAMESPACE
diff --git a/src/gui/opengl/qopenglpixeltransferoptions.h b/src/gui/opengl/qopenglpixeltransferoptions.h
deleted file mode 100644
index 195543ae90..0000000000
--- a/src/gui/opengl/qopenglpixeltransferoptions.h
+++ /dev/null
@@ -1,100 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB).
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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 QOPENGLPIXELUPLOADOPTIONS_H
-#define QOPENGLPIXELUPLOADOPTIONS_H
-
-#include <QtGui/qtguiglobal.h>
-
-#if !defined(QT_NO_OPENGL)
-
-#include <QtCore/QSharedDataPointer>
-
-QT_BEGIN_NAMESPACE
-
-class QOpenGLPixelTransferOptionsData;
-
-class Q_GUI_EXPORT QOpenGLPixelTransferOptions
-{
-public:
-    QOpenGLPixelTransferOptions();
-    QOpenGLPixelTransferOptions(const QOpenGLPixelTransferOptions &);
-    QOpenGLPixelTransferOptions &operator=(QOpenGLPixelTransferOptions &&other) noexcept
-    { swap(other); return *this; }
-    QOpenGLPixelTransferOptions &operator=(const QOpenGLPixelTransferOptions &);
-    ~QOpenGLPixelTransferOptions();
-
-    void swap(QOpenGLPixelTransferOptions &other) noexcept
-    { data.swap(other.data); }
-
-    void setAlignment(int alignment);
-    int alignment() const;
-
-    void setSkipImages(int skipImages);
-    int skipImages() const;
-
-    void setSkipRows(int skipRows);
-    int skipRows() const;
-
-    void setSkipPixels(int skipPixels);
-    int skipPixels() const;
-
-    void setImageHeight(int imageHeight);
-    int imageHeight() const;
-
-    void setRowLength(int rowLength);
-    int rowLength() const;
-
-    void setLeastSignificantByteFirst(bool lsbFirst);
-    bool isLeastSignificantBitFirst() const;
-
-    void setSwapBytesEnabled(bool swapBytes);
-    bool isSwapBytesEnabled() const;
-
-private:
-    QSharedDataPointer<QOpenGLPixelTransferOptionsData> data;
-};
-
-Q_DECLARE_SHARED(QOpenGLPixelTransferOptions)
-
-QT_END_NAMESPACE
-
-#endif // QT_NO_OPENGL
-
-#endif // QOPENGLPIXELUPLOADOPTIONS_H
diff --git a/src/gui/opengl/qopenglprogrambinarycache.cpp b/src/gui/opengl/qopenglprogrambinarycache.cpp
index 72bdacf43f..28b09b553a 100644
--- a/src/gui/opengl/qopenglprogrambinarycache.cpp
+++ b/src/gui/opengl/qopenglprogrambinarycache.cpp
@@ -1,41 +1,5 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-****************************************************************************/
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
 #include "qopenglprogrambinarycache_p.h"
 #include <QOpenGLContext>
@@ -45,7 +9,6 @@
 #include <QDir>
 #include <QSaveFile>
 #include <QCoreApplication>
-#include <QLoggingCategory>
 #include <QCryptographicHash>
 
 #ifdef Q_OS_UNIX
@@ -55,6 +18,8 @@
 
 QT_BEGIN_NAMESPACE
 
+using namespace Qt::StringLiterals;
+
 Q_LOGGING_CATEGORY(lcOpenGLProgramDiskCache, "qt.opengl.diskcache")
 
 #ifndef GL_CONTEXT_LOST
@@ -118,22 +83,26 @@ static inline bool qt_ensureWritableDir(const QString &name)
 QOpenGLProgramBinaryCache::QOpenGLProgramBinaryCache()
     : m_cacheWritable(false)
 {
-    const QString subPath = QLatin1String("/qtshadercache-") + QSysInfo::buildAbi() + QLatin1Char('/');
+    const QString subPath = "/qtshadercache-"_L1 + QSysInfo::buildAbi() + u'/';
     const QString sharedCachePath = QStandardPaths::writableLocation(QStandardPaths::GenericCacheLocation);
+    m_globalCacheDir = sharedCachePath + subPath;
+    m_localCacheDir = QStandardPaths::writableLocation(QStandardPaths::CacheLocation) + subPath;
+
     if (!sharedCachePath.isEmpty()) {
-        m_cacheDir = sharedCachePath + subPath;
-        m_cacheWritable = qt_ensureWritableDir(m_cacheDir);
+        m_currentCacheDir = m_globalCacheDir;
+        m_cacheWritable = qt_ensureWritableDir(m_currentCacheDir);
     }
     if (!m_cacheWritable) {
-        m_cacheDir = QStandardPaths::writableLocation(QStandardPaths::CacheLocation) + subPath;
-        m_cacheWritable = qt_ensureWritableDir(m_cacheDir);
+        m_currentCacheDir = m_localCacheDir;
+        m_cacheWritable = qt_ensureWritableDir(m_currentCacheDir);
     }
-    qCDebug(lcOpenGLProgramDiskCache, "Cache location '%s' writable = %d", qPrintable(m_cacheDir), m_cacheWritable);
+
+    qCDebug(lcOpenGLProgramDiskCache, "Cache location '%s' writable = %d", qPrintable(m_currentCacheDir), m_cacheWritable);
 }
 
 QString QOpenGLProgramBinaryCache::cacheFileName(const QByteArray &cacheKey) const
 {
-    return m_cacheDir + QString::fromUtf8(cacheKey);
+    return m_currentCacheDir + QString::fromUtf8(cacheKey);
 }
 
 #define BASE_HEADER_SIZE (int(4 * sizeof(quint32)))
@@ -191,7 +160,7 @@ bool QOpenGLProgramBinaryCache::setProgramBinary(uint programId, uint blobFormat
         if (error == GL_NO_ERROR || error == GL_CONTEXT_LOST)
             break;
     }
-#if defined(QT_OPENGL_ES_2)
+#if QT_CONFIG(opengles2)
     if (context->isOpenGLES() && context->format().majorVersion() < 3) {
         initializeProgramBinaryOES(context);
         programBinaryOES(programId, blobFormat, p, blobSize);
@@ -362,6 +331,25 @@ static inline void writeStr(uchar **p, const QByteArray &str)
     *p += str.size();
 }
 
+static inline bool writeFile(const QString &filename, const QByteArray &data)
+{
+#if QT_CONFIG(temporaryfile)
+    QSaveFile f(filename);
+    if (f.open(QIODevice::WriteOnly | QIODevice::Truncate)) {
+        f.write(data);
+        if (f.commit())
+            return true;
+    }
+#else
+    QFile f(filename);
+    if (f.open(QIODevice::WriteOnly | QIODevice::Truncate)) {
+        if (f.write(data) == data.length())
+            return true;
+    }
+#endif
+    return false;
+}
+
 void QOpenGLProgramBinaryCache::save(const QByteArray &cacheKey, uint programId)
 {
     if (!m_cacheWritable)
@@ -413,7 +401,7 @@ void QOpenGLProgramBinaryCache::save(const QByteArray &cacheKey, uint programId)
         *p++ = 0;
 
     GLint outSize = 0;
-#if defined(QT_OPENGL_ES_2)
+#if QT_CONFIG(opengles2)
     if (context->isOpenGLES() && context->format().majorVersion() < 3) {
         QMutexLocker lock(&m_mutex);
         initializeProgramBinaryOES(context);
@@ -428,23 +416,23 @@ void QOpenGLProgramBinaryCache::save(const QByteArray &cacheKey, uint programId)
 
     writeUInt(&blobFormatPtr, blobFormat);
 
-#if QT_CONFIG(temporaryfile)
-    QSaveFile f(cacheFileName(cacheKey));
-    if (f.open(QIODevice::WriteOnly | QIODevice::Truncate)) {
-        f.write(blob);
-        if (!f.commit())
-#else
-    QFile f(cacheFileName(cacheKey));
-    if (f.open(QIODevice::WriteOnly | QIODevice::Truncate)) {
-        if (f.write(blob) < blob.length())
-#endif
-            qCDebug(lcOpenGLProgramDiskCache, "Failed to write %s to shader cache", qPrintable(f.fileName()));
-    } else {
-        qCDebug(lcOpenGLProgramDiskCache, "Failed to create %s in shader cache", qPrintable(f.fileName()));
+    QString filename = cacheFileName(cacheKey);
+    bool ok = writeFile(filename, blob);
+    if (!ok && m_currentCacheDir == m_globalCacheDir) {
+        m_currentCacheDir = m_localCacheDir;
+        m_cacheWritable = qt_ensureWritableDir(m_currentCacheDir);
+        qCDebug(lcOpenGLProgramDiskCache, "Cache location changed to '%s' writable = %d",
+                qPrintable(m_currentCacheDir), m_cacheWritable);
+        if (m_cacheWritable) {
+            filename = cacheFileName(cacheKey);
+            ok = writeFile(filename, blob);
+        }
     }
+    if (!ok)
+        qCDebug(lcOpenGLProgramDiskCache, "Failed to write %s to shader cache", qPrintable(filename));
 }
 
-#if defined(QT_OPENGL_ES_2)
+#if QT_CONFIG(opengles2)
 void QOpenGLProgramBinaryCache::initializeProgramBinaryOES(QOpenGLContext *context)
 {
     if (m_programBinaryOESInitialized)
diff --git a/src/gui/opengl/qopenglprogrambinarycache_p.h b/src/gui/opengl/qopenglprogrambinarycache_p.h
index f1cf24cd87..6a636fcf56 100644
--- a/src/gui/opengl/qopenglprogrambinarycache_p.h
+++ b/src/gui/opengl/qopenglprogrambinarycache_p.h
@@ -1,41 +1,5 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-****************************************************************************/
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
 #ifndef QOPENGLPROGRAMBINARYCACHE_P_H
 #define QOPENGLPROGRAMBINARYCACHE_P_H
@@ -54,8 +18,9 @@
 #include <QtGui/qtguiglobal.h>
 #include <QtCore/qcache.h>
 #include <QtCore/qmutex.h>
+#include <QtCore/QLoggingCategory>
 #include <QtGui/private/qopenglcontext_p.h>
-#include <QtGui/private/qshader_p.h>
+#include <rhi/qshader.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -63,10 +28,12 @@ QT_BEGIN_NAMESPACE
 // therefore stay independent from QOpenGLShader(Program). Must rely only on
 // QOpenGLContext/Functions.
 
-class QOpenGLProgramBinaryCache
+QT_DECLARE_EXPORTED_QT_LOGGING_CATEGORY(lcOpenGLProgramDiskCache, Q_GUI_EXPORT)
+
+class Q_GUI_EXPORT QOpenGLProgramBinaryCache
 {
 public:
-    struct ShaderDesc {
+    struct Q_GUI_EXPORT ShaderDesc {
         ShaderDesc() { }
         ShaderDesc(QShader::Stage stage, const QByteArray &source = QByteArray())
           : stage(stage), source(source)
@@ -74,8 +41,8 @@ public:
         QShader::Stage stage;
         QByteArray source;
     };
-    struct ProgramDesc {
-        QVector<ShaderDesc> shaders;
+    struct Q_GUI_EXPORT ProgramDesc {
+        QList<ShaderDesc> shaders;
         QByteArray cacheKey() const;
     };
 
@@ -89,7 +56,9 @@ private:
     bool verifyHeader(const QByteArray &buf) const;
     bool setProgramBinary(uint programId, uint blobFormat, const void *p, uint blobSize);
 
-    QString m_cacheDir;
+    QString m_globalCacheDir;
+    QString m_localCacheDir;
+    QString m_currentCacheDir;
     bool m_cacheWritable;
     struct MemCacheEntry {
         MemCacheEntry(const void *p, int size, uint format)
@@ -100,7 +69,7 @@ private:
         uint format;
     };
     QCache<QByteArray, MemCacheEntry> m_memCache;
-#if defined(QT_OPENGL_ES_2)
+#if QT_CONFIG(opengles2)
     void (QOPENGLF_APIENTRYP programBinaryOES)(GLuint program, GLenum binaryFormat, const GLvoid *binary, GLsizei length);
     void (QOPENGLF_APIENTRYP getProgramBinaryOES)(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, GLvoid *binary);
     void initializeProgramBinaryOES(QOpenGLContext *context);
@@ -114,7 +83,7 @@ private:
 // per-context basis, not just once per process. QOpenGLSharedResource enables this,
 // although it's once-per-sharing-context-group, not per-context. Still, this should
 // be good enough in practice.
-class QOpenGLProgramBinarySupportCheck : public QOpenGLSharedResource
+class Q_GUI_EXPORT QOpenGLProgramBinarySupportCheck : public QOpenGLSharedResource
 {
 public:
     QOpenGLProgramBinarySupportCheck(QOpenGLContext *context);
diff --git a/src/gui/opengl/qopenglshadercache_p.h b/src/gui/opengl/qopenglshadercache_p.h
deleted file mode 100644
index 0f730602b0..0000000000
--- a/src/gui/opengl/qopenglshadercache_p.h
+++ /dev/null
@@ -1,86 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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 <QtGui/private/qtguiglobal_p.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/gui/opengl/qopenglshaderprogram.cpp b/src/gui/opengl/qopenglshaderprogram.cpp
deleted file mode 100644
index 7e89d9c8d4..0000000000
--- a/src/gui/opengl/qopenglshaderprogram.cpp
+++ /dev/null
@@ -1,3812 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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 "qopenglshaderprogram.h"
-#include "qopenglprogrambinarycache_p.h"
-#include "qopenglextrafunctions.h"
-#include "private/qopenglcontext_p.h"
-#include <QtCore/private/qobject_p.h>
-#include <QtCore/qdebug.h>
-#include <QtCore/qfile.h>
-#include <QtCore/qvarlengtharray.h>
-#include <QtCore/qvector.h>
-#include <QtCore/qloggingcategory.h>
-#include <QtGui/qtransform.h>
-#include <QtGui/QColor>
-#include <QtGui/QSurfaceFormat>
-
-#if !defined(QT_OPENGL_ES_2)
-#include <QtGui/qopenglfunctions_4_0_core.h>
-#endif
-
-#include <algorithm>
-
-QT_BEGIN_NAMESPACE
-
-/*!
-    \class QOpenGLShaderProgram
-    \brief The QOpenGLShaderProgram class allows OpenGL shader programs to be linked and used.
-    \since 5.0
-    \ingroup painting-3D
-    \inmodule QtGui
-
-    \section1 Introduction
-
-    This class supports shader programs written in the OpenGL Shading
-    Language (GLSL) and in the OpenGL/ES Shading Language (GLSL/ES).
-
-    QOpenGLShader and QOpenGLShaderProgram shelter the programmer from the details of
-    compiling and linking vertex and fragment shaders.
-
-    The following example creates a vertex shader program using the
-    supplied source \c{code}.  Once compiled and linked, the shader
-    program is activated in the current QOpenGLContext by calling
-    QOpenGLShaderProgram::bind():
-
-    \snippet code/src_gui_qopenglshaderprogram.cpp 0
-
-    \section1 Writing Portable Shaders
-
-    Shader programs can be difficult to reuse across OpenGL implementations
-    because of varying levels of support for standard vertex attributes and
-    uniform variables.  In particular, GLSL/ES lacks all of the
-    standard variables that are present on desktop OpenGL systems:
-    \c{gl_Vertex}, \c{gl_Normal}, \c{gl_Color}, and so on.  Desktop OpenGL
-    lacks the variable qualifiers \c{highp}, \c{mediump}, and \c{lowp}.
-
-    The QOpenGLShaderProgram class makes the process of writing portable shaders
-    easier by prefixing all shader programs with the following lines on
-    desktop OpenGL:
-
-    \code
-    #define highp
-    #define mediump
-    #define lowp
-    \endcode
-
-    This makes it possible to run most GLSL/ES shader programs
-    on desktop systems.  The programmer should restrict themselves
-    to just features that are present in GLSL/ES, and avoid
-    standard variable names that only work on the desktop.
-
-    \section1 Simple Shader Example
-
-    \snippet code/src_gui_qopenglshaderprogram.cpp 1
-
-    With the above shader program active, we can draw a green triangle
-    as follows:
-
-    \snippet code/src_gui_qopenglshaderprogram.cpp 2
-
-    \section1 Binary Shaders and Programs
-
-    Binary shaders may be specified using \c{glShaderBinary()} on
-    the return value from QOpenGLShader::shaderId().  The QOpenGLShader instance
-    containing the binary can then be added to the shader program with
-    addShader() and linked in the usual fashion with link().
-
-    Binary programs may be specified using \c{glProgramBinaryOES()}
-    on the return value from programId().  Then the application should
-    call link(), which will notice that the program has already been
-    specified and linked, allowing other operations to be performed
-    on the shader program. The shader program's id can be explicitly
-    created using the create() function.
-
-    \section2 Caching Program Binaries
-
-    As of Qt 5.9, support for caching program binaries on disk is built in. To
-    enable this, switch to using addCacheableShaderFromSourceCode() and
-    addCacheableShaderFromSourceFile(). With an OpenGL ES 3.x context or support
-    for \c{GL_ARB_get_program_binary}, this will transparently cache program
-    binaries under QStandardPaths::GenericCacheLocation or
-    QStandardPaths::CacheLocation. When support is not available, calling the
-    cacheable function variants is equivalent to the normal ones.
-
-    \note Some drivers do not have any binary formats available, even though
-    they advertise the extension or offer OpenGL ES 3.0. In this case program
-    binary support will be disabled.
-
-    \sa QOpenGLShader
-*/
-
-/*!
-    \class QOpenGLShader
-    \brief The QOpenGLShader class allows OpenGL shaders to be compiled.
-    \since 5.0
-    \ingroup painting-3D
-    \inmodule QtGui
-
-    This class supports shaders written in the OpenGL Shading Language (GLSL)
-    and in the OpenGL/ES Shading Language (GLSL/ES).
-
-    QOpenGLShader and QOpenGLShaderProgram shelter the programmer from the details of
-    compiling and linking vertex and fragment shaders.
-
-    \sa QOpenGLShaderProgram
-*/
-
-/*!
-    \enum QOpenGLShader::ShaderTypeBit
-    This enum specifies the type of QOpenGLShader that is being created.
-
-    \value Vertex Vertex shader written in the OpenGL Shading Language (GLSL).
-    \value Fragment Fragment shader written in the OpenGL Shading Language (GLSL).
-    \value Geometry Geometry shaders written in the OpenGL Shading Language (GLSL)
-           (requires OpenGL >= 3.2 or OpenGL ES >= 3.2).
-    \value TessellationControl Tessellation control shaders written in the OpenGL
-           shading language (GLSL) (requires OpenGL >= 4.0 or OpenGL ES >= 3.2).
-    \value TessellationEvaluation Tessellation evaluation shaders written in the OpenGL
-           shading language (GLSL) (requires OpenGL >= 4.0 or OpenGL ES >= 3.2).
-    \value Compute Compute shaders written in the OpenGL shading language (GLSL)
-           (requires OpenGL >= 4.3 or OpenGL ES >= 3.1).
-*/
-
-Q_DECLARE_LOGGING_CATEGORY(lcOpenGLProgramDiskCache)
-
-// For GLES 3.1/3.2
-#ifndef GL_GEOMETRY_SHADER
-#define GL_GEOMETRY_SHADER         0x8DD9
-#endif
-#ifndef GL_TESS_CONTROL_SHADER
-#define GL_TESS_CONTROL_SHADER     0x8E88
-#endif
-#ifndef GL_TESS_EVALUATION_SHADER
-#define GL_TESS_EVALUATION_SHADER  0x8E87
-#endif
-#ifndef GL_COMPUTE_SHADER
-#define GL_COMPUTE_SHADER          0x91B9
-#endif
-#ifndef GL_MAX_GEOMETRY_OUTPUT_VERTICES
-#define GL_MAX_GEOMETRY_OUTPUT_VERTICES          0x8DE0
-#endif
-#ifndef GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS
-#define GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS  0x8DE1
-#endif
-#ifndef GL_PATCH_VERTICES
-#define GL_PATCH_VERTICES  0x8E72
-#endif
-#ifndef GL_PATCH_DEFAULT_OUTER_LEVEL
-#define GL_PATCH_DEFAULT_OUTER_LEVEL  0x8E74
-#endif
-#ifndef GL_PATCH_DEFAULT_INNER_LEVEL
-#define GL_PATCH_DEFAULT_INNER_LEVEL  0x8E73
-#endif
-
-#ifndef QT_OPENGL_ES_2
-static inline bool isFormatGLES(const QSurfaceFormat &f)
-{
-    return (f.renderableType() == QSurfaceFormat::OpenGLES);
-}
-#endif
-
-static inline bool supportsGeometry(const QSurfaceFormat &f)
-{
-    return f.version() >= qMakePair(3, 2);
-}
-
-static inline bool supportsCompute(const QSurfaceFormat &f)
-{
-#ifndef QT_OPENGL_ES_2
-    if (!isFormatGLES(f))
-        return f.version() >= qMakePair(4, 3);
-    else
-        return f.version() >= qMakePair(3, 1);
-#else
-    return f.version() >= qMakePair(3, 1);
-#endif
-}
-
-static inline bool supportsTessellation(const QSurfaceFormat &f)
-{
-#ifndef QT_OPENGL_ES_2
-    if (!isFormatGLES(f))
-        return f.version() >= qMakePair(4, 0);
-    else
-        return f.version() >= qMakePair(3, 2);
-#else
-    return f.version() >= qMakePair(3, 2);
-#endif
-}
-
-class QOpenGLShaderPrivate : public QObjectPrivate
-{
-    Q_DECLARE_PUBLIC(QOpenGLShader)
-public:
-    QOpenGLShaderPrivate(QOpenGLContext *ctx, QOpenGLShader::ShaderType type)
-        : shaderGuard(nullptr)
-        , shaderType(type)
-        , compiled(false)
-        , glfuncs(new QOpenGLExtraFunctions(ctx))
-        , supportsGeometryShaders(false)
-        , supportsTessellationShaders(false)
-        , supportsComputeShaders(false)
-    {
-        if (shaderType & QOpenGLShader::Geometry)
-            supportsGeometryShaders = supportsGeometry(ctx->format());
-        else if (shaderType & (QOpenGLShader::TessellationControl | QOpenGLShader::TessellationEvaluation))
-            supportsTessellationShaders = supportsTessellation(ctx->format());
-        else if (shaderType & QOpenGLShader::Compute)
-            supportsComputeShaders = supportsCompute(ctx->format());
-    }
-    ~QOpenGLShaderPrivate();
-
-    QOpenGLSharedResourceGuard *shaderGuard;
-    QOpenGLShader::ShaderType shaderType;
-    bool compiled;
-    QString log;
-
-    QOpenGLExtraFunctions *glfuncs;
-
-    // Support for geometry shaders
-    bool supportsGeometryShaders;
-    // Support for tessellation shaders
-    bool supportsTessellationShaders;
-    // Support for compute shaders
-    bool supportsComputeShaders;
-
-
-    bool create();
-    bool compile(QOpenGLShader *q);
-    void deleteShader();
-};
-
-namespace {
-    void freeShaderFunc(QOpenGLFunctions *funcs, GLuint id)
-    {
-        funcs->glDeleteShader(id);
-    }
-}
-
-QOpenGLShaderPrivate::~QOpenGLShaderPrivate()
-{
-    delete glfuncs;
-    if (shaderGuard)
-        shaderGuard->free();
-}
-
-bool QOpenGLShaderPrivate::create()
-{
-    QOpenGLContext *context = const_cast<QOpenGLContext *>(QOpenGLContext::currentContext());
-    if (!context)
-        return false;
-    GLuint shader = 0;
-    if (shaderType == QOpenGLShader::Vertex) {
-        shader = glfuncs->glCreateShader(GL_VERTEX_SHADER);
-    } else if (shaderType == QOpenGLShader::Geometry && supportsGeometryShaders) {
-        shader = glfuncs->glCreateShader(GL_GEOMETRY_SHADER);
-    } else if (shaderType == QOpenGLShader::TessellationControl && supportsTessellationShaders) {
-        shader = glfuncs->glCreateShader(GL_TESS_CONTROL_SHADER);
-    } else if (shaderType == QOpenGLShader::TessellationEvaluation && supportsTessellationShaders) {
-        shader = glfuncs->glCreateShader(GL_TESS_EVALUATION_SHADER);
-    } else if (shaderType == QOpenGLShader::Compute && supportsComputeShaders) {
-        shader = glfuncs->glCreateShader(GL_COMPUTE_SHADER);
-    } else if (shaderType == QOpenGLShader::Fragment) {
-        shader = glfuncs->glCreateShader(GL_FRAGMENT_SHADER);
-    }
-    if (!shader) {
-        qWarning("QOpenGLShader: could not create shader");
-        return false;
-    }
-    shaderGuard = new QOpenGLSharedResourceGuard(context, shader, freeShaderFunc);
-    return true;
-}
-
-bool QOpenGLShaderPrivate::compile(QOpenGLShader *q)
-{
-    GLuint shader = shaderGuard ? shaderGuard->id() : 0;
-    if (!shader)
-        return false;
-
-    // Try to compile shader
-    glfuncs->glCompileShader(shader);
-    GLint value = 0;
-
-    // Get compilation status
-    glfuncs->glGetShaderiv(shader, GL_COMPILE_STATUS, &value);
-    compiled = (value != 0);
-
-    if (!compiled) {
-        // Compilation failed, try to provide some information about the failure
-        QString name = q->objectName();
-
-        const char *types[] = {
-            "Fragment",
-            "Vertex",
-            "Geometry",
-            "Tessellation Control",
-            "Tessellation Evaluation",
-            "Compute",
-            ""
-        };
-
-        const char *type = types[6];
-        switch (shaderType) {
-        case QOpenGLShader::Fragment:
-            type = types[0]; break;
-        case QOpenGLShader::Vertex:
-            type = types[1]; break;
-        case QOpenGLShader::Geometry:
-            type = types[2]; break;
-        case QOpenGLShader::TessellationControl:
-            type = types[3]; break;
-        case QOpenGLShader::TessellationEvaluation:
-            type = types[4]; break;
-        case QOpenGLShader::Compute:
-            type = types[5]; break;
-        }
-
-        // Get info and source code lengths
-        GLint infoLogLength = 0;
-        GLint sourceCodeLength = 0;
-        char *logBuffer = nullptr;
-        char *sourceCodeBuffer = nullptr;
-
-        // Get the compilation info log
-        glfuncs->glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLogLength);
-
-        if (infoLogLength > 1) {
-            GLint temp;
-            logBuffer = new char [infoLogLength];
-            glfuncs->glGetShaderInfoLog(shader, infoLogLength, &temp, logBuffer);
-        }
-
-        // Get the source code
-        glfuncs->glGetShaderiv(shader, GL_SHADER_SOURCE_LENGTH, &sourceCodeLength);
-
-        if (sourceCodeLength > 1) {
-            GLint temp;
-            sourceCodeBuffer = new char [sourceCodeLength];
-            glfuncs->glGetShaderSource(shader, sourceCodeLength, &temp, sourceCodeBuffer);
-        }
-
-        if (logBuffer)
-            log = QString::fromLatin1(logBuffer);
-        else
-            log = QLatin1String("failed");
-
-        if (name.isEmpty())
-            qWarning("QOpenGLShader::compile(%s): %s", type, qPrintable(log));
-        else
-            qWarning("QOpenGLShader::compile(%s)[%s]: %s", type, qPrintable(name), qPrintable(log));
-
-        // Dump the source code if we got it
-        if (sourceCodeBuffer) {
-            qWarning("*** Problematic %s shader source code ***\n"
-                     "%ls\n"
-                     "***",
-                     type, qUtf16Printable(QString::fromLatin1(sourceCodeBuffer)));
-        }
-
-        // Cleanup
-        delete [] logBuffer;
-        delete [] sourceCodeBuffer;
-    }
-
-    return compiled;
-}
-
-void QOpenGLShaderPrivate::deleteShader()
-{
-    if (shaderGuard) {
-        shaderGuard->free();
-        shaderGuard = nullptr;
-    }
-}
-
-/*!
-    Constructs a new QOpenGLShader object of the specified \a type
-    and attaches it to \a parent.  If shader programs are not supported,
-    QOpenGLShaderProgram::hasOpenGLShaderPrograms() will return false.
-
-    This constructor is normally followed by a call to compileSourceCode()
-    or compileSourceFile().
-
-    The shader will be associated with the current QOpenGLContext.
-
-    \sa compileSourceCode(), compileSourceFile()
-*/
-QOpenGLShader::QOpenGLShader(QOpenGLShader::ShaderType type, QObject *parent)
-    : QObject(*new QOpenGLShaderPrivate(QOpenGLContext::currentContext(), type), parent)
-{
-    Q_D(QOpenGLShader);
-    d->create();
-}
-
-/*!
-    Deletes this shader.  If the shader has been attached to a
-    QOpenGLShaderProgram object, then the actual shader will stay around
-    until the QOpenGLShaderProgram is destroyed.
-*/
-QOpenGLShader::~QOpenGLShader()
-{
-}
-
-/*!
-    Returns the type of this shader.
-*/
-QOpenGLShader::ShaderType QOpenGLShader::shaderType() const
-{
-    Q_D(const QOpenGLShader);
-    return d->shaderType;
-}
-
-static const char qualifierDefines[] =
-    "#define lowp\n"
-    "#define mediump\n"
-    "#define highp\n";
-
-#if defined(QT_OPENGL_ES) && !defined(QT_OPENGL_FORCE_SHADER_DEFINES)
-// The "highp" qualifier doesn't exist in fragment shaders
-// on all ES platforms.  When it doesn't exist, use "mediump".
-#define QOpenGL_REDEFINE_HIGHP 1
-static const char redefineHighp[] =
-    "#ifndef GL_FRAGMENT_PRECISION_HIGH\n"
-    "#define highp mediump\n"
-    "#endif\n";
-#endif
-
-// Boiler-plate header to have the layout attributes available we need later
-static const char blendEquationAdvancedHeader[] =
-    "#ifdef GL_KHR_blend_equation_advanced\n"
-    "#extension GL_ARB_fragment_coord_conventions : enable\n"
-    "#extension GL_KHR_blend_equation_advanced : enable\n"
-    "#endif\n";
-
-struct QVersionDirectivePosition
-{
-    Q_DECL_CONSTEXPR QVersionDirectivePosition(int position = 0, int line = -1)
-        : position(position)
-        , line(line)
-    {
-    }
-
-    Q_DECL_CONSTEXPR bool hasPosition() const
-    {
-        return position > 0;
-    }
-
-    const int position;
-    const int line;
-};
-
-static QVersionDirectivePosition findVersionDirectivePosition(const char *source)
-{
-    Q_ASSERT(source);
-
-    // According to the GLSL spec the #version directive must not be
-    // preceded by anything but whitespace and comments.
-    // In order to not get confused by #version directives within a
-    // multiline comment, we need to do some minimal comment parsing
-    // while searching for the directive.
-    enum {
-        Normal,
-        StartOfLine,
-        PreprocessorDirective,
-        CommentStarting,
-        MultiLineComment,
-        SingleLineComment,
-        CommentEnding
-    } state = StartOfLine;
-
-    const char *c = source;
-    while (*c) {
-        switch (state) {
-        case PreprocessorDirective:
-            if (*c == ' ' || *c == '\t')
-                break;
-            if (!strncmp(c, "version", strlen("version"))) {
-                // Found version directive
-                c += strlen("version");
-                while (*c && *c != '\n')
-                    ++c;
-                int splitPosition = c - source + 1;
-                int linePosition = int(std::count(source, c, '\n')) + 1;
-                return QVersionDirectivePosition(splitPosition, linePosition);
-            } else if (*c == '/')
-                state = CommentStarting;
-            else if (*c == '\n')
-                state = StartOfLine;
-            else
-                state = Normal;
-            break;
-        case StartOfLine:
-            if (*c == ' ' || *c == '\t')
-                break;
-            else if (*c == '#') {
-                state = PreprocessorDirective;
-                break;
-            }
-            state = Normal;
-            Q_FALLTHROUGH();
-        case Normal:
-            if (*c == '/')
-                state = CommentStarting;
-            else if (*c == '\n')
-                state = StartOfLine;
-            break;
-        case CommentStarting:
-            if (*c == '*')
-                state = MultiLineComment;
-            else if (*c == '/')
-                state = SingleLineComment;
-            else
-                state = Normal;
-            break;
-        case MultiLineComment:
-            if (*c == '*')
-                state = CommentEnding;
-            break;
-        case SingleLineComment:
-            if (*c == '\n')
-                state = Normal;
-            break;
-        case CommentEnding:
-            if (*c == '/')
-                state = Normal;
-            else if (*c != QLatin1Char('*'))
-                state = MultiLineComment;
-            break;
-        }
-        ++c;
-    }
-
-    return QVersionDirectivePosition(0, 1);
-}
-
-/*!
-    Sets the \a source code for this shader and compiles it.
-    Returns \c true if the source was successfully compiled, false otherwise.
-
-    \sa compileSourceFile()
-*/
-bool QOpenGLShader::compileSourceCode(const char *source)
-{
-    Q_D(QOpenGLShader);
-    // This method breaks the shader code into two parts:
-    // 1. Up to and including an optional #version directive.
-    // 2. The rest.
-    // If a #version directive exists, qualifierDefines and redefineHighp
-    // are inserted after. Otherwise they are inserted right at the start.
-    // In both cases a #line directive is appended in order to compensate
-    // for line number changes in case of compiler errors.
-
-    if (d->shaderGuard && d->shaderGuard->id() && source) {
-        const QVersionDirectivePosition versionDirectivePosition = findVersionDirectivePosition(source);
-
-        QVarLengthArray<const char *, 5> sourceChunks;
-        QVarLengthArray<GLint, 5> sourceChunkLengths;
-        QOpenGLContext *ctx = QOpenGLContext::currentContext();
-
-        if (versionDirectivePosition.hasPosition()) {
-            // Append source up to and including the #version directive
-            sourceChunks.append(source);
-            sourceChunkLengths.append(GLint(versionDirectivePosition.position));
-        } else {
-            // QTBUG-55733: Intel on Windows with Compatibility profile requires a #version always
-            if (ctx->format().profile() == QSurfaceFormat::CompatibilityProfile) {
-                const char *vendor = reinterpret_cast<const char *>(ctx->functions()->glGetString(GL_VENDOR));
-                if (vendor && !strcmp(vendor, "Intel")) {
-                    static const char version110[] = "#version 110\n";
-                    sourceChunks.append(version110);
-                    sourceChunkLengths.append(GLint(sizeof(version110)) - 1);
-                }
-            }
-        }
-        if (d->shaderType == Fragment) {
-            sourceChunks.append(blendEquationAdvancedHeader);
-            sourceChunkLengths.append(GLint(sizeof(blendEquationAdvancedHeader) - 1));
-        }
-
-        // The precision qualifiers are useful on OpenGL/ES systems,
-        // but usually not present on desktop systems.
-        const QSurfaceFormat currentSurfaceFormat = ctx->format();
-        QOpenGLContextPrivate *ctx_d = QOpenGLContextPrivate::get(QOpenGLContext::currentContext());
-        if (currentSurfaceFormat.renderableType() == QSurfaceFormat::OpenGL
-                || ctx_d->workaround_missingPrecisionQualifiers
-#ifdef QT_OPENGL_FORCE_SHADER_DEFINES
-                || true
-#endif
-                ) {
-            sourceChunks.append(qualifierDefines);
-            sourceChunkLengths.append(GLint(sizeof(qualifierDefines) - 1));
-        }
-
-#ifdef QOpenGL_REDEFINE_HIGHP
-        if (d->shaderType == Fragment && !ctx_d->workaround_missingPrecisionQualifiers
-            && QOpenGLContext::currentContext()->isOpenGLES()) {
-            sourceChunks.append(redefineHighp);
-            sourceChunkLengths.append(GLint(sizeof(redefineHighp) - 1));
-        }
-#endif
-
-        QByteArray lineDirective;
-        // #line is rejected by some drivers:
-        // "2.1 Mesa 8.1-devel (git-48a3d4e)" or "MESA 2.1 Mesa 8.1-devel"
-        const char *version = reinterpret_cast<const char *>(ctx->functions()->glGetString(GL_VERSION));
-        if (!version || !strstr(version, "2.1 Mesa 8")) {
-            // Append #line directive in order to compensate for text insertion
-            lineDirective = QStringLiteral("#line %1\n").arg(versionDirectivePosition.line).toUtf8();
-            sourceChunks.append(lineDirective.constData());
-            sourceChunkLengths.append(GLint(lineDirective.length()));
-        }
-
-        // Append rest of shader code
-        sourceChunks.append(source + versionDirectivePosition.position);
-        sourceChunkLengths.append(GLint(qstrlen(source + versionDirectivePosition.position)));
-
-        d->glfuncs->glShaderSource(d->shaderGuard->id(), sourceChunks.size(), sourceChunks.data(), sourceChunkLengths.data());
-        return d->compile(this);
-    } else {
-        return false;
-    }
-}
-
-/*!
-    \overload
-
-    Sets the \a source code for this shader and compiles it.
-    Returns \c true if the source was successfully compiled, false otherwise.
-
-    \sa compileSourceFile()
-*/
-bool QOpenGLShader::compileSourceCode(const QByteArray& source)
-{
-    return compileSourceCode(source.constData());
-}
-
-/*!
-    \overload
-
-    Sets the \a source code for this shader and compiles it.
-    Returns \c true if the source was successfully compiled, false otherwise.
-
-    \sa compileSourceFile()
-*/
-bool QOpenGLShader::compileSourceCode(const QString& source)
-{
-    return compileSourceCode(source.toLatin1().constData());
-}
-
-/*!
-    Sets the source code for this shader to the contents of \a fileName
-    and compiles it.  Returns \c true if the file could be opened and the
-    source compiled, false otherwise.
-
-    \sa compileSourceCode()
-*/
-bool QOpenGLShader::compileSourceFile(const QString& fileName)
-{
-    QFile file(fileName);
-    if (!file.open(QFile::ReadOnly)) {
-        qWarning() << "QOpenGLShader: Unable to open file" << fileName;
-        return false;
-    }
-
-    QByteArray contents = file.readAll();
-    return compileSourceCode(contents.constData());
-}
-
-/*!
-    Returns the source code for this shader.
-
-    \sa compileSourceCode()
-*/
-QByteArray QOpenGLShader::sourceCode() const
-{
-    Q_D(const QOpenGLShader);
-    GLuint shader = d->shaderGuard ? d->shaderGuard->id() : 0;
-    if (!shader)
-        return QByteArray();
-    GLint size = 0;
-    d->glfuncs->glGetShaderiv(shader, GL_SHADER_SOURCE_LENGTH, &size);
-    if (size <= 0)
-        return QByteArray();
-    GLint len = 0;
-    char *source = new char [size];
-    d->glfuncs->glGetShaderSource(shader, size, &len, source);
-    QByteArray src(source);
-    delete [] source;
-    return src;
-}
-
-/*!
-    Returns \c true if this shader has been compiled; false otherwise.
-
-    \sa compileSourceCode(), compileSourceFile()
-*/
-bool QOpenGLShader::isCompiled() const
-{
-    Q_D(const QOpenGLShader);
-    return d->compiled;
-}
-
-/*!
-    Returns the errors and warnings that occurred during the last compile.
-
-    \sa compileSourceCode(), compileSourceFile()
-*/
-QString QOpenGLShader::log() const
-{
-    Q_D(const QOpenGLShader);
-    return d->log;
-}
-
-/*!
-    Returns the OpenGL identifier associated with this shader.
-
-    \sa QOpenGLShaderProgram::programId()
-*/
-GLuint QOpenGLShader::shaderId() const
-{
-    Q_D(const QOpenGLShader);
-    return d->shaderGuard ? d->shaderGuard->id() : 0;
-}
-
-class QOpenGLShaderProgramPrivate : public QObjectPrivate
-{
-    Q_DECLARE_PUBLIC(QOpenGLShaderProgram)
-public:
-    QOpenGLShaderProgramPrivate()
-        : programGuard(nullptr)
-        , linked(false)
-        , inited(false)
-        , removingShaders(false)
-        , glfuncs(new QOpenGLExtraFunctions)
-#ifndef QT_OPENGL_ES_2
-        , tessellationFuncs(nullptr)
-#endif
-        , linkBinaryRecursion(false)
-    {
-    }
-    ~QOpenGLShaderProgramPrivate();
-
-    QOpenGLSharedResourceGuard *programGuard;
-    bool linked;
-    bool inited;
-    bool removingShaders;
-
-    QString log;
-    QList<QOpenGLShader *> shaders;
-    QList<QOpenGLShader *> anonShaders;
-
-    QOpenGLExtraFunctions *glfuncs;
-#ifndef QT_OPENGL_ES_2
-    // for tessellation features not in GLES 3.2
-    QOpenGLFunctions_4_0_Core *tessellationFuncs;
-#endif
-
-    bool hasShader(QOpenGLShader::ShaderType type) const;
-
-    QOpenGLProgramBinaryCache::ProgramDesc binaryProgram;
-    bool isCacheDisabled() const;
-    bool compileCacheable();
-    bool linkBinary();
-
-    bool linkBinaryRecursion;
-};
-
-namespace {
-    void freeProgramFunc(QOpenGLFunctions *funcs, GLuint id)
-    {
-        funcs->glDeleteProgram(id);
-    }
-}
-
-
-QOpenGLShaderProgramPrivate::~QOpenGLShaderProgramPrivate()
-{
-    delete glfuncs;
-    if (programGuard)
-        programGuard->free();
-}
-
-bool QOpenGLShaderProgramPrivate::hasShader(QOpenGLShader::ShaderType type) const
-{
-    for (QOpenGLShader *shader : shaders) {
-        if (shader->shaderType() == type)
-            return true;
-    }
-    return false;
-}
-
-/*!
-    Constructs a new shader program and attaches it to \a parent.
-    The program will be invalid until addShader() is called.
-
-    The shader program will be associated with the current QOpenGLContext.
-
-    \sa addShader()
-*/
-QOpenGLShaderProgram::QOpenGLShaderProgram(QObject *parent)
-    : QObject(*new QOpenGLShaderProgramPrivate, parent)
-{
-}
-
-/*!
-    Deletes this shader program.
-*/
-QOpenGLShaderProgram::~QOpenGLShaderProgram()
-{
-}
-
-/*!
-    Requests the shader program's id to be created immediately. Returns \c true
-    if successful; \c false otherwise.
-
-    This function is primarily useful when combining QOpenGLShaderProgram
-    with other OpenGL functions that operate directly on the shader
-    program id, like \c {GL_OES_get_program_binary}.
-
-    When the shader program is used normally, the shader program's id will
-    be created on demand.
-
-    \sa programId()
-
-    \since 5.3
- */
-bool QOpenGLShaderProgram::create()
-{
-    return init();
-}
-
-bool QOpenGLShaderProgram::init()
-{
-    Q_D(QOpenGLShaderProgram);
-    if ((d->programGuard && d->programGuard->id()) || d->inited)
-        return true;
-    d->inited = true;
-    QOpenGLContext *context = const_cast<QOpenGLContext *>(QOpenGLContext::currentContext());
-    if (!context)
-        return false;
-    d->glfuncs->initializeOpenGLFunctions();
-
-#ifndef QT_OPENGL_ES_2
-    if (!context->isOpenGLES() && context->format().version() >= qMakePair(4, 0)) {
-        d->tessellationFuncs = context->versionFunctions<QOpenGLFunctions_4_0_Core>();
-        d->tessellationFuncs->initializeOpenGLFunctions();
-    }
-#endif
-
-    GLuint program = d->glfuncs->glCreateProgram();
-    if (!program) {
-        qWarning("QOpenGLShaderProgram: could not create shader program");
-        return false;
-    }
-    if (d->programGuard)
-        delete d->programGuard;
-    d->programGuard = new QOpenGLSharedResourceGuard(context, program, freeProgramFunc);
-    return true;
-}
-
-/*!
-    Adds a compiled \a shader to this shader program.  Returns \c true
-    if the shader could be added, or false otherwise.
-
-    Ownership of the \a shader object remains with the caller.
-    It will not be deleted when this QOpenGLShaderProgram instance
-    is deleted.  This allows the caller to add the same shader
-    to multiple shader programs.
-
-    \sa addShaderFromSourceCode(), addShaderFromSourceFile()
-    \sa removeShader(), link(), removeAllShaders()
-*/
-bool QOpenGLShaderProgram::addShader(QOpenGLShader *shader)
-{
-    Q_D(QOpenGLShaderProgram);
-    if (!init())
-        return false;
-    if (d->shaders.contains(shader))
-        return true;    // Already added to this shader program.
-    if (d->programGuard && d->programGuard->id() && shader) {
-        if (!shader->d_func()->shaderGuard || !shader->d_func()->shaderGuard->id())
-            return false;
-        if (d->programGuard->group() != shader->d_func()->shaderGuard->group()) {
-            qWarning("QOpenGLShaderProgram::addShader: Program and shader are not associated with same context.");
-            return false;
-        }
-        d->glfuncs->glAttachShader(d->programGuard->id(), shader->d_func()->shaderGuard->id());
-        d->linked = false;  // Program needs to be relinked.
-        d->shaders.append(shader);
-        connect(shader, SIGNAL(destroyed()), this, SLOT(shaderDestroyed()));
-        return true;
-    } else {
-        return false;
-    }
-}
-
-/*!
-    Compiles \a source as a shader of the specified \a type and
-    adds it to this shader program.  Returns \c true if compilation
-    was successful, false otherwise.  The compilation errors
-    and warnings will be made available via log().
-
-    This function is intended to be a short-cut for quickly
-    adding vertex and fragment shaders to a shader program without
-    creating an instance of QOpenGLShader first.
-
-    \sa addShader(), addShaderFromSourceFile()
-    \sa removeShader(), link(), log(), removeAllShaders()
-*/
-bool QOpenGLShaderProgram::addShaderFromSourceCode(QOpenGLShader::ShaderType type, const char *source)
-{
-    Q_D(QOpenGLShaderProgram);
-    if (!init())
-        return false;
-    QOpenGLShader *shader = new QOpenGLShader(type, this);
-    if (!shader->compileSourceCode(source)) {
-        d->log = shader->log();
-        delete shader;
-        return false;
-    }
-    d->anonShaders.append(shader);
-    return addShader(shader);
-}
-
-/*!
-    \overload
-
-    Compiles \a source as a shader of the specified \a type and
-    adds it to this shader program.  Returns \c true if compilation
-    was successful, false otherwise.  The compilation errors
-    and warnings will be made available via log().
-
-    This function is intended to be a short-cut for quickly
-    adding vertex and fragment shaders to a shader program without
-    creating an instance of QOpenGLShader first.
-
-    \sa addShader(), addShaderFromSourceFile()
-    \sa removeShader(), link(), log(), removeAllShaders()
-*/
-bool QOpenGLShaderProgram::addShaderFromSourceCode(QOpenGLShader::ShaderType type, const QByteArray& source)
-{
-    return addShaderFromSourceCode(type, source.constData());
-}
-
-/*!
-    \overload
-
-    Compiles \a source as a shader of the specified \a type and
-    adds it to this shader program.  Returns \c true if compilation
-    was successful, false otherwise.  The compilation errors
-    and warnings will be made available via log().
-
-    This function is intended to be a short-cut for quickly
-    adding vertex and fragment shaders to a shader program without
-    creating an instance of QOpenGLShader first.
-
-    \sa addShader(), addShaderFromSourceFile()
-    \sa removeShader(), link(), log(), removeAllShaders()
-*/
-bool QOpenGLShaderProgram::addShaderFromSourceCode(QOpenGLShader::ShaderType type, const QString& source)
-{
-    return addShaderFromSourceCode(type, source.toLatin1().constData());
-}
-
-/*!
-    Compiles the contents of \a fileName as a shader of the specified
-    \a type and adds it to this shader program.  Returns \c true if
-    compilation was successful, false otherwise.  The compilation errors
-    and warnings will be made available via log().
-
-    This function is intended to be a short-cut for quickly
-    adding vertex and fragment shaders to a shader program without
-    creating an instance of QOpenGLShader first.
-
-    \sa addShader(), addShaderFromSourceCode()
-*/
-bool QOpenGLShaderProgram::addShaderFromSourceFile
-    (QOpenGLShader::ShaderType type, const QString& fileName)
-{
-    Q_D(QOpenGLShaderProgram);
-    if (!init())
-        return false;
-    QOpenGLShader *shader = new QOpenGLShader(type, this);
-    if (!shader->compileSourceFile(fileName)) {
-        d->log = shader->log();
-        delete shader;
-        return false;
-    }
-    d->anonShaders.append(shader);
-    return addShader(shader);
-}
-
-/*!
-    Registers the shader of the specified \a type and \a source to this
-    program. Unlike addShaderFromSourceCode(), this function does not perform
-    compilation. Compilation is deferred to link(), and may not happen at all,
-    because link() may potentially use a program binary from Qt's shader disk
-    cache. This will typically lead to a significant increase in performance.
-
-    \return true if the shader has been registered or, in the non-cached case,
-    compiled successfully; false if there was an error. The compilation error
-    messages can be retrieved via log().
-
-    When the disk cache is disabled, via Qt::AA_DisableShaderDiskCache for
-    example, or the OpenGL context has no support for context binaries, calling
-    this function is equivalent to addShaderFromSourceCode().
-
-    \since 5.9
-    \sa addShaderFromSourceCode(), addCacheableShaderFromSourceFile()
- */
-bool QOpenGLShaderProgram::addCacheableShaderFromSourceCode(QOpenGLShader::ShaderType type, const char *source)
-{
-    Q_D(QOpenGLShaderProgram);
-    if (!init())
-        return false;
-    if (d->isCacheDisabled())
-        return addShaderFromSourceCode(type, source);
-
-    return addCacheableShaderFromSourceCode(type, QByteArray(source));
-}
-
-static inline QShader::Stage qt_shaderTypeToStage(QOpenGLShader::ShaderType type)
-{
-    switch (type) {
-    case QOpenGLShader::Vertex:
-        return QShader::VertexStage;
-    case QOpenGLShader::Fragment:
-        return QShader::FragmentStage;
-    case QOpenGLShader::Geometry:
-        return QShader::GeometryStage;
-    case QOpenGLShader::TessellationControl:
-        return QShader::TessellationControlStage;
-    case QOpenGLShader::TessellationEvaluation:
-        return QShader::TessellationEvaluationStage;
-    case QOpenGLShader::Compute:
-        return QShader::ComputeStage;
-    }
-    return QShader::VertexStage;
-}
-
-static inline QOpenGLShader::ShaderType qt_shaderStageToType(QShader::Stage stage)
-{
-    switch (stage) {
-    case QShader::VertexStage:
-        return QOpenGLShader::Vertex;
-    case QShader::TessellationControlStage:
-        return QOpenGLShader::TessellationControl;
-    case QShader::TessellationEvaluationStage:
-        return QOpenGLShader::TessellationEvaluation;
-    case QShader::GeometryStage:
-        return QOpenGLShader::Geometry;
-    case QShader::FragmentStage:
-        return QOpenGLShader::Fragment;
-    case QShader::ComputeStage:
-        return QOpenGLShader::Compute;
-    }
-    return QOpenGLShader::Vertex;
-}
-
-/*!
-    \overload
-
-    Registers the shader of the specified \a type and \a source to this
-    program. Unlike addShaderFromSourceCode(), this function does not perform
-    compilation. Compilation is deferred to link(), and may not happen at all,
-    because link() may potentially use a program binary from Qt's shader disk
-    cache. This will typically lead to a significant increase in performance.
-
-    \return true if the shader has been registered or, in the non-cached case,
-    compiled successfully; false if there was an error. The compilation error
-    messages can be retrieved via log().
-
-    When the disk cache is disabled, via Qt::AA_DisableShaderDiskCache for
-    example, or the OpenGL context has no support for context binaries, calling
-    this function is equivalent to addShaderFromSourceCode().
-
-    \since 5.9
-    \sa addShaderFromSourceCode(), addCacheableShaderFromSourceFile()
- */
-bool QOpenGLShaderProgram::addCacheableShaderFromSourceCode(QOpenGLShader::ShaderType type, const QByteArray &source)
-{
-    Q_D(QOpenGLShaderProgram);
-    if (!init())
-        return false;
-    if (d->isCacheDisabled())
-        return addShaderFromSourceCode(type, source);
-
-    d->binaryProgram.shaders.append(QOpenGLProgramBinaryCache::ShaderDesc(qt_shaderTypeToStage(type), source));
-    return true;
-}
-
-/*!
-    \overload
-
-    Registers the shader of the specified \a type and \a source to this
-    program. Unlike addShaderFromSourceCode(), this function does not perform
-    compilation. Compilation is deferred to link(), and may not happen at all,
-    because link() may potentially use a program binary from Qt's shader disk
-    cache. This will typically lead to a significant increase in performance.
-
-    When the disk cache is disabled, via Qt::AA_DisableShaderDiskCache for
-    example, or the OpenGL context has no support for context binaries, calling
-    this function is equivalent to addShaderFromSourceCode().
-
-    \since 5.9
-    \sa addShaderFromSourceCode(), addCacheableShaderFromSourceFile()
- */
-bool QOpenGLShaderProgram::addCacheableShaderFromSourceCode(QOpenGLShader::ShaderType type, const QString &source)
-{
-    Q_D(QOpenGLShaderProgram);
-    if (!init())
-        return false;
-    if (d->isCacheDisabled())
-        return addShaderFromSourceCode(type, source);
-
-    return addCacheableShaderFromSourceCode(type, source.toUtf8().constData());
-}
-
-/*!
-    Registers the shader of the specified \a type and \a fileName to this
-    program. Unlike addShaderFromSourceFile(), this function does not perform
-    compilation. Compilation is deferred to link(), and may not happen at all,
-    because link() may potentially use a program binary from Qt's shader disk
-    cache. This will typically lead to a significant increase in performance.
-
-    \return true if the file has been read successfully, false if the file could
-    not be opened or the normal, non-cached compilation of the shader has
-    failed. The compilation error messages can be retrieved via log().
-
-    When the disk cache is disabled, via Qt::AA_DisableShaderDiskCache for
-    example, or the OpenGL context has no support for context binaries, calling
-    this function is equivalent to addShaderFromSourceFile().
-
-    \since 5.9
-    \sa addShaderFromSourceFile(), addCacheableShaderFromSourceCode()
- */
-bool QOpenGLShaderProgram::addCacheableShaderFromSourceFile(QOpenGLShader::ShaderType type, const QString &fileName)
-{
-    Q_D(QOpenGLShaderProgram);
-    if (!init())
-        return false;
-    if (d->isCacheDisabled())
-        return addShaderFromSourceFile(type, fileName);
-
-    QOpenGLProgramBinaryCache::ShaderDesc shader(qt_shaderTypeToStage(type));
-    // NB! It could be tempting to defer reading the file contents and just
-    // hash the filename as the cache key, perhaps combined with last-modified
-    // timestamp checks. However, this would raise a number of issues (no
-    // timestamps for files in the resource system; preference for global, not
-    // per-application cache items (where filenames may clash); resource-based
-    // shaders from libraries like Qt Quick; etc.), so just avoid it.
-    QFile f(fileName);
-    if (f.open(QIODevice::ReadOnly | QIODevice::Text)) {
-        shader.source = f.readAll();
-        f.close();
-    } else {
-        qWarning("QOpenGLShaderProgram: Unable to open file %s", qPrintable(fileName));
-        return false;
-    }
-    d->binaryProgram.shaders.append(shader);
-    return true;
-}
-
-/*!
-    Removes \a shader from this shader program.  The object is not deleted.
-
-    The shader program must be valid in the current QOpenGLContext.
-
-    \sa addShader(), link(), removeAllShaders()
-*/
-void QOpenGLShaderProgram::removeShader(QOpenGLShader *shader)
-{
-    Q_D(QOpenGLShaderProgram);
-    if (d->programGuard && d->programGuard->id()
-        && shader && shader->d_func()->shaderGuard)
-    {
-        d->glfuncs->glDetachShader(d->programGuard->id(), shader->d_func()->shaderGuard->id());
-    }
-    d->linked = false;  // Program needs to be relinked.
-    if (shader) {
-        d->shaders.removeAll(shader);
-        d->anonShaders.removeAll(shader);
-        disconnect(shader, SIGNAL(destroyed()), this, SLOT(shaderDestroyed()));
-    }
-}
-
-/*!
-    Returns a list of all shaders that have been added to this shader
-    program using addShader().
-
-    \sa addShader(), removeShader()
-*/
-QList<QOpenGLShader *> QOpenGLShaderProgram::shaders() const
-{
-    Q_D(const QOpenGLShaderProgram);
-    return d->shaders;
-}
-
-/*!
-    Removes all of the shaders that were added to this program previously.
-    The QOpenGLShader objects for the shaders will not be deleted if they
-    were constructed externally.  QOpenGLShader objects that are constructed
-    internally by QOpenGLShaderProgram will be deleted.
-
-    \sa addShader(), removeShader()
-*/
-void QOpenGLShaderProgram::removeAllShaders()
-{
-    Q_D(QOpenGLShaderProgram);
-    d->removingShaders = true;
-    for (QOpenGLShader *shader : qAsConst(d->shaders)) {
-        if (d->programGuard && d->programGuard->id()
-            && shader && shader->d_func()->shaderGuard)
-        {
-            d->glfuncs->glDetachShader(d->programGuard->id(), shader->d_func()->shaderGuard->id());
-        }
-    }
-    // Delete shader objects that were created anonymously.
-    qDeleteAll(d->anonShaders);
-    d->shaders.clear();
-    d->anonShaders.clear();
-    d->binaryProgram = QOpenGLProgramBinaryCache::ProgramDesc();
-    d->linked = false;  // Program needs to be relinked.
-    d->removingShaders = false;
-}
-
-/*!
-    Links together the shaders that were added to this program with
-    addShader().  Returns \c true if the link was successful or
-    false otherwise.  If the link failed, the error messages can
-    be retrieved with log().
-
-    Subclasses can override this function to initialize attributes
-    and uniform variables for use in specific shader programs.
-
-    If the shader program was already linked, calling this
-    function again will force it to be re-linked.
-
-    When shaders were added to this program via
-    addCacheableShaderFromSourceCode() or addCacheableShaderFromSourceFile(),
-    program binaries are supported, and a cached binary is available on disk,
-    actual compilation and linking are skipped. Instead, link() will initialize
-    the program with the binary blob via glProgramBinary(). If there is no
-    cached version of the program or it was generated with a different driver
-    version, the shaders will be compiled from source and the program will get
-    linked normally. This allows seamless upgrading of the graphics drivers,
-    without having to worry about potentially incompatible binary formats.
-
-    \sa addShader(), log()
-*/
-bool QOpenGLShaderProgram::link()
-{
-    Q_D(QOpenGLShaderProgram);
-    GLuint program = d->programGuard ? d->programGuard->id() : 0;
-    if (!program)
-        return false;
-
-    if (!d->linkBinaryRecursion && d->shaders.isEmpty() && !d->binaryProgram.shaders.isEmpty())
-        return d->linkBinary();
-
-    GLint value;
-    if (d->shaders.isEmpty()) {
-        // If there are no explicit shaders, then it is possible that the
-        // application added a program binary with glProgramBinaryOES(), or
-        // otherwise populated the shaders itself. This is also the case when
-        // we are recursively called back from linkBinary() after a successful
-        // glProgramBinary(). Check to see if the program is already linked and
-        // bail out if so.
-        value = 0;
-        d->glfuncs->glGetProgramiv(program, GL_LINK_STATUS, &value);
-        d->linked = (value != 0);
-        if (d->linked)
-            return true;
-    }
-
-    d->glfuncs->glLinkProgram(program);
-    value = 0;
-    d->glfuncs->glGetProgramiv(program, GL_LINK_STATUS, &value);
-    d->linked = (value != 0);
-    value = 0;
-    d->glfuncs->glGetProgramiv(program, GL_INFO_LOG_LENGTH, &value);
-    d->log = QString();
-    if (value > 1) {
-        char *logbuf = new char [value];
-        GLint len;
-        d->glfuncs->glGetProgramInfoLog(program, value, &len, logbuf);
-        d->log = QString::fromLatin1(logbuf);
-        if (!d->linked && !d->linkBinaryRecursion) {
-            QString name = objectName();
-            if (name.isEmpty())
-                qWarning("QOpenGLShader::link: %ls", qUtf16Printable(d->log));
-            else
-                qWarning("QOpenGLShader::link[%ls]: %ls", qUtf16Printable(name), qUtf16Printable(d->log));
-        }
-        delete [] logbuf;
-    }
-    return d->linked;
-}
-
-/*!
-    Returns \c true if this shader program has been linked; false otherwise.
-
-    \sa link()
-*/
-bool QOpenGLShaderProgram::isLinked() const
-{
-    Q_D(const QOpenGLShaderProgram);
-    return d->linked;
-}
-
-/*!
-    Returns the errors and warnings that occurred during the last link()
-    or addShader() with explicitly specified source code.
-
-    \sa link()
-*/
-QString QOpenGLShaderProgram::log() const
-{
-    Q_D(const QOpenGLShaderProgram);
-    return d->log;
-}
-
-/*!
-    Binds this shader program to the active QOpenGLContext and makes
-    it the current shader program.  Any previously bound shader program
-    is released.  This is equivalent to calling \c{glUseProgram()} on
-    programId().  Returns \c true if the program was successfully bound;
-    false otherwise.  If the shader program has not yet been linked,
-    or it needs to be re-linked, this function will call link().
-
-    \sa link(), release()
-*/
-bool QOpenGLShaderProgram::bind()
-{
-    Q_D(QOpenGLShaderProgram);
-    GLuint program = d->programGuard ? d->programGuard->id() : 0;
-    if (!program)
-        return false;
-    if (!d->linked && !link())
-        return false;
-#ifndef QT_NO_DEBUG
-    if (d->programGuard->group() != QOpenGLContextGroup::currentContextGroup()) {
-        qWarning("QOpenGLShaderProgram::bind: program is not valid in the current context.");
-        return false;
-    }
-#endif
-    d->glfuncs->glUseProgram(program);
-    return true;
-}
-
-/*!
-    Releases the active shader program from the current QOpenGLContext.
-    This is equivalent to calling \c{glUseProgram(0)}.
-
-    \sa bind()
-*/
-void QOpenGLShaderProgram::release()
-{
-    Q_D(QOpenGLShaderProgram);
-#ifndef QT_NO_DEBUG
-    if (d->programGuard && d->programGuard->group() != QOpenGLContextGroup::currentContextGroup())
-        qWarning("QOpenGLShaderProgram::release: program is not valid in the current context.");
-#endif
-    d->glfuncs->glUseProgram(0);
-}
-
-/*!
-    Returns the OpenGL identifier associated with this shader program.
-
-    \sa QOpenGLShader::shaderId()
-*/
-GLuint QOpenGLShaderProgram::programId() const
-{
-    Q_D(const QOpenGLShaderProgram);
-    GLuint id = d->programGuard ? d->programGuard->id() : 0;
-    if (id)
-        return id;
-
-    // Create the identifier if we don't have one yet.  This is for
-    // applications that want to create the attached shader configuration
-    // themselves, particularly those using program binaries.
-    if (!const_cast<QOpenGLShaderProgram *>(this)->init())
-        return 0;
-    return d->programGuard ? d->programGuard->id() : 0;
-}
-
-/*!
-    Binds the attribute \a name to the specified \a location.  This
-    function can be called before or after the program has been linked.
-    Any attributes that have not been explicitly bound when the program
-    is linked will be assigned locations automatically.
-
-    When this function is called after the program has been linked,
-    the program will need to be relinked for the change to take effect.
-
-    \sa attributeLocation()
-*/
-void QOpenGLShaderProgram::bindAttributeLocation(const char *name, int location)
-{
-    Q_D(QOpenGLShaderProgram);
-    if (!init() || !d->programGuard || !d->programGuard->id())
-        return;
-    d->glfuncs->glBindAttribLocation(d->programGuard->id(), location, name);
-    d->linked = false;  // Program needs to be relinked.
-}
-
-/*!
-    \overload
-
-    Binds the attribute \a name to the specified \a location.  This
-    function can be called before or after the program has been linked.
-    Any attributes that have not been explicitly bound when the program
-    is linked will be assigned locations automatically.
-
-    When this function is called after the program has been linked,
-    the program will need to be relinked for the change to take effect.
-
-    \sa attributeLocation()
-*/
-void QOpenGLShaderProgram::bindAttributeLocation(const QByteArray& name, int location)
-{
-    bindAttributeLocation(name.constData(), location);
-}
-
-/*!
-    \overload
-
-    Binds the attribute \a name to the specified \a location.  This
-    function can be called before or after the program has been linked.
-    Any attributes that have not been explicitly bound when the program
-    is linked will be assigned locations automatically.
-
-    When this function is called after the program has been linked,
-    the program will need to be relinked for the change to take effect.
-
-    \sa attributeLocation()
-*/
-void QOpenGLShaderProgram::bindAttributeLocation(const QString& name, int location)
-{
-    bindAttributeLocation(name.toLatin1().constData(), location);
-}
-
-/*!
-    Returns the location of the attribute \a name within this shader
-    program's parameter list.  Returns -1 if \a name is not a valid
-    attribute for this shader program.
-
-    \sa uniformLocation(), bindAttributeLocation()
-*/
-int QOpenGLShaderProgram::attributeLocation(const char *name) const
-{
-    Q_D(const QOpenGLShaderProgram);
-    if (d->linked && d->programGuard && d->programGuard->id()) {
-        return d->glfuncs->glGetAttribLocation(d->programGuard->id(), name);
-    } else {
-        qWarning("QOpenGLShaderProgram::attributeLocation(%s): shader program is not linked", name);
-        return -1;
-    }
-}
-
-/*!
-    \overload
-
-    Returns the location of the attribute \a name within this shader
-    program's parameter list.  Returns -1 if \a name is not a valid
-    attribute for this shader program.
-
-    \sa uniformLocation(), bindAttributeLocation()
-*/
-int QOpenGLShaderProgram::attributeLocation(const QByteArray& name) const
-{
-    return attributeLocation(name.constData());
-}
-
-/*!
-    \overload
-
-    Returns the location of the attribute \a name within this shader
-    program's parameter list.  Returns -1 if \a name is not a valid
-    attribute for this shader program.
-
-    \sa uniformLocation(), bindAttributeLocation()
-*/
-int QOpenGLShaderProgram::attributeLocation(const QString& name) const
-{
-    return attributeLocation(name.toLatin1().constData());
-}
-
-/*!
-    Sets the attribute at \a location in the current context to \a value.
-
-    \sa setUniformValue()
-*/
-void QOpenGLShaderProgram::setAttributeValue(int location, GLfloat value)
-{
-    Q_D(QOpenGLShaderProgram);
-    if (location != -1)
-        d->glfuncs->glVertexAttrib1fv(location, &value);
-}
-
-/*!
-    \overload
-
-    Sets the attribute called \a name in the current context to \a value.
-
-    \sa setUniformValue()
-*/
-void QOpenGLShaderProgram::setAttributeValue(const char *name, GLfloat value)
-{
-    setAttributeValue(attributeLocation(name), value);
-}
-
-/*!
-    Sets the attribute at \a location in the current context to
-    the 2D vector (\a x, \a y).
-
-    \sa setUniformValue()
-*/
-void QOpenGLShaderProgram::setAttributeValue(int location, GLfloat x, GLfloat y)
-{
-    Q_D(QOpenGLShaderProgram);
-    if (location != -1) {
-        GLfloat values[2] = {x, y};
-        d->glfuncs->glVertexAttrib2fv(location, values);
-    }
-}
-
-/*!
-    \overload
-
-    Sets the attribute called \a name in the current context to
-    the 2D vector (\a x, \a y).
-
-    \sa setUniformValue()
-*/
-void QOpenGLShaderProgram::setAttributeValue(const char *name, GLfloat x, GLfloat y)
-{
-    setAttributeValue(attributeLocation(name), x, y);
-}
-
-/*!
-    Sets the attribute at \a location in the current context to
-    the 3D vector (\a x, \a y, \a z).
-
-    \sa setUniformValue()
-*/
-void QOpenGLShaderProgram::setAttributeValue
-        (int location, GLfloat x, GLfloat y, GLfloat z)
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    if (location != -1) {
-        GLfloat values[3] = {x, y, z};
-        d->glfuncs->glVertexAttrib3fv(location, values);
-    }
-}
-
-/*!
-    \overload
-
-    Sets the attribute called \a name in the current context to
-    the 3D vector (\a x, \a y, \a z).
-
-    \sa setUniformValue()
-*/
-void QOpenGLShaderProgram::setAttributeValue
-        (const char *name, GLfloat x, GLfloat y, GLfloat z)
-{
-    setAttributeValue(attributeLocation(name), x, y, z);
-}
-
-/*!
-    Sets the attribute at \a location in the current context to
-    the 4D vector (\a x, \a y, \a z, \a w).
-
-    \sa setUniformValue()
-*/
-void QOpenGLShaderProgram::setAttributeValue
-        (int location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    Q_D(QOpenGLShaderProgram);
-    if (location != -1) {
-        GLfloat values[4] = {x, y, z, w};
-        d->glfuncs->glVertexAttrib4fv(location, values);
-    }
-}
-
-/*!
-    \overload
-
-    Sets the attribute called \a name in the current context to
-    the 4D vector (\a x, \a y, \a z, \a w).
-
-    \sa setUniformValue()
-*/
-void QOpenGLShaderProgram::setAttributeValue
-        (const char *name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    setAttributeValue(attributeLocation(name), x, y, z, w);
-}
-
-/*!
-    Sets the attribute at \a location in the current context to \a value.
-
-    \sa setUniformValue()
-*/
-void QOpenGLShaderProgram::setAttributeValue(int location, const QVector2D& value)
-{
-    Q_D(QOpenGLShaderProgram);
-    if (location != -1)
-        d->glfuncs->glVertexAttrib2fv(location, reinterpret_cast<const GLfloat *>(&value));
-}
-
-/*!
-    \overload
-
-    Sets the attribute called \a name in the current context to \a value.
-
-    \sa setUniformValue()
-*/
-void QOpenGLShaderProgram::setAttributeValue(const char *name, const QVector2D& value)
-{
-    setAttributeValue(attributeLocation(name), value);
-}
-
-/*!
-    Sets the attribute at \a location in the current context to \a value.
-
-    \sa setUniformValue()
-*/
-void QOpenGLShaderProgram::setAttributeValue(int location, const QVector3D& value)
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    if (location != -1)
-        d->glfuncs->glVertexAttrib3fv(location, reinterpret_cast<const GLfloat *>(&value));
-}
-
-/*!
-    \overload
-
-    Sets the attribute called \a name in the current context to \a value.
-
-    \sa setUniformValue()
-*/
-void QOpenGLShaderProgram::setAttributeValue(const char *name, const QVector3D& value)
-{
-    setAttributeValue(attributeLocation(name), value);
-}
-
-/*!
-    Sets the attribute at \a location in the current context to \a value.
-
-    \sa setUniformValue()
-*/
-void QOpenGLShaderProgram::setAttributeValue(int location, const QVector4D& value)
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    if (location != -1)
-        d->glfuncs->glVertexAttrib4fv(location, reinterpret_cast<const GLfloat *>(&value));
-}
-
-/*!
-    \overload
-
-    Sets the attribute called \a name in the current context to \a value.
-
-    \sa setUniformValue()
-*/
-void QOpenGLShaderProgram::setAttributeValue(const char *name, const QVector4D& value)
-{
-    setAttributeValue(attributeLocation(name), value);
-}
-
-/*!
-    Sets the attribute at \a location in the current context to \a value.
-
-    \sa setUniformValue()
-*/
-void QOpenGLShaderProgram::setAttributeValue(int location, const QColor& value)
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    if (location != -1) {
-        GLfloat values[4] = {GLfloat(value.redF()), GLfloat(value.greenF()),
-                             GLfloat(value.blueF()), GLfloat(value.alphaF())};
-        d->glfuncs->glVertexAttrib4fv(location, values);
-    }
-}
-
-/*!
-    \overload
-
-    Sets the attribute called \a name in the current context to \a value.
-
-    \sa setUniformValue()
-*/
-void QOpenGLShaderProgram::setAttributeValue(const char *name, const QColor& value)
-{
-    setAttributeValue(attributeLocation(name), value);
-}
-
-/*!
-    Sets the attribute at \a location in the current context to the
-    contents of \a values, which contains \a columns elements, each
-    consisting of \a rows elements.  The \a rows value should be
-    1, 2, 3, or 4.  This function is typically used to set matrix
-    values and column vectors.
-
-    \sa setUniformValue()
-*/
-void QOpenGLShaderProgram::setAttributeValue
-    (int location, const GLfloat *values, int columns, int rows)
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    if (rows < 1 || rows > 4) {
-        qWarning("QOpenGLShaderProgram::setAttributeValue: rows %d not supported", rows);
-        return;
-    }
-    if (location != -1) {
-        while (columns-- > 0) {
-            if (rows == 1)
-                d->glfuncs->glVertexAttrib1fv(location, values);
-            else if (rows == 2)
-                d->glfuncs->glVertexAttrib2fv(location, values);
-            else if (rows == 3)
-                d->glfuncs->glVertexAttrib3fv(location, values);
-            else
-                d->glfuncs->glVertexAttrib4fv(location, values);
-            values += rows;
-            ++location;
-        }
-    }
-}
-
-/*!
-    \overload
-
-    Sets the attribute called \a name in the current context to the
-    contents of \a values, which contains \a columns elements, each
-    consisting of \a rows elements.  The \a rows value should be
-    1, 2, 3, or 4.  This function is typically used to set matrix
-    values and column vectors.
-
-    \sa setUniformValue()
-*/
-void QOpenGLShaderProgram::setAttributeValue
-    (const char *name, const GLfloat *values, int columns, int rows)
-{
-    setAttributeValue(attributeLocation(name), values, columns, rows);
-}
-
-/*!
-    Sets an array of vertex \a values on the attribute at \a location
-    in this shader program.  The \a tupleSize indicates the number of
-    components per vertex (1, 2, 3, or 4), and the \a stride indicates
-    the number of bytes between vertices.  A default \a stride value
-    of zero indicates that the vertices are densely packed in \a values.
-
-    The array will become active when enableAttributeArray() is called
-    on the \a location.  Otherwise the value specified with
-    setAttributeValue() for \a location will be used.
-
-    \sa setAttributeValue(), setUniformValue(), enableAttributeArray()
-    \sa disableAttributeArray()
-*/
-void QOpenGLShaderProgram::setAttributeArray
-    (int location, const GLfloat *values, int tupleSize, int stride)
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    if (location != -1) {
-        d->glfuncs->glVertexAttribPointer(location, tupleSize, GL_FLOAT, GL_FALSE,
-                              stride, values);
-    }
-}
-
-/*!
-    Sets an array of 2D vertex \a values on the attribute at \a location
-    in this shader program.  The \a stride indicates the number of bytes
-    between vertices.  A default \a stride value of zero indicates that
-    the vertices are densely packed in \a values.
-
-    The array will become active when enableAttributeArray() is called
-    on the \a location.  Otherwise the value specified with
-    setAttributeValue() for \a location will be used.
-
-    \sa setAttributeValue(), setUniformValue(), enableAttributeArray()
-    \sa disableAttributeArray()
-*/
-void QOpenGLShaderProgram::setAttributeArray
-        (int location, const QVector2D *values, int stride)
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    if (location != -1) {
-        d->glfuncs->glVertexAttribPointer(location, 2, GL_FLOAT, GL_FALSE,
-                              stride, values);
-    }
-}
-
-/*!
-    Sets an array of 3D vertex \a values on the attribute at \a location
-    in this shader program.  The \a stride indicates the number of bytes
-    between vertices.  A default \a stride value of zero indicates that
-    the vertices are densely packed in \a values.
-
-    The array will become active when enableAttributeArray() is called
-    on the \a location.  Otherwise the value specified with
-    setAttributeValue() for \a location will be used.
-
-    \sa setAttributeValue(), setUniformValue(), enableAttributeArray()
-    \sa disableAttributeArray()
-*/
-void QOpenGLShaderProgram::setAttributeArray
-        (int location, const QVector3D *values, int stride)
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    if (location != -1) {
-        d->glfuncs->glVertexAttribPointer(location, 3, GL_FLOAT, GL_FALSE,
-                              stride, values);
-    }
-}
-
-/*!
-    Sets an array of 4D vertex \a values on the attribute at \a location
-    in this shader program.  The \a stride indicates the number of bytes
-    between vertices.  A default \a stride value of zero indicates that
-    the vertices are densely packed in \a values.
-
-    The array will become active when enableAttributeArray() is called
-    on the \a location.  Otherwise the value specified with
-    setAttributeValue() for \a location will be used.
-
-    \sa setAttributeValue(), setUniformValue(), enableAttributeArray()
-    \sa disableAttributeArray()
-*/
-void QOpenGLShaderProgram::setAttributeArray
-        (int location, const QVector4D *values, int stride)
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    if (location != -1) {
-        d->glfuncs->glVertexAttribPointer(location, 4, GL_FLOAT, GL_FALSE,
-                              stride, values);
-    }
-}
-
-/*!
-    Sets an array of vertex \a values on the attribute at \a location
-    in this shader program.  The \a stride indicates the number of bytes
-    between vertices.  A default \a stride value of zero indicates that
-    the vertices are densely packed in \a values.
-
-    The \a type indicates the type of elements in the \a values array,
-    usually \c{GL_FLOAT}, \c{GL_UNSIGNED_BYTE}, etc.  The \a tupleSize
-    indicates the number of components per vertex: 1, 2, 3, or 4.
-
-    The array will become active when enableAttributeArray() is called
-    on the \a location.  Otherwise the value specified with
-    setAttributeValue() for \a location will be used.
-
-    The setAttributeBuffer() function can be used to set the attribute
-    array to an offset within a vertex buffer.
-
-    \note Normalization will be enabled. If this is not desired, call
-    glVertexAttribPointer directly through QOpenGLFunctions.
-
-    \sa setAttributeValue(), setUniformValue(), enableAttributeArray()
-    \sa disableAttributeArray(), setAttributeBuffer()
-*/
-void QOpenGLShaderProgram::setAttributeArray
-    (int location, GLenum type, const void *values, int tupleSize, int stride)
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    if (location != -1) {
-        d->glfuncs->glVertexAttribPointer(location, tupleSize, type, GL_TRUE,
-                              stride, values);
-    }
-}
-
-/*!
-    \overload
-
-    Sets an array of vertex \a values on the attribute called \a name
-    in this shader program.  The \a tupleSize indicates the number of
-    components per vertex (1, 2, 3, or 4), and the \a stride indicates
-    the number of bytes between vertices.  A default \a stride value
-    of zero indicates that the vertices are densely packed in \a values.
-
-    The array will become active when enableAttributeArray() is called
-    on \a name.  Otherwise the value specified with setAttributeValue()
-    for \a name will be used.
-
-    \sa setAttributeValue(), setUniformValue(), enableAttributeArray()
-    \sa disableAttributeArray()
-*/
-void QOpenGLShaderProgram::setAttributeArray
-    (const char *name, const GLfloat *values, int tupleSize, int stride)
-{
-    setAttributeArray(attributeLocation(name), values, tupleSize, stride);
-}
-
-/*!
-    \overload
-
-    Sets an array of 2D vertex \a values on the attribute called \a name
-    in this shader program.  The \a stride indicates the number of bytes
-    between vertices.  A default \a stride value of zero indicates that
-    the vertices are densely packed in \a values.
-
-    The array will become active when enableAttributeArray() is called
-    on \a name.  Otherwise the value specified with setAttributeValue()
-    for \a name will be used.
-
-    \sa setAttributeValue(), setUniformValue(), enableAttributeArray()
-    \sa disableAttributeArray()
-*/
-void QOpenGLShaderProgram::setAttributeArray
-        (const char *name, const QVector2D *values, int stride)
-{
-    setAttributeArray(attributeLocation(name), values, stride);
-}
-
-/*!
-    \overload
-
-    Sets an array of 3D vertex \a values on the attribute called \a name
-    in this shader program.  The \a stride indicates the number of bytes
-    between vertices.  A default \a stride value of zero indicates that
-    the vertices are densely packed in \a values.
-
-    The array will become active when enableAttributeArray() is called
-    on \a name.  Otherwise the value specified with setAttributeValue()
-    for \a name will be used.
-
-    \sa setAttributeValue(), setUniformValue(), enableAttributeArray()
-    \sa disableAttributeArray()
-*/
-void QOpenGLShaderProgram::setAttributeArray
-        (const char *name, const QVector3D *values, int stride)
-{
-    setAttributeArray(attributeLocation(name), values, stride);
-}
-
-/*!
-    \overload
-
-    Sets an array of 4D vertex \a values on the attribute called \a name
-    in this shader program.  The \a stride indicates the number of bytes
-    between vertices.  A default \a stride value of zero indicates that
-    the vertices are densely packed in \a values.
-
-    The array will become active when enableAttributeArray() is called
-    on \a name.  Otherwise the value specified with setAttributeValue()
-    for \a name will be used.
-
-    \sa setAttributeValue(), setUniformValue(), enableAttributeArray()
-    \sa disableAttributeArray()
-*/
-void QOpenGLShaderProgram::setAttributeArray
-        (const char *name, const QVector4D *values, int stride)
-{
-    setAttributeArray(attributeLocation(name), values, stride);
-}
-
-/*!
-    \overload
-
-    Sets an array of vertex \a values on the attribute called \a name
-    in this shader program.  The \a stride indicates the number of bytes
-    between vertices.  A default \a stride value of zero indicates that
-    the vertices are densely packed in \a values.
-
-    The \a type indicates the type of elements in the \a values array,
-    usually \c{GL_FLOAT}, \c{GL_UNSIGNED_BYTE}, etc.  The \a tupleSize
-    indicates the number of components per vertex: 1, 2, 3, or 4.
-
-    The array will become active when enableAttributeArray() is called
-    on the \a name.  Otherwise the value specified with
-    setAttributeValue() for \a name will be used.
-
-    The setAttributeBuffer() function can be used to set the attribute
-    array to an offset within a vertex buffer.
-
-    \sa setAttributeValue(), setUniformValue(), enableAttributeArray()
-    \sa disableAttributeArray(), setAttributeBuffer()
-*/
-void QOpenGLShaderProgram::setAttributeArray
-    (const char *name, GLenum type, const void *values, int tupleSize, int stride)
-{
-    setAttributeArray(attributeLocation(name), type, values, tupleSize, stride);
-}
-
-/*!
-    Sets an array of vertex values on the attribute at \a location in
-    this shader program, starting at a specific \a offset in the
-    currently bound vertex buffer.  The \a stride indicates the number
-    of bytes between vertices.  A default \a stride value of zero
-    indicates that the vertices are densely packed in the value array.
-
-    The \a type indicates the type of elements in the vertex value
-    array, usually \c{GL_FLOAT}, \c{GL_UNSIGNED_BYTE}, etc.  The \a
-    tupleSize indicates the number of components per vertex: 1, 2, 3,
-    or 4.
-
-    The array will become active when enableAttributeArray() is called
-    on the \a location.  Otherwise the value specified with
-    setAttributeValue() for \a location will be used.
-
-    \note Normalization will be enabled. If this is not desired, call
-    glVertexAttribPointer directly through QOpenGLFunctions.
-
-    \sa setAttributeArray()
-*/
-void QOpenGLShaderProgram::setAttributeBuffer
-    (int location, GLenum type, int offset, int tupleSize, int stride)
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    if (location != -1) {
-        d->glfuncs->glVertexAttribPointer(location, tupleSize, type, GL_TRUE, stride,
-                              reinterpret_cast<const void *>(qintptr(offset)));
-    }
-}
-
-/*!
-    \overload
-
-    Sets an array of vertex values on the attribute called \a name
-    in this shader program, starting at a specific \a offset in the
-    currently bound vertex buffer.  The \a stride indicates the number
-    of bytes between vertices.  A default \a stride value of zero
-    indicates that the vertices are densely packed in the value array.
-
-    The \a type indicates the type of elements in the vertex value
-    array, usually \c{GL_FLOAT}, \c{GL_UNSIGNED_BYTE}, etc.  The \a
-    tupleSize indicates the number of components per vertex: 1, 2, 3,
-    or 4.
-
-    The array will become active when enableAttributeArray() is called
-    on the \a name.  Otherwise the value specified with
-    setAttributeValue() for \a name will be used.
-
-    \sa setAttributeArray()
-*/
-void QOpenGLShaderProgram::setAttributeBuffer
-    (const char *name, GLenum type, int offset, int tupleSize, int stride)
-{
-    setAttributeBuffer(attributeLocation(name), type, offset, tupleSize, stride);
-}
-
-/*!
-    Enables the vertex array at \a location in this shader program
-    so that the value set by setAttributeArray() on \a location
-    will be used by the shader program.
-
-    \sa disableAttributeArray(), setAttributeArray(), setAttributeValue()
-    \sa setUniformValue()
-*/
-void QOpenGLShaderProgram::enableAttributeArray(int location)
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    if (location != -1)
-        d->glfuncs->glEnableVertexAttribArray(location);
-}
-
-/*!
-    \overload
-
-    Enables the vertex array called \a name in this shader program
-    so that the value set by setAttributeArray() on \a name
-    will be used by the shader program.
-
-    \sa disableAttributeArray(), setAttributeArray(), setAttributeValue()
-    \sa setUniformValue()
-*/
-void QOpenGLShaderProgram::enableAttributeArray(const char *name)
-{
-    enableAttributeArray(attributeLocation(name));
-}
-
-/*!
-    Disables the vertex array at \a location in this shader program
-    that was enabled by a previous call to enableAttributeArray().
-
-    \sa enableAttributeArray(), setAttributeArray(), setAttributeValue()
-    \sa setUniformValue()
-*/
-void QOpenGLShaderProgram::disableAttributeArray(int location)
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    if (location != -1)
-        d->glfuncs->glDisableVertexAttribArray(location);
-}
-
-/*!
-    \overload
-
-    Disables the vertex array called \a name in this shader program
-    that was enabled by a previous call to enableAttributeArray().
-
-    \sa enableAttributeArray(), setAttributeArray(), setAttributeValue()
-    \sa setUniformValue()
-*/
-void QOpenGLShaderProgram::disableAttributeArray(const char *name)
-{
-    disableAttributeArray(attributeLocation(name));
-}
-
-/*!
-    Returns the location of the uniform variable \a name within this shader
-    program's parameter list.  Returns -1 if \a name is not a valid
-    uniform variable for this shader program.
-
-    \sa attributeLocation()
-*/
-int QOpenGLShaderProgram::uniformLocation(const char *name) const
-{
-    Q_D(const QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    if (d->linked && d->programGuard && d->programGuard->id()) {
-        return d->glfuncs->glGetUniformLocation(d->programGuard->id(), name);
-    } else {
-        qWarning("QOpenGLShaderProgram::uniformLocation(%s): shader program is not linked", name);
-        return -1;
-    }
-}
-
-/*!
-    \overload
-
-    Returns the location of the uniform variable \a name within this shader
-    program's parameter list.  Returns -1 if \a name is not a valid
-    uniform variable for this shader program.
-
-    \sa attributeLocation()
-*/
-int QOpenGLShaderProgram::uniformLocation(const QByteArray& name) const
-{
-    return uniformLocation(name.constData());
-}
-
-/*!
-    \overload
-
-    Returns the location of the uniform variable \a name within this shader
-    program's parameter list.  Returns -1 if \a name is not a valid
-    uniform variable for this shader program.
-
-    \sa attributeLocation()
-*/
-int QOpenGLShaderProgram::uniformLocation(const QString& name) const
-{
-    return uniformLocation(name.toLatin1().constData());
-}
-
-/*!
-    Sets the uniform variable at \a location in the current context to \a value.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValue(int location, GLfloat value)
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    if (location != -1)
-        d->glfuncs->glUniform1fv(location, 1, &value);
-}
-
-/*!
-    \overload
-
-    Sets the uniform variable called \a name in the current context
-    to \a value.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValue(const char *name, GLfloat value)
-{
-    setUniformValue(uniformLocation(name), value);
-}
-
-/*!
-    Sets the uniform variable at \a location in the current context to \a value.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValue(int location, GLint value)
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    if (location != -1)
-        d->glfuncs->glUniform1i(location, value);
-}
-
-/*!
-    \overload
-
-    Sets the uniform variable called \a name in the current context
-    to \a value.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValue(const char *name, GLint value)
-{
-    setUniformValue(uniformLocation(name), value);
-}
-
-/*!
-    Sets the uniform variable at \a location in the current context to \a value.
-    This function should be used when setting sampler values.
-
-    \note This function is not aware of unsigned int support in modern OpenGL
-    versions and therefore treats \a value as a GLint and calls glUniform1i.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValue(int location, GLuint value)
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    if (location != -1)
-        d->glfuncs->glUniform1i(location, value);
-}
-
-/*!
-    \overload
-
-    Sets the uniform variable called \a name in the current context
-    to \a value.  This function should be used when setting sampler values.
-
-    \note This function is not aware of unsigned int support in modern OpenGL
-    versions and therefore treats \a value as a GLint and calls glUniform1i.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValue(const char *name, GLuint value)
-{
-    setUniformValue(uniformLocation(name), value);
-}
-
-/*!
-    Sets the uniform variable at \a location in the current context to
-    the 2D vector (\a x, \a y).
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValue(int location, GLfloat x, GLfloat y)
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    if (location != -1) {
-        GLfloat values[2] = {x, y};
-        d->glfuncs->glUniform2fv(location, 1, values);
-    }
-}
-
-/*!
-    \overload
-
-    Sets the uniform variable called \a name in the current context to
-    the 2D vector (\a x, \a y).
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValue(const char *name, GLfloat x, GLfloat y)
-{
-    setUniformValue(uniformLocation(name), x, y);
-}
-
-/*!
-    Sets the uniform variable at \a location in the current context to
-    the 3D vector (\a x, \a y, \a z).
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValue
-        (int location, GLfloat x, GLfloat y, GLfloat z)
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    if (location != -1) {
-        GLfloat values[3] = {x, y, z};
-        d->glfuncs->glUniform3fv(location, 1, values);
-    }
-}
-
-/*!
-    \overload
-
-    Sets the uniform variable called \a name in the current context to
-    the 3D vector (\a x, \a y, \a z).
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValue
-        (const char *name, GLfloat x, GLfloat y, GLfloat z)
-{
-    setUniformValue(uniformLocation(name), x, y, z);
-}
-
-/*!
-    Sets the uniform variable at \a location in the current context to
-    the 4D vector (\a x, \a y, \a z, \a w).
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValue
-        (int location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    if (location != -1) {
-        GLfloat values[4] = {x, y, z, w};
-        d->glfuncs->glUniform4fv(location, 1, values);
-    }
-}
-
-/*!
-    \overload
-
-    Sets the uniform variable called \a name in the current context to
-    the 4D vector (\a x, \a y, \a z, \a w).
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValue
-        (const char *name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    setUniformValue(uniformLocation(name), x, y, z, w);
-}
-
-/*!
-    Sets the uniform variable at \a location in the current context to \a value.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValue(int location, const QVector2D& value)
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    if (location != -1)
-        d->glfuncs->glUniform2fv(location, 1, reinterpret_cast<const GLfloat *>(&value));
-}
-
-/*!
-    \overload
-
-    Sets the uniform variable called \a name in the current context
-    to \a value.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValue(const char *name, const QVector2D& value)
-{
-    setUniformValue(uniformLocation(name), value);
-}
-
-/*!
-    Sets the uniform variable at \a location in the current context to \a value.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValue(int location, const QVector3D& value)
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    if (location != -1)
-        d->glfuncs->glUniform3fv(location, 1, reinterpret_cast<const GLfloat *>(&value));
-}
-
-/*!
-    \overload
-
-    Sets the uniform variable called \a name in the current context
-    to \a value.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValue(const char *name, const QVector3D& value)
-{
-    setUniformValue(uniformLocation(name), value);
-}
-
-/*!
-    Sets the uniform variable at \a location in the current context to \a value.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValue(int location, const QVector4D& value)
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    if (location != -1)
-        d->glfuncs->glUniform4fv(location, 1, reinterpret_cast<const GLfloat *>(&value));
-}
-
-/*!
-    \overload
-
-    Sets the uniform variable called \a name in the current context
-    to \a value.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValue(const char *name, const QVector4D& value)
-{
-    setUniformValue(uniformLocation(name), value);
-}
-
-/*!
-    Sets the uniform variable at \a location in the current context to
-    the red, green, blue, and alpha components of \a color.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValue(int location, const QColor& color)
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    if (location != -1) {
-        GLfloat values[4] = {GLfloat(color.redF()), GLfloat(color.greenF()),
-                             GLfloat(color.blueF()), GLfloat(color.alphaF())};
-        d->glfuncs->glUniform4fv(location, 1, values);
-    }
-}
-
-/*!
-    \overload
-
-    Sets the uniform variable called \a name in the current context to
-    the red, green, blue, and alpha components of \a color.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValue(const char *name, const QColor& color)
-{
-    setUniformValue(uniformLocation(name), color);
-}
-
-/*!
-    Sets the uniform variable at \a location in the current context to
-    the x and y coordinates of \a point.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValue(int location, const QPoint& point)
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    if (location != -1) {
-        GLfloat values[4] = {GLfloat(point.x()), GLfloat(point.y())};
-        d->glfuncs->glUniform2fv(location, 1, values);
-    }
-}
-
-/*!
-    \overload
-
-    Sets the uniform variable associated with \a name in the current
-    context to the x and y coordinates of \a point.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValue(const char *name, const QPoint& point)
-{
-    setUniformValue(uniformLocation(name), point);
-}
-
-/*!
-    Sets the uniform variable at \a location in the current context to
-    the x and y coordinates of \a point.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValue(int location, const QPointF& point)
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    if (location != -1) {
-        GLfloat values[4] = {GLfloat(point.x()), GLfloat(point.y())};
-        d->glfuncs->glUniform2fv(location, 1, values);
-    }
-}
-
-/*!
-    \overload
-
-    Sets the uniform variable associated with \a name in the current
-    context to the x and y coordinates of \a point.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValue(const char *name, const QPointF& point)
-{
-    setUniformValue(uniformLocation(name), point);
-}
-
-/*!
-    Sets the uniform variable at \a location in the current context to
-    the width and height of the given \a size.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValue(int location, const QSize& size)
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    if (location != -1) {
-        GLfloat values[4] = {GLfloat(size.width()), GLfloat(size.height())};
-        d->glfuncs->glUniform2fv(location, 1, values);
-    }
-}
-
-/*!
-    \overload
-
-    Sets the uniform variable associated with \a name in the current
-    context to the width and height of the given \a size.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValue(const char *name, const QSize& size)
-{
-    setUniformValue(uniformLocation(name), size);
-}
-
-/*!
-    Sets the uniform variable at \a location in the current context to
-    the width and height of the given \a size.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValue(int location, const QSizeF& size)
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    if (location != -1) {
-        GLfloat values[4] = {GLfloat(size.width()), GLfloat(size.height())};
-        d->glfuncs->glUniform2fv(location, 1, values);
-    }
-}
-
-/*!
-    \overload
-
-    Sets the uniform variable associated with \a name in the current
-    context to the width and height of the given \a size.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValue(const char *name, const QSizeF& size)
-{
-    setUniformValue(uniformLocation(name), size);
-}
-
-/*!
-    Sets the uniform variable at \a location in the current context
-    to a 2x2 matrix \a value.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValue(int location, const QMatrix2x2& value)
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    d->glfuncs->glUniformMatrix2fv(location, 1, GL_FALSE, value.constData());
-}
-
-/*!
-    \overload
-
-    Sets the uniform variable called \a name in the current context
-    to a 2x2 matrix \a value.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValue(const char *name, const QMatrix2x2& value)
-{
-    setUniformValue(uniformLocation(name), value);
-}
-
-/*!
-    Sets the uniform variable at \a location in the current context
-    to a 2x3 matrix \a value.
-
-    \note This function is not aware of non square matrix support,
-    that is, GLSL types like mat2x3, that is present in modern OpenGL
-    versions. Instead, it treats the uniform as an array of vec3.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValue(int location, const QMatrix2x3& value)
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    d->glfuncs->glUniform3fv(location, 2, value.constData());
-}
-
-/*!
-    \overload
-
-    Sets the uniform variable called \a name in the current context
-    to a 2x3 matrix \a value.
-
-    \note This function is not aware of non square matrix support,
-    that is, GLSL types like mat2x3, that is present in modern OpenGL
-    versions. Instead, it treats the uniform as an array of vec3.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValue(const char *name, const QMatrix2x3& value)
-{
-    setUniformValue(uniformLocation(name), value);
-}
-
-/*!
-    Sets the uniform variable at \a location in the current context
-    to a 2x4 matrix \a value.
-
-    \note This function is not aware of non square matrix support,
-    that is, GLSL types like mat2x4, that is present in modern OpenGL
-    versions. Instead, it treats the uniform as an array of vec4.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValue(int location, const QMatrix2x4& value)
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    d->glfuncs->glUniform4fv(location, 2, value.constData());
-}
-
-/*!
-    \overload
-
-    Sets the uniform variable called \a name in the current context
-    to a 2x4 matrix \a value.
-
-    \note This function is not aware of non square matrix support,
-    that is, GLSL types like mat2x4, that is present in modern OpenGL
-    versions. Instead, it treats the uniform as an array of vec4.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValue(const char *name, const QMatrix2x4& value)
-{
-    setUniformValue(uniformLocation(name), value);
-}
-
-/*!
-    Sets the uniform variable at \a location in the current context
-    to a 3x2 matrix \a value.
-
-    \note This function is not aware of non square matrix support,
-    that is, GLSL types like mat3x2, that is present in modern OpenGL
-    versions. Instead, it treats the uniform as an array of vec2.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValue(int location, const QMatrix3x2& value)
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    d->glfuncs->glUniform2fv(location, 3, value.constData());
-}
-
-/*!
-    \overload
-
-    Sets the uniform variable called \a name in the current context
-    to a 3x2 matrix \a value.
-
-    \note This function is not aware of non square matrix support,
-    that is, GLSL types like mat3x2, that is present in modern OpenGL
-    versions. Instead, it treats the uniform as an array of vec2.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValue(const char *name, const QMatrix3x2& value)
-{
-    setUniformValue(uniformLocation(name), value);
-}
-
-/*!
-    Sets the uniform variable at \a location in the current context
-    to a 3x3 matrix \a value.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValue(int location, const QMatrix3x3& value)
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    d->glfuncs->glUniformMatrix3fv(location, 1, GL_FALSE, value.constData());
-}
-
-/*!
-    \overload
-
-    Sets the uniform variable called \a name in the current context
-    to a 3x3 matrix \a value.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValue(const char *name, const QMatrix3x3& value)
-{
-    setUniformValue(uniformLocation(name), value);
-}
-
-/*!
-    Sets the uniform variable at \a location in the current context
-    to a 3x4 matrix \a value.
-
-    \note This function is not aware of non square matrix support,
-    that is, GLSL types like mat3x4, that is present in modern OpenGL
-    versions. Instead, it treats the uniform as an array of vec4.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValue(int location, const QMatrix3x4& value)
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    d->glfuncs->glUniform4fv(location, 3, value.constData());
-}
-
-/*!
-    \overload
-
-    Sets the uniform variable called \a name in the current context
-    to a 3x4 matrix \a value.
-
-    \note This function is not aware of non square matrix support,
-    that is, GLSL types like mat3x4, that is present in modern OpenGL
-    versions. Instead, it treats the uniform as an array of vec4.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValue(const char *name, const QMatrix3x4& value)
-{
-    setUniformValue(uniformLocation(name), value);
-}
-
-/*!
-    Sets the uniform variable at \a location in the current context
-    to a 4x2 matrix \a value.
-
-    \note This function is not aware of non square matrix support,
-    that is, GLSL types like mat4x2, that is present in modern OpenGL
-    versions. Instead, it treats the uniform as an array of vec2.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValue(int location, const QMatrix4x2& value)
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    d->glfuncs->glUniform2fv(location, 4, value.constData());
-}
-
-/*!
-    \overload
-
-    Sets the uniform variable called \a name in the current context
-    to a 4x2 matrix \a value.
-
-    \note This function is not aware of non square matrix support,
-    that is, GLSL types like mat4x2, that is present in modern OpenGL
-    versions. Instead, it treats the uniform as an array of vec2.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValue(const char *name, const QMatrix4x2& value)
-{
-    setUniformValue(uniformLocation(name), value);
-}
-
-/*!
-    Sets the uniform variable at \a location in the current context
-    to a 4x3 matrix \a value.
-
-    \note This function is not aware of non square matrix support,
-    that is, GLSL types like mat4x3, that is present in modern OpenGL
-    versions. Instead, it treats the uniform as an array of vec3.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValue(int location, const QMatrix4x3& value)
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    d->glfuncs->glUniform3fv(location, 4, value.constData());
-}
-
-/*!
-    \overload
-
-    Sets the uniform variable called \a name in the current context
-    to a 4x3 matrix \a value.
-
-    \note This function is not aware of non square matrix support,
-    that is, GLSL types like mat4x3, that is present in modern OpenGL
-    versions. Instead, it treats the uniform as an array of vec3.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValue(const char *name, const QMatrix4x3& value)
-{
-    setUniformValue(uniformLocation(name), value);
-}
-
-/*!
-    Sets the uniform variable at \a location in the current context
-    to a 4x4 matrix \a value.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValue(int location, const QMatrix4x4& value)
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    d->glfuncs->glUniformMatrix4fv(location, 1, GL_FALSE, value.constData());
-}
-
-/*!
-    \overload
-
-    Sets the uniform variable called \a name in the current context
-    to a 4x4 matrix \a value.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValue(const char *name, const QMatrix4x4& value)
-{
-    setUniformValue(uniformLocation(name), value);
-}
-
-/*!
-    \overload
-
-    Sets the uniform variable at \a location in the current context
-    to a 2x2 matrix \a value.  The matrix elements must be specified
-    in column-major order.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValue(int location, const GLfloat value[2][2])
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    if (location != -1)
-        d->glfuncs->glUniformMatrix2fv(location, 1, GL_FALSE, value[0]);
-}
-
-/*!
-    \overload
-
-    Sets the uniform variable at \a location in the current context
-    to a 3x3 matrix \a value.  The matrix elements must be specified
-    in column-major order.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValue(int location, const GLfloat value[3][3])
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    if (location != -1)
-        d->glfuncs->glUniformMatrix3fv(location, 1, GL_FALSE, value[0]);
-}
-
-/*!
-    \overload
-
-    Sets the uniform variable at \a location in the current context
-    to a 4x4 matrix \a value.  The matrix elements must be specified
-    in column-major order.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValue(int location, const GLfloat value[4][4])
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    if (location != -1)
-        d->glfuncs->glUniformMatrix4fv(location, 1, GL_FALSE, value[0]);
-}
-
-
-/*!
-    \overload
-
-    Sets the uniform variable called \a name in the current context
-    to a 2x2 matrix \a value.  The matrix elements must be specified
-    in column-major order.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValue(const char *name, const GLfloat value[2][2])
-{
-    setUniformValue(uniformLocation(name), value);
-}
-
-/*!
-    \overload
-
-    Sets the uniform variable called \a name in the current context
-    to a 3x3 matrix \a value.  The matrix elements must be specified
-    in column-major order.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValue(const char *name, const GLfloat value[3][3])
-{
-    setUniformValue(uniformLocation(name), value);
-}
-
-/*!
-    \overload
-
-    Sets the uniform variable called \a name in the current context
-    to a 4x4 matrix \a value.  The matrix elements must be specified
-    in column-major order.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValue(const char *name, const GLfloat value[4][4])
-{
-    setUniformValue(uniformLocation(name), value);
-}
-
-/*!
-    Sets the uniform variable at \a location in the current context to a
-    3x3 transformation matrix \a value that is specified as a QTransform value.
-
-    To set a QTransform value as a 4x4 matrix in a shader, use
-    \c{setUniformValue(location, QMatrix4x4(value))}.
-*/
-void QOpenGLShaderProgram::setUniformValue(int location, const QTransform& value)
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    if (location != -1) {
-        GLfloat mat[3][3] = {
-            {GLfloat(value.m11()), GLfloat(value.m12()), GLfloat(value.m13())},
-            {GLfloat(value.m21()), GLfloat(value.m22()), GLfloat(value.m23())},
-            {GLfloat(value.m31()), GLfloat(value.m32()), GLfloat(value.m33())}
-        };
-        d->glfuncs->glUniformMatrix3fv(location, 1, GL_FALSE, mat[0]);
-    }
-}
-
-/*!
-    \overload
-
-    Sets the uniform variable called \a name in the current context to a
-    3x3 transformation matrix \a value that is specified as a QTransform value.
-
-    To set a QTransform value as a 4x4 matrix in a shader, use
-    \c{setUniformValue(name, QMatrix4x4(value))}.
-*/
-void QOpenGLShaderProgram::setUniformValue
-        (const char *name, const QTransform& value)
-{
-    setUniformValue(uniformLocation(name), value);
-}
-
-/*!
-    Sets the uniform variable array at \a location in the current
-    context to the \a count elements of \a values.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValueArray(int location, const GLint *values, int count)
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    if (location != -1)
-        d->glfuncs->glUniform1iv(location, count, values);
-}
-
-/*!
-    \overload
-
-    Sets the uniform variable array called \a name in the current
-    context to the \a count elements of \a values.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValueArray
-        (const char *name, const GLint *values, int count)
-{
-    setUniformValueArray(uniformLocation(name), values, count);
-}
-
-/*!
-    Sets the uniform variable array at \a location in the current
-    context to the \a count elements of \a values.  This overload
-    should be used when setting an array of sampler values.
-
-    \note This function is not aware of unsigned int support in modern OpenGL
-    versions and therefore treats \a values as a GLint and calls glUniform1iv.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValueArray(int location, const GLuint *values, int count)
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    if (location != -1)
-        d->glfuncs->glUniform1iv(location, count, reinterpret_cast<const GLint *>(values));
-}
-
-/*!
-    \overload
-
-    Sets the uniform variable array called \a name in the current
-    context to the \a count elements of \a values.  This overload
-    should be used when setting an array of sampler values.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValueArray
-        (const char *name, const GLuint *values, int count)
-{
-    setUniformValueArray(uniformLocation(name), values, count);
-}
-
-/*!
-    Sets the uniform variable array at \a location in the current
-    context to the \a count elements of \a values.  Each element
-    has \a tupleSize components.  The \a tupleSize must be 1, 2, 3, or 4.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValueArray(int location, const GLfloat *values, int count, int tupleSize)
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    if (location != -1) {
-        if (tupleSize == 1)
-            d->glfuncs->glUniform1fv(location, count, values);
-        else if (tupleSize == 2)
-            d->glfuncs->glUniform2fv(location, count, values);
-        else if (tupleSize == 3)
-            d->glfuncs->glUniform3fv(location, count, values);
-        else if (tupleSize == 4)
-            d->glfuncs->glUniform4fv(location, count, values);
-        else
-            qWarning("QOpenGLShaderProgram::setUniformValue: size %d not supported", tupleSize);
-    }
-}
-
-/*!
-    \overload
-
-    Sets the uniform variable array called \a name in the current
-    context to the \a count elements of \a values.  Each element
-    has \a tupleSize components.  The \a tupleSize must be 1, 2, 3, or 4.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValueArray
-        (const char *name, const GLfloat *values, int count, int tupleSize)
-{
-    setUniformValueArray(uniformLocation(name), values, count, tupleSize);
-}
-
-/*!
-    Sets the uniform variable array at \a location in the current
-    context to the \a count 2D vector elements of \a values.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValueArray(int location, const QVector2D *values, int count)
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    if (location != -1)
-        d->glfuncs->glUniform2fv(location, count, reinterpret_cast<const GLfloat *>(values));
-}
-
-/*!
-    \overload
-
-    Sets the uniform variable array called \a name in the current
-    context to the \a count 2D vector elements of \a values.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValueArray(const char *name, const QVector2D *values, int count)
-{
-    setUniformValueArray(uniformLocation(name), values, count);
-}
-
-/*!
-    Sets the uniform variable array at \a location in the current
-    context to the \a count 3D vector elements of \a values.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValueArray(int location, const QVector3D *values, int count)
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    if (location != -1)
-        d->glfuncs->glUniform3fv(location, count, reinterpret_cast<const GLfloat *>(values));
-}
-
-/*!
-    \overload
-
-    Sets the uniform variable array called \a name in the current
-    context to the \a count 3D vector elements of \a values.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValueArray(const char *name, const QVector3D *values, int count)
-{
-    setUniformValueArray(uniformLocation(name), values, count);
-}
-
-/*!
-    Sets the uniform variable array at \a location in the current
-    context to the \a count 4D vector elements of \a values.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValueArray(int location, const QVector4D *values, int count)
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    if (location != -1)
-        d->glfuncs->glUniform4fv(location, count, reinterpret_cast<const GLfloat *>(values));
-}
-
-/*!
-    \overload
-
-    Sets the uniform variable array called \a name in the current
-    context to the \a count 4D vector elements of \a values.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValueArray(const char *name, const QVector4D *values, int count)
-{
-    setUniformValueArray(uniformLocation(name), values, count);
-}
-
-// We have to repack matrix arrays from qreal to GLfloat.
-#define setUniformMatrixArray(func,location,values,count,type,cols,rows) \
-    if (location == -1 || count <= 0) \
-        return; \
-    if (sizeof(type) == sizeof(GLfloat) * cols * rows) { \
-        func(location, count, GL_FALSE, \
-             reinterpret_cast<const GLfloat *>(values[0].constData())); \
-    } else { \
-        QVarLengthArray<GLfloat> temp(cols * rows * count); \
-        for (int index = 0; index < count; ++index) { \
-            for (int index2 = 0; index2 < (cols * rows); ++index2) { \
-                temp.data()[cols * rows * index + index2] = \
-                    values[index].constData()[index2]; \
-            } \
-        } \
-        func(location, count, GL_FALSE, temp.constData()); \
-    }
-#define setUniformGenericMatrixArray(colfunc,location,values,count,type,cols,rows) \
-    if (location == -1 || count <= 0) \
-        return; \
-    if (sizeof(type) == sizeof(GLfloat) * cols * rows) { \
-        const GLfloat *data = reinterpret_cast<const GLfloat *> \
-            (values[0].constData());  \
-        colfunc(location, count * cols, data); \
-    } else { \
-        QVarLengthArray<GLfloat> temp(cols * rows * count); \
-        for (int index = 0; index < count; ++index) { \
-            for (int index2 = 0; index2 < (cols * rows); ++index2) { \
-                temp.data()[cols * rows * index + index2] = \
-                    values[index].constData()[index2]; \
-            } \
-        } \
-        colfunc(location, count * cols, temp.constData()); \
-    }
-
-/*!
-    Sets the uniform variable array at \a location in the current
-    context to the \a count 2x2 matrix elements of \a values.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValueArray(int location, const QMatrix2x2 *values, int count)
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    setUniformMatrixArray
-        (d->glfuncs->glUniformMatrix2fv, location, values, count, QMatrix2x2, 2, 2);
-}
-
-/*!
-    \overload
-
-    Sets the uniform variable array called \a name in the current
-    context to the \a count 2x2 matrix elements of \a values.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValueArray(const char *name, const QMatrix2x2 *values, int count)
-{
-    setUniformValueArray(uniformLocation(name), values, count);
-}
-
-/*!
-    Sets the uniform variable array at \a location in the current
-    context to the \a count 2x3 matrix elements of \a values.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValueArray(int location, const QMatrix2x3 *values, int count)
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    setUniformGenericMatrixArray
-        (d->glfuncs->glUniform3fv, location, values, count,
-         QMatrix2x3, 2, 3);
-}
-
-/*!
-    \overload
-
-    Sets the uniform variable array called \a name in the current
-    context to the \a count 2x3 matrix elements of \a values.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValueArray(const char *name, const QMatrix2x3 *values, int count)
-{
-    setUniformValueArray(uniformLocation(name), values, count);
-}
-
-/*!
-    Sets the uniform variable array at \a location in the current
-    context to the \a count 2x4 matrix elements of \a values.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValueArray(int location, const QMatrix2x4 *values, int count)
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    setUniformGenericMatrixArray
-        (d->glfuncs->glUniform4fv, location, values, count,
-         QMatrix2x4, 2, 4);
-}
-
-/*!
-    \overload
-
-    Sets the uniform variable array called \a name in the current
-    context to the \a count 2x4 matrix elements of \a values.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValueArray(const char *name, const QMatrix2x4 *values, int count)
-{
-    setUniformValueArray(uniformLocation(name), values, count);
-}
-
-/*!
-    Sets the uniform variable array at \a location in the current
-    context to the \a count 3x2 matrix elements of \a values.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValueArray(int location, const QMatrix3x2 *values, int count)
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    setUniformGenericMatrixArray
-        (d->glfuncs->glUniform2fv, location, values, count,
-         QMatrix3x2, 3, 2);
-}
-
-/*!
-    \overload
-
-    Sets the uniform variable array called \a name in the current
-    context to the \a count 3x2 matrix elements of \a values.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValueArray(const char *name, const QMatrix3x2 *values, int count)
-{
-    setUniformValueArray(uniformLocation(name), values, count);
-}
-
-/*!
-    Sets the uniform variable array at \a location in the current
-    context to the \a count 3x3 matrix elements of \a values.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValueArray(int location, const QMatrix3x3 *values, int count)
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    setUniformMatrixArray
-        (d->glfuncs->glUniformMatrix3fv, location, values, count, QMatrix3x3, 3, 3);
-}
-
-/*!
-    \overload
-
-    Sets the uniform variable array called \a name in the current
-    context to the \a count 3x3 matrix elements of \a values.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValueArray(const char *name, const QMatrix3x3 *values, int count)
-{
-    setUniformValueArray(uniformLocation(name), values, count);
-}
-
-/*!
-    Sets the uniform variable array at \a location in the current
-    context to the \a count 3x4 matrix elements of \a values.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValueArray(int location, const QMatrix3x4 *values, int count)
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    setUniformGenericMatrixArray
-        (d->glfuncs->glUniform4fv, location, values, count,
-         QMatrix3x4, 3, 4);
-}
-
-/*!
-    \overload
-
-    Sets the uniform variable array called \a name in the current
-    context to the \a count 3x4 matrix elements of \a values.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValueArray(const char *name, const QMatrix3x4 *values, int count)
-{
-    setUniformValueArray(uniformLocation(name), values, count);
-}
-
-/*!
-    Sets the uniform variable array at \a location in the current
-    context to the \a count 4x2 matrix elements of \a values.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValueArray(int location, const QMatrix4x2 *values, int count)
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    setUniformGenericMatrixArray
-        (d->glfuncs->glUniform2fv, location, values, count,
-         QMatrix4x2, 4, 2);
-}
-
-/*!
-    \overload
-
-    Sets the uniform variable array called \a name in the current
-    context to the \a count 4x2 matrix elements of \a values.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValueArray(const char *name, const QMatrix4x2 *values, int count)
-{
-    setUniformValueArray(uniformLocation(name), values, count);
-}
-
-/*!
-    Sets the uniform variable array at \a location in the current
-    context to the \a count 4x3 matrix elements of \a values.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValueArray(int location, const QMatrix4x3 *values, int count)
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    setUniformGenericMatrixArray
-        (d->glfuncs->glUniform3fv, location, values, count,
-         QMatrix4x3, 4, 3);
-}
-
-/*!
-    \overload
-
-    Sets the uniform variable array called \a name in the current
-    context to the \a count 4x3 matrix elements of \a values.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValueArray(const char *name, const QMatrix4x3 *values, int count)
-{
-    setUniformValueArray(uniformLocation(name), values, count);
-}
-
-/*!
-    Sets the uniform variable array at \a location in the current
-    context to the \a count 4x4 matrix elements of \a values.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValueArray(int location, const QMatrix4x4 *values, int count)
-{
-    Q_D(QOpenGLShaderProgram);
-    Q_UNUSED(d);
-    setUniformMatrixArray
-        (d->glfuncs->glUniformMatrix4fv, location, values, count, QMatrix4x4, 4, 4);
-}
-
-/*!
-    \overload
-
-    Sets the uniform variable array called \a name in the current
-    context to the \a count 4x4 matrix elements of \a values.
-
-    \sa setAttributeValue()
-*/
-void QOpenGLShaderProgram::setUniformValueArray(const char *name, const QMatrix4x4 *values, int count)
-{
-    setUniformValueArray(uniformLocation(name), values, count);
-}
-
-/*!
-    Returns the hardware limit for how many vertices a geometry shader
-    can output.
-*/
-int QOpenGLShaderProgram::maxGeometryOutputVertices() const
-{
-    GLint n = 0;
-    Q_D(const QOpenGLShaderProgram);
-    d->glfuncs->glGetIntegerv(GL_MAX_GEOMETRY_OUTPUT_VERTICES, &n);
-    return n;
-}
-
-/*!
-    Use this function to specify to OpenGL the number of vertices in
-    a patch to \a count. A patch is a custom OpenGL primitive whose interpretation
-    is entirely defined by the tessellation shader stages. Therefore, calling
-    this function only makes sense when using a QOpenGLShaderProgram
-    containing tessellation stage shaders. When using OpenGL tessellation,
-    the only primitive that can be rendered with \c{glDraw*()} functions is
-    \c{GL_PATCHES}.
-
-    This is equivalent to calling glPatchParameteri(GL_PATCH_VERTICES, count).
-
-    \note This modifies global OpenGL state and is not specific to this
-    QOpenGLShaderProgram instance. You should call this in your render
-    function when needed, as QOpenGLShaderProgram will not apply this for
-    you. This is purely a convenience function.
-
-    \sa patchVertexCount()
-*/
-void QOpenGLShaderProgram::setPatchVertexCount(int count)
-{
-    Q_D(QOpenGLShaderProgram);
-    d->glfuncs->glPatchParameteri(GL_PATCH_VERTICES, count);
-}
-
-/*!
-    Returns the number of vertices per-patch to be used when rendering.
-
-    \note This returns the global OpenGL state value. It is not specific to
-    this QOpenGLShaderProgram instance.
-
-    \sa setPatchVertexCount()
-*/
-int QOpenGLShaderProgram::patchVertexCount() const
-{
-    int patchVertices = 0;
-    Q_D(const QOpenGLShaderProgram);
-    d->glfuncs->glGetIntegerv(GL_PATCH_VERTICES, &patchVertices);
-    return patchVertices;
-}
-
-/*!
-    Sets the default outer tessellation levels to be used by the tessellation
-    primitive generator in the event that the tessellation control shader
-    does not output them to \a levels. For more details on OpenGL and Tessellation
-    shaders see \l{OpenGL Tessellation Shaders}.
-
-    The \a levels argument should be a QVector consisting of 4 floats. Not all
-    of the values make sense for all tessellation modes. If you specify a vector with
-    fewer than 4 elements, the remaining elements will be given a default value of 1.
-
-    \note This modifies global OpenGL state and is not specific to this
-    QOpenGLShaderProgram instance. You should call this in your render
-    function when needed, as QOpenGLShaderProgram will not apply this for
-    you. This is purely a convenience function.
-
-    \note This function is only available with OpenGL >= 4.0 and is not supported
-    with OpenGL ES 3.2.
-
-    \sa defaultOuterTessellationLevels(), setDefaultInnerTessellationLevels()
-*/
-void QOpenGLShaderProgram::setDefaultOuterTessellationLevels(const QVector<float> &levels)
-{
-#ifndef QT_OPENGL_ES_2
-    Q_D(QOpenGLShaderProgram);
-    if (d->tessellationFuncs) {
-        QVector<float> tessLevels = levels;
-
-        // Ensure we have the required 4 outer tessellation levels
-        // Use default of 1 for missing entries (same as spec)
-        const int argCount = 4;
-        if (tessLevels.size() < argCount) {
-            tessLevels.reserve(argCount);
-            for (int i = tessLevels.size(); i < argCount; ++i)
-                tessLevels.append(1.0f);
-        }
-        d->tessellationFuncs->glPatchParameterfv(GL_PATCH_DEFAULT_OUTER_LEVEL, tessLevels.data());
-    }
-#else
-    Q_UNUSED(levels);
-#endif
-}
-
-/*!
-    Returns the default outer tessellation levels to be used by the tessellation
-    primitive generator in the event that the tessellation control shader
-    does not output them. For more details on OpenGL and Tessellation shaders see
-    \l{OpenGL Tessellation Shaders}.
-
-    Returns a QVector of floats describing the outer tessellation levels. The vector
-    will always have four elements but not all of them make sense for every mode
-    of tessellation.
-
-    \note This returns the global OpenGL state value. It is not specific to
-    this QOpenGLShaderProgram instance.
-
-    \note This function is only supported with OpenGL >= 4.0 and will not
-    return valid results with OpenGL ES 3.2.
-
-    \sa setDefaultOuterTessellationLevels(), defaultInnerTessellationLevels()
-*/
-QVector<float> QOpenGLShaderProgram::defaultOuterTessellationLevels() const
-{
-#ifndef QT_OPENGL_ES_2
-    QVector<float> tessLevels(4, 1.0f);
-    Q_D(const QOpenGLShaderProgram);
-    if (d->tessellationFuncs)
-        d->tessellationFuncs->glGetFloatv(GL_PATCH_DEFAULT_OUTER_LEVEL, tessLevels.data());
-    return tessLevels;
-#else
-    return QVector<float>();
-#endif
-}
-
-/*!
-    Sets the default outer tessellation levels to be used by the tessellation
-    primitive generator in the event that the tessellation control shader
-    does not output them to \a levels. For more details on OpenGL and Tessellation shaders see
-    \l{OpenGL Tessellation Shaders}.
-
-    The \a levels argument should be a QVector consisting of 2 floats. Not all
-    of the values make sense for all tessellation modes. If you specify a vector with
-    fewer than 2 elements, the remaining elements will be given a default value of 1.
-
-    \note This modifies global OpenGL state and is not specific to this
-    QOpenGLShaderProgram instance. You should call this in your render
-    function when needed, as QOpenGLShaderProgram will not apply this for
-    you. This is purely a convenience function.
-
-    \note This function is only available with OpenGL >= 4.0 and is not supported
-    with OpenGL ES 3.2.
-
-    \sa defaultInnerTessellationLevels(), setDefaultOuterTessellationLevels()
-*/
-void QOpenGLShaderProgram::setDefaultInnerTessellationLevels(const QVector<float> &levels)
-{
-#ifndef QT_OPENGL_ES_2
-    Q_D(QOpenGLShaderProgram);
-    if (d->tessellationFuncs) {
-        QVector<float> tessLevels = levels;
-
-        // Ensure we have the required 2 inner tessellation levels
-        // Use default of 1 for missing entries (same as spec)
-        const int argCount = 2;
-        if (tessLevels.size() < argCount) {
-            tessLevels.reserve(argCount);
-            for (int i = tessLevels.size(); i < argCount; ++i)
-                tessLevels.append(1.0f);
-        }
-        d->tessellationFuncs->glPatchParameterfv(GL_PATCH_DEFAULT_INNER_LEVEL, tessLevels.data());
-    }
-#else
-    Q_UNUSED(levels);
-#endif
-}
-
-/*!
-    Returns the default inner tessellation levels to be used by the tessellation
-    primitive generator in the event that the tessellation control shader
-    does not output them. For more details on OpenGL and Tessellation shaders see
-    \l{OpenGL Tessellation Shaders}.
-
-    Returns a QVector of floats describing the inner tessellation levels. The vector
-    will always have two elements but not all of them make sense for every mode
-    of tessellation.
-
-    \note This returns the global OpenGL state value. It is not specific to
-    this QOpenGLShaderProgram instance.
-
-    \note This function is only supported with OpenGL >= 4.0 and will not
-    return valid results with OpenGL ES 3.2.
-
-    \sa setDefaultInnerTessellationLevels(), defaultOuterTessellationLevels()
-*/
-QVector<float> QOpenGLShaderProgram::defaultInnerTessellationLevels() const
-{
-#ifndef QT_OPENGL_ES_2
-    QVector<float> tessLevels(2, 1.0f);
-    Q_D(const QOpenGLShaderProgram);
-    if (d->tessellationFuncs)
-        d->tessellationFuncs->glGetFloatv(GL_PATCH_DEFAULT_INNER_LEVEL, tessLevels.data());
-    return tessLevels;
-#else
-    return QVector<float>();
-#endif
-}
-
-
-/*!
-    Returns \c true if shader programs written in the OpenGL Shading
-    Language (GLSL) are supported on this system; false otherwise.
-
-    The \a context is used to resolve the GLSL extensions.
-    If \a context is \nullptr, then QOpenGLContext::currentContext()
-    is used.
-*/
-bool QOpenGLShaderProgram::hasOpenGLShaderPrograms(QOpenGLContext *context)
-{
-    if (!context)
-        context = QOpenGLContext::currentContext();
-    if (!context)
-        return false;
-    return QOpenGLFunctions(context).hasOpenGLFeature(QOpenGLFunctions::Shaders);
-}
-
-/*!
-    \internal
-*/
-void QOpenGLShaderProgram::shaderDestroyed()
-{
-    Q_D(QOpenGLShaderProgram);
-    QOpenGLShader *shader = qobject_cast<QOpenGLShader *>(sender());
-    if (shader && !d->removingShaders)
-        removeShader(shader);
-}
-
-/*!
-    Returns \c true if shader programs of type \a type are supported on
-    this system; false otherwise.
-
-    The \a context is used to resolve the GLSL extensions.
-    If \a context is \nullptr, then QOpenGLContext::currentContext()
-    is used.
-*/
-bool QOpenGLShader::hasOpenGLShaders(ShaderType type, QOpenGLContext *context)
-{
-    if (!context)
-        context = QOpenGLContext::currentContext();
-    if (!context)
-        return false;
-
-    if ((type & ~(Geometry | Vertex | Fragment | TessellationControl | TessellationEvaluation | Compute)) || type == 0)
-        return false;
-
-    if (type & QOpenGLShader::Geometry)
-        return supportsGeometry(context->format());
-    else if (type & (QOpenGLShader::TessellationControl | QOpenGLShader::TessellationEvaluation))
-        return supportsTessellation(context->format());
-    else if (type & QOpenGLShader::Compute)
-        return supportsCompute(context->format());
-
-    // Unconditional support of vertex and fragment shaders implicitly assumes
-    // a minimum OpenGL version of 2.0
-    return true;
-}
-
-bool QOpenGLShaderProgramPrivate::isCacheDisabled() const
-{
-    static QOpenGLProgramBinarySupportCheckWrapper binSupportCheck;
-    return !binSupportCheck.get(QOpenGLContext::currentContext())->isSupported();
-}
-
-bool QOpenGLShaderProgramPrivate::compileCacheable()
-{
-    Q_Q(QOpenGLShaderProgram);
-    for (const QOpenGLProgramBinaryCache::ShaderDesc &shader : qAsConst(binaryProgram.shaders)) {
-        QScopedPointer<QOpenGLShader> s(new QOpenGLShader(qt_shaderStageToType(shader.stage), q));
-        if (!s->compileSourceCode(shader.source)) {
-            log = s->log();
-            return false;
-        }
-        anonShaders.append(s.take());
-        if (!q->addShader(anonShaders.last()))
-            return false;
-    }
-    return true;
-}
-
-bool QOpenGLShaderProgramPrivate::linkBinary()
-{
-    static QOpenGLProgramBinaryCache binCache;
-
-    Q_Q(QOpenGLShaderProgram);
-
-    const QByteArray cacheKey = binaryProgram.cacheKey();
-    if (lcOpenGLProgramDiskCache().isEnabled(QtDebugMsg))
-        qCDebug(lcOpenGLProgramDiskCache, "program with %d shaders, cache key %s",
-                binaryProgram.shaders.count(), cacheKey.constData());
-
-    bool needsCompile = true;
-    if (binCache.load(cacheKey, q->programId())) {
-        qCDebug(lcOpenGLProgramDiskCache, "Program binary received from cache");
-        needsCompile = false;
-    }
-
-    bool needsSave = false;
-    if (needsCompile) {
-        qCDebug(lcOpenGLProgramDiskCache, "Program binary not in cache, compiling");
-        if (compileCacheable())
-            needsSave = true;
-        else
-            return false;
-    }
-
-    linkBinaryRecursion = true;
-    bool ok = q->link();
-    linkBinaryRecursion = false;
-    if (ok && needsSave)
-        binCache.save(cacheKey, q->programId());
-
-    return ok;
-}
-
-QT_END_NAMESPACE
diff --git a/src/gui/opengl/qopenglshaderprogram.h b/src/gui/opengl/qopenglshaderprogram.h
deleted file mode 100644
index c79101fd4d..0000000000
--- a/src/gui/opengl/qopenglshaderprogram.h
+++ /dev/null
@@ -1,318 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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 QOPENGLSHADERPROGRAM_H
-#define QOPENGLSHADERPROGRAM_H
-
-#include <QtGui/qtguiglobal.h>
-
-#ifndef QT_NO_OPENGL
-
-#include <QtGui/qopengl.h>
-#include <QtGui/qvector2d.h>
-#include <QtGui/qvector3d.h>
-#include <QtGui/qvector4d.h>
-#include <QtGui/qmatrix4x4.h>
-
-QT_BEGIN_NAMESPACE
-
-
-class QOpenGLContext;
-class QOpenGLShaderProgram;
-class QOpenGLShaderPrivate;
-
-class Q_GUI_EXPORT QOpenGLShader : public QObject
-{
-    Q_OBJECT
-public:
-    enum ShaderTypeBit
-    {
-        Vertex                 = 0x0001,
-        Fragment               = 0x0002,
-        Geometry               = 0x0004,
-        TessellationControl    = 0x0008,
-        TessellationEvaluation = 0x0010,
-        Compute                = 0x0020
-    };
-    Q_DECLARE_FLAGS(ShaderType, ShaderTypeBit)
-
-    explicit QOpenGLShader(QOpenGLShader::ShaderType type, QObject *parent = nullptr);
-    ~QOpenGLShader();
-
-    QOpenGLShader::ShaderType shaderType() const;
-
-    bool compileSourceCode(const char *source);
-    bool compileSourceCode(const QByteArray& source);
-    bool compileSourceCode(const QString& source);
-    bool compileSourceFile(const QString& fileName);
-
-    QByteArray sourceCode() const;
-
-    bool isCompiled() const;
-    QString log() const;
-
-    GLuint shaderId() const;
-
-    static bool hasOpenGLShaders(ShaderType type, QOpenGLContext *context = nullptr);
-
-private:
-    friend class QOpenGLShaderProgram;
-
-    Q_DISABLE_COPY(QOpenGLShader)
-    Q_DECLARE_PRIVATE(QOpenGLShader)
-};
-
-Q_DECLARE_OPERATORS_FOR_FLAGS(QOpenGLShader::ShaderType)
-
-
-class QOpenGLShaderProgramPrivate;
-
-class Q_GUI_EXPORT QOpenGLShaderProgram : public QObject
-{
-    Q_OBJECT
-public:
-    explicit QOpenGLShaderProgram(QObject *parent = nullptr);
-    ~QOpenGLShaderProgram();
-
-    bool addShader(QOpenGLShader *shader);
-    void removeShader(QOpenGLShader *shader);
-    QList<QOpenGLShader *> shaders() const;
-
-    bool addShaderFromSourceCode(QOpenGLShader::ShaderType type, const char *source);
-    bool addShaderFromSourceCode(QOpenGLShader::ShaderType type, const QByteArray& source);
-    bool addShaderFromSourceCode(QOpenGLShader::ShaderType type, const QString& source);
-    bool addShaderFromSourceFile(QOpenGLShader::ShaderType type, const QString& fileName);
-
-    bool addCacheableShaderFromSourceCode(QOpenGLShader::ShaderType type, const char *source);
-    bool addCacheableShaderFromSourceCode(QOpenGLShader::ShaderType type, const QByteArray &source);
-    bool addCacheableShaderFromSourceCode(QOpenGLShader::ShaderType type, const QString &source);
-    bool addCacheableShaderFromSourceFile(QOpenGLShader::ShaderType type, const QString &fileName);
-
-    void removeAllShaders();
-
-    virtual bool link();
-    bool isLinked() const;
-    QString log() const;
-
-    bool bind();
-    void release();
-
-    bool create();
-
-    GLuint programId() const;
-
-    int maxGeometryOutputVertices() const;
-
-    void setPatchVertexCount(int count);
-    int patchVertexCount() const;
-
-    void setDefaultOuterTessellationLevels(const QVector<float> &levels);
-    QVector<float> defaultOuterTessellationLevels() const;
-
-    void setDefaultInnerTessellationLevels(const QVector<float> &levels);
-    QVector<float> defaultInnerTessellationLevels() const;
-
-    void bindAttributeLocation(const char *name, int location);
-    void bindAttributeLocation(const QByteArray& name, int location);
-    void bindAttributeLocation(const QString& name, int location);
-
-    int attributeLocation(const char *name) const;
-    int attributeLocation(const QByteArray& name) const;
-    int attributeLocation(const QString& name) const;
-
-    void setAttributeValue(int location, GLfloat value);
-    void setAttributeValue(int location, GLfloat x, GLfloat y);
-    void setAttributeValue(int location, GLfloat x, GLfloat y, GLfloat z);
-    void setAttributeValue(int location, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void setAttributeValue(int location, const QVector2D& value);
-    void setAttributeValue(int location, const QVector3D& value);
-    void setAttributeValue(int location, const QVector4D& value);
-    void setAttributeValue(int location, const QColor& value);
-    void setAttributeValue(int location, const GLfloat *values, int columns, int rows);
-
-    void setAttributeValue(const char *name, GLfloat value);
-    void setAttributeValue(const char *name, GLfloat x, GLfloat y);
-    void setAttributeValue(const char *name, GLfloat x, GLfloat y, GLfloat z);
-    void setAttributeValue(const char *name, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void setAttributeValue(const char *name, const QVector2D& value);
-    void setAttributeValue(const char *name, const QVector3D& value);
-    void setAttributeValue(const char *name, const QVector4D& value);
-    void setAttributeValue(const char *name, const QColor& value);
-    void setAttributeValue(const char *name, const GLfloat *values, int columns, int rows);
-
-    void setAttributeArray
-        (int location, const GLfloat *values, int tupleSize, int stride = 0);
-    void setAttributeArray
-        (int location, const QVector2D *values, int stride = 0);
-    void setAttributeArray
-        (int location, const QVector3D *values, int stride = 0);
-    void setAttributeArray
-        (int location, const QVector4D *values, int stride = 0);
-    void setAttributeArray
-        (int location, GLenum type, const void *values, int tupleSize, int stride = 0);
-    void setAttributeArray
-        (const char *name, const GLfloat *values, int tupleSize, int stride = 0);
-    void setAttributeArray
-        (const char *name, const QVector2D *values, int stride = 0);
-    void setAttributeArray
-        (const char *name, const QVector3D *values, int stride = 0);
-    void setAttributeArray
-        (const char *name, const QVector4D *values, int stride = 0);
-    void setAttributeArray
-        (const char *name, GLenum type, const void *values, int tupleSize, int stride = 0);
-
-    void setAttributeBuffer
-        (int location, GLenum type, int offset, int tupleSize, int stride = 0);
-    void setAttributeBuffer
-        (const char *name, GLenum type, int offset, int tupleSize, int stride = 0);
-
-    void enableAttributeArray(int location);
-    void enableAttributeArray(const char *name);
-    void disableAttributeArray(int location);
-    void disableAttributeArray(const char *name);
-
-    int uniformLocation(const char *name) const;
-    int uniformLocation(const QByteArray& name) const;
-    int uniformLocation(const QString& name) const;
-
-    void setUniformValue(int location, GLfloat value);
-    void setUniformValue(int location, GLint value);
-    void setUniformValue(int location, GLuint value);
-    void setUniformValue(int location, GLfloat x, GLfloat y);
-    void setUniformValue(int location, GLfloat x, GLfloat y, GLfloat z);
-    void setUniformValue(int location, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void setUniformValue(int location, const QVector2D& value);
-    void setUniformValue(int location, const QVector3D& value);
-    void setUniformValue(int location, const QVector4D& value);
-    void setUniformValue(int location, const QColor& color);
-    void setUniformValue(int location, const QPoint& point);
-    void setUniformValue(int location, const QPointF& point);
-    void setUniformValue(int location, const QSize& size);
-    void setUniformValue(int location, const QSizeF& size);
-    void setUniformValue(int location, const QMatrix2x2& value);
-    void setUniformValue(int location, const QMatrix2x3& value);
-    void setUniformValue(int location, const QMatrix2x4& value);
-    void setUniformValue(int location, const QMatrix3x2& value);
-    void setUniformValue(int location, const QMatrix3x3& value);
-    void setUniformValue(int location, const QMatrix3x4& value);
-    void setUniformValue(int location, const QMatrix4x2& value);
-    void setUniformValue(int location, const QMatrix4x3& value);
-    void setUniformValue(int location, const QMatrix4x4& value);
-    void setUniformValue(int location, const GLfloat value[2][2]);
-    void setUniformValue(int location, const GLfloat value[3][3]);
-    void setUniformValue(int location, const GLfloat value[4][4]);
-    void setUniformValue(int location, const QTransform& value);
-
-    void setUniformValue(const char *name, GLfloat value);
-    void setUniformValue(const char *name, GLint value);
-    void setUniformValue(const char *name, GLuint value);
-    void setUniformValue(const char *name, GLfloat x, GLfloat y);
-    void setUniformValue(const char *name, GLfloat x, GLfloat y, GLfloat z);
-    void setUniformValue(const char *name, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void setUniformValue(const char *name, const QVector2D& value);
-    void setUniformValue(const char *name, const QVector3D& value);
-    void setUniformValue(const char *name, const QVector4D& value);
-    void setUniformValue(const char *name, const QColor& color);
-    void setUniformValue(const char *name, const QPoint& point);
-    void setUniformValue(const char *name, const QPointF& point);
-    void setUniformValue(const char *name, const QSize& size);
-    void setUniformValue(const char *name, const QSizeF& size);
-    void setUniformValue(const char *name, const QMatrix2x2& value);
-    void setUniformValue(const char *name, const QMatrix2x3& value);
-    void setUniformValue(const char *name, const QMatrix2x4& value);
-    void setUniformValue(const char *name, const QMatrix3x2& value);
-    void setUniformValue(const char *name, const QMatrix3x3& value);
-    void setUniformValue(const char *name, const QMatrix3x4& value);
-    void setUniformValue(const char *name, const QMatrix4x2& value);
-    void setUniformValue(const char *name, const QMatrix4x3& value);
-    void setUniformValue(const char *name, const QMatrix4x4& value);
-    void setUniformValue(const char *name, const GLfloat value[2][2]);
-    void setUniformValue(const char *name, const GLfloat value[3][3]);
-    void setUniformValue(const char *name, const GLfloat value[4][4]);
-    void setUniformValue(const char *name, const QTransform& value);
-
-    void setUniformValueArray(int location, const GLfloat *values, int count, int tupleSize);
-    void setUniformValueArray(int location, const GLint *values, int count);
-    void setUniformValueArray(int location, const GLuint *values, int count);
-    void setUniformValueArray(int location, const QVector2D *values, int count);
-    void setUniformValueArray(int location, const QVector3D *values, int count);
-    void setUniformValueArray(int location, const QVector4D *values, int count);
-    void setUniformValueArray(int location, const QMatrix2x2 *values, int count);
-    void setUniformValueArray(int location, const QMatrix2x3 *values, int count);
-    void setUniformValueArray(int location, const QMatrix2x4 *values, int count);
-    void setUniformValueArray(int location, const QMatrix3x2 *values, int count);
-    void setUniformValueArray(int location, const QMatrix3x3 *values, int count);
-    void setUniformValueArray(int location, const QMatrix3x4 *values, int count);
-    void setUniformValueArray(int location, const QMatrix4x2 *values, int count);
-    void setUniformValueArray(int location, const QMatrix4x3 *values, int count);
-    void setUniformValueArray(int location, const QMatrix4x4 *values, int count);
-
-    void setUniformValueArray(const char *name, const GLfloat *values, int count, int tupleSize);
-    void setUniformValueArray(const char *name, const GLint *values, int count);
-    void setUniformValueArray(const char *name, const GLuint *values, int count);
-    void setUniformValueArray(const char *name, const QVector2D *values, int count);
-    void setUniformValueArray(const char *name, const QVector3D *values, int count);
-    void setUniformValueArray(const char *name, const QVector4D *values, int count);
-    void setUniformValueArray(const char *name, const QMatrix2x2 *values, int count);
-    void setUniformValueArray(const char *name, const QMatrix2x3 *values, int count);
-    void setUniformValueArray(const char *name, const QMatrix2x4 *values, int count);
-    void setUniformValueArray(const char *name, const QMatrix3x2 *values, int count);
-    void setUniformValueArray(const char *name, const QMatrix3x3 *values, int count);
-    void setUniformValueArray(const char *name, const QMatrix3x4 *values, int count);
-    void setUniformValueArray(const char *name, const QMatrix4x2 *values, int count);
-    void setUniformValueArray(const char *name, const QMatrix4x3 *values, int count);
-    void setUniformValueArray(const char *name, const QMatrix4x4 *values, int count);
-
-    static bool hasOpenGLShaderPrograms(QOpenGLContext *context = nullptr);
-
-private Q_SLOTS:
-    void shaderDestroyed();
-
-private:
-    Q_DISABLE_COPY(QOpenGLShaderProgram)
-    Q_DECLARE_PRIVATE(QOpenGLShaderProgram)
-
-    bool init();
-};
-
-QT_END_NAMESPACE
-
-#endif // QT_NO_OPENGL
-
-#endif
diff --git a/src/gui/opengl/qopengltexture.cpp b/src/gui/opengl/qopengltexture.cpp
deleted file mode 100644
index fd282e3ba0..0000000000
--- a/src/gui/opengl/qopengltexture.cpp
+++ /dev/null
@@ -1,4986 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB).
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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 "qopengltexture.h"
-#include "qopengltexture_p.h"
-#include "qopengltexturehelper_p.h"
-#include "qopenglfunctions.h"
-#include <QtGui/qcolor.h>
-#include <QtGui/qopenglcontext.h>
-#include <QtCore/qdebug.h>
-#include <private/qobject_p.h>
-#include <private/qopenglcontext_p.h>
-
-QT_BEGIN_NAMESPACE
-
-//this is to work around GL_TEXTURE_WRAP_R_OES which also has 0x8072 as value
-#if !defined(GL_TEXTURE_WRAP_R)
-    #define GL_TEXTURE_WRAP_R 0x8072
-#endif
-
-QOpenGLTexturePrivate::QOpenGLTexturePrivate(QOpenGLTexture::Target textureTarget,
-                                             QOpenGLTexture *qq)
-    : q_ptr(qq),
-      context(nullptr),
-      target(textureTarget),
-      textureId(0),
-      format(QOpenGLTexture::NoFormat),
-      formatClass(QOpenGLTexture::NoFormatClass),
-      requestedMipLevels(1),
-      mipLevels(-1),
-      layers(1),
-      faces(1),
-      samples(0),
-      fixedSamplePositions(true),
-      baseLevel(0),
-      maxLevel(1000),
-      depthStencilMode(QOpenGLTexture::DepthMode),
-      comparisonFunction(QOpenGLTexture::CompareLessEqual),
-      comparisonMode(QOpenGLTexture::CompareNone),
-      minFilter(QOpenGLTexture::Nearest),
-      magFilter(QOpenGLTexture::Nearest),
-      maxAnisotropy(1.0f),
-      minLevelOfDetail(-1000.0f),
-      maxLevelOfDetail(1000.0f),
-      levelOfDetailBias(0.0f),
-      textureView(false),
-      autoGenerateMipMaps(true),
-      storageAllocated(false),
-      texFuncs(nullptr),
-      functions(nullptr)
-{
-    dimensions[0] = dimensions[1] = dimensions[2] = 1;
-
-    switch (target) {
-    case QOpenGLTexture::Target1D:
-        bindingTarget = QOpenGLTexture::BindingTarget1D;
-        break;
-    case QOpenGLTexture::Target1DArray:
-        bindingTarget = QOpenGLTexture::BindingTarget1DArray;
-        break;
-    case QOpenGLTexture::Target2D:
-        bindingTarget = QOpenGLTexture::BindingTarget2D;
-        break;
-    case QOpenGLTexture::Target2DArray:
-        bindingTarget = QOpenGLTexture::BindingTarget2DArray;
-        break;
-    case QOpenGLTexture::Target3D:
-        bindingTarget = QOpenGLTexture::BindingTarget3D;
-        break;
-    case QOpenGLTexture::TargetCubeMap:
-        bindingTarget = QOpenGLTexture::BindingTargetCubeMap;
-        faces = 6;
-        break;
-    case QOpenGLTexture::TargetCubeMapArray:
-        bindingTarget = QOpenGLTexture::BindingTargetCubeMapArray;
-        faces = 6;
-        break;
-    case QOpenGLTexture::Target2DMultisample:
-        bindingTarget = QOpenGLTexture::BindingTarget2DMultisample;
-        break;
-    case QOpenGLTexture::Target2DMultisampleArray:
-        bindingTarget = QOpenGLTexture::BindingTarget2DMultisampleArray;
-        break;
-    case QOpenGLTexture::TargetRectangle:
-        bindingTarget = QOpenGLTexture::BindingTargetRectangle;
-        break;
-    case QOpenGLTexture::TargetBuffer:
-        bindingTarget = QOpenGLTexture::BindingTargetBuffer;
-        break;
-    }
-
-    swizzleMask[0] = QOpenGLTexture::RedValue;
-    swizzleMask[1] = QOpenGLTexture::GreenValue;
-    swizzleMask[2] = QOpenGLTexture::BlueValue;
-    swizzleMask[3] = QOpenGLTexture::AlphaValue;
-
-    wrapModes[0] = wrapModes[1] = wrapModes[2] = target == QOpenGLTexture::TargetRectangle
-        ? QOpenGLTexture::ClampToEdge : QOpenGLTexture::Repeat;
-}
-
-QOpenGLTexturePrivate::~QOpenGLTexturePrivate()
-{
-    destroy();
-}
-
-void QOpenGLTexturePrivate::initializeOpenGLFunctions()
-{
-    // If we already have a functions object, there is nothing to do
-    if (texFuncs)
-        return;
-
-    // See if the context already has a suitable resource we can use.
-    // If not create a functions object and add it to the context in case
-    // others wish to use it too
-    texFuncs = context->textureFunctions();
-    if (!texFuncs) {
-        texFuncs = new QOpenGLTextureHelper(context);
-        context->setTextureFunctions(texFuncs);
-    }
-}
-
-bool QOpenGLTexturePrivate::create()
-{
-    if (textureId != 0)
-        return true;
-
-    QOpenGLContext *ctx = QOpenGLContext::currentContext();
-    if (!ctx) {
-        qWarning("Requires a valid current OpenGL context.\n"
-                 "Texture has not been created");
-        return false;
-    }
-    context = ctx;
-    functions = ctx->functions();
-
-    // Resolve any functions we will need based upon context version and create the texture
-    initializeOpenGLFunctions();
-
-    // What features do we have?
-    QOpenGLTexture::Feature feature = QOpenGLTexture::ImmutableStorage;
-    while (feature != QOpenGLTexture::MaxFeatureFlag) {
-        if (QOpenGLTexture::hasFeature(feature))
-            features |= feature;
-        feature = static_cast<QOpenGLTexture::Feature>(feature << 1);
-    }
-
-    functions->glGenTextures(1, &textureId);
-    return textureId != 0;
-}
-
-void QOpenGLTexturePrivate::destroy()
-{
-    if (!textureId) {
-        // not created or already destroyed
-        return;
-    }
-    QOpenGLContext *currentContext = QOpenGLContext::currentContext();
-    if (!currentContext) {
-        qWarning("QOpenGLTexturePrivate::destroy() called without a current context.\n"
-                 "Texture has not been destroyed");
-        return;
-    }
-    if (!QOpenGLContext::areSharing(currentContext, context)) {
-
-        qWarning("QOpenGLTexturePrivate::destroy() called but texture context %p"
-                 " is not shared with current context %p.\n"
-                 "Texture has not been destroyed",
-                 static_cast<const void *>(context),
-                 static_cast<const void *>(currentContext));
-        return;
-    }
-
-    functions->glDeleteTextures(1, &textureId);
-
-    context = nullptr;
-    functions = nullptr;
-    textureId = 0;
-    format = QOpenGLTexture::NoFormat;
-    formatClass = QOpenGLTexture::NoFormatClass;
-    requestedMipLevels = 1;
-    mipLevels = -1;
-    layers = 1;
-    faces = 1;
-    samples = 0;
-    fixedSamplePositions = true,
-    baseLevel = 0;
-    maxLevel = 1000;
-    depthStencilMode = QOpenGLTexture::DepthMode;
-    minFilter = QOpenGLTexture::Nearest;
-    magFilter = QOpenGLTexture::Nearest;
-    maxAnisotropy = 1.0f;
-    minLevelOfDetail = -1000.0f;
-    maxLevelOfDetail = 1000.0f;
-    levelOfDetailBias = 0.0f;
-    textureView = false;
-    autoGenerateMipMaps = true;
-    storageAllocated = false;
-    texFuncs = nullptr;
-
-    swizzleMask[0] = QOpenGLTexture::RedValue;
-    swizzleMask[1] = QOpenGLTexture::GreenValue;
-    swizzleMask[2] = QOpenGLTexture::BlueValue;
-    swizzleMask[3] = QOpenGLTexture::AlphaValue;
-
-    wrapModes[0] = wrapModes[1] = wrapModes[2] = target == QOpenGLTexture::TargetRectangle
-        ? QOpenGLTexture::ClampToEdge : QOpenGLTexture::Repeat;
-}
-
-void QOpenGLTexturePrivate::bind()
-{
-    functions->glBindTexture(target, textureId);
-}
-
-void QOpenGLTexturePrivate::bind(uint unit, QOpenGLTexture::TextureUnitReset reset)
-{
-    GLint oldTextureUnit = 0;
-    if (reset == QOpenGLTexture::ResetTextureUnit)
-        functions->glGetIntegerv(GL_ACTIVE_TEXTURE, &oldTextureUnit);
-
-    texFuncs->glActiveTexture(GL_TEXTURE0 + unit);
-    functions->glBindTexture(target, textureId);
-
-    if (reset == QOpenGLTexture::ResetTextureUnit)
-        texFuncs->glActiveTexture(GL_TEXTURE0 + oldTextureUnit);
-}
-
-void QOpenGLTexturePrivate::release()
-{
-    functions->glBindTexture(target, 0);
-}
-
-void QOpenGLTexturePrivate::release(uint unit, QOpenGLTexture::TextureUnitReset reset)
-{
-    GLint oldTextureUnit = 0;
-    if (reset == QOpenGLTexture::ResetTextureUnit)
-        functions->glGetIntegerv(GL_ACTIVE_TEXTURE, &oldTextureUnit);
-
-    texFuncs->glActiveTexture(GL_TEXTURE0 + unit);
-    functions->glBindTexture(target, 0);
-
-    if (reset == QOpenGLTexture::ResetTextureUnit)
-        texFuncs->glActiveTexture(GL_TEXTURE0 + oldTextureUnit);
-}
-
-bool QOpenGLTexturePrivate::isBound() const
-{
-    GLint boundTextureId = 0;
-    functions->glGetIntegerv(bindingTarget, &boundTextureId);
-    return (static_cast<GLuint>(boundTextureId) == textureId);
-}
-
-bool QOpenGLTexturePrivate::isBound(uint unit) const
-{
-    GLint oldTextureUnit = 0;
-    functions->glGetIntegerv(GL_ACTIVE_TEXTURE, &oldTextureUnit);
-
-    GLint boundTextureId = 0;
-    texFuncs->glActiveTexture(GL_TEXTURE0 + unit);
-    functions->glGetIntegerv(bindingTarget, &boundTextureId);
-    bool result = (static_cast<GLuint>(boundTextureId) == textureId);
-
-    texFuncs->glActiveTexture(GL_TEXTURE0 + oldTextureUnit);
-    return result;
-}
-
-int QOpenGLTexturePrivate::evaluateMipLevels() const
-{
-    switch (target) {
-    case QOpenGLTexture::Target1D:
-    case QOpenGLTexture::Target1DArray:
-    case QOpenGLTexture::Target2D:
-    case QOpenGLTexture::Target2DArray:
-    case QOpenGLTexture::Target3D:
-    case QOpenGLTexture::TargetCubeMap:
-    case QOpenGLTexture::TargetCubeMapArray:
-        return qMin(maximumMipLevelCount(), qMax(1, requestedMipLevels));
-
-    case QOpenGLTexture::TargetRectangle:
-    case QOpenGLTexture::Target2DMultisample:
-    case QOpenGLTexture::Target2DMultisampleArray:
-    case QOpenGLTexture::TargetBuffer:
-    default:
-        return 1;
-    }
-}
-
-static bool isSizedTextureFormat(QOpenGLTexture::TextureFormat internalFormat)
-{
-    switch (internalFormat) {
-    case QOpenGLTexture::NoFormat:
-        return false;
-
-    case QOpenGLTexture::R8_UNorm:
-    case QOpenGLTexture::RG8_UNorm:
-    case QOpenGLTexture::RGB8_UNorm:
-    case QOpenGLTexture::RGBA8_UNorm:
-    case QOpenGLTexture::R16_UNorm:
-    case QOpenGLTexture::RG16_UNorm:
-    case QOpenGLTexture::RGB16_UNorm:
-    case QOpenGLTexture::RGBA16_UNorm:
-    case QOpenGLTexture::R8_SNorm:
-    case QOpenGLTexture::RG8_SNorm:
-    case QOpenGLTexture::RGB8_SNorm:
-    case QOpenGLTexture::RGBA8_SNorm:
-    case QOpenGLTexture::R16_SNorm:
-    case QOpenGLTexture::RG16_SNorm:
-    case QOpenGLTexture::RGB16_SNorm:
-    case QOpenGLTexture::RGBA16_SNorm:
-    case QOpenGLTexture::R8U:
-    case QOpenGLTexture::RG8U:
-    case QOpenGLTexture::RGB8U:
-    case QOpenGLTexture::RGBA8U:
-    case QOpenGLTexture::R16U:
-    case QOpenGLTexture::RG16U:
-    case QOpenGLTexture::RGB16U:
-    case QOpenGLTexture::RGBA16U:
-    case QOpenGLTexture::R32U:
-    case QOpenGLTexture::RG32U:
-    case QOpenGLTexture::RGB32U:
-    case QOpenGLTexture::RGBA32U:
-    case QOpenGLTexture::R8I:
-    case QOpenGLTexture::RG8I:
-    case QOpenGLTexture::RGB8I:
-    case QOpenGLTexture::RGBA8I:
-    case QOpenGLTexture::R16I:
-    case QOpenGLTexture::RG16I:
-    case QOpenGLTexture::RGB16I:
-    case QOpenGLTexture::RGBA16I:
-    case QOpenGLTexture::R32I:
-    case QOpenGLTexture::RG32I:
-    case QOpenGLTexture::RGB32I:
-    case QOpenGLTexture::RGBA32I:
-    case QOpenGLTexture::R16F:
-    case QOpenGLTexture::RG16F:
-    case QOpenGLTexture::RGB16F:
-    case QOpenGLTexture::RGBA16F:
-    case QOpenGLTexture::R32F:
-    case QOpenGLTexture::RG32F:
-    case QOpenGLTexture::RGB32F:
-    case QOpenGLTexture::RGBA32F:
-    case QOpenGLTexture::RGB9E5:
-    case QOpenGLTexture::RG11B10F:
-    case QOpenGLTexture::RG3B2:
-    case QOpenGLTexture::R5G6B5:
-    case QOpenGLTexture::RGB5A1:
-    case QOpenGLTexture::RGBA4:
-    case QOpenGLTexture::RGB10A2:
-
-    case QOpenGLTexture::D16:
-    case QOpenGLTexture::D24:
-    case QOpenGLTexture::D32:
-    case QOpenGLTexture::D32F:
-
-    case QOpenGLTexture::D24S8:
-    case QOpenGLTexture::D32FS8X24:
-
-    case QOpenGLTexture::S8:
-
-    case QOpenGLTexture::RGB_DXT1:
-    case QOpenGLTexture::RGBA_DXT1:
-    case QOpenGLTexture::RGBA_DXT3:
-    case QOpenGLTexture::RGBA_DXT5:
-    case QOpenGLTexture::R_ATI1N_UNorm:
-    case QOpenGLTexture::R_ATI1N_SNorm:
-    case QOpenGLTexture::RG_ATI2N_UNorm:
-    case QOpenGLTexture::RG_ATI2N_SNorm:
-    case QOpenGLTexture::RGB_BP_UNSIGNED_FLOAT:
-    case QOpenGLTexture::RGB_BP_SIGNED_FLOAT:
-    case QOpenGLTexture::RGB_BP_UNorm:
-    case QOpenGLTexture::SRGB8:
-    case QOpenGLTexture::SRGB8_Alpha8:
-    case QOpenGLTexture::SRGB_DXT1:
-    case QOpenGLTexture::SRGB_Alpha_DXT1:
-    case QOpenGLTexture::SRGB_Alpha_DXT3:
-    case QOpenGLTexture::SRGB_Alpha_DXT5:
-    case QOpenGLTexture::SRGB_BP_UNorm:
-    case QOpenGLTexture::R11_EAC_UNorm:
-    case QOpenGLTexture::R11_EAC_SNorm:
-    case QOpenGLTexture::RG11_EAC_UNorm:
-    case QOpenGLTexture::RG11_EAC_SNorm:
-    case QOpenGLTexture::RGB8_ETC2:
-    case QOpenGLTexture::SRGB8_ETC2:
-    case QOpenGLTexture::RGB8_PunchThrough_Alpha1_ETC2:
-    case QOpenGLTexture::SRGB8_PunchThrough_Alpha1_ETC2:
-    case QOpenGLTexture::RGBA8_ETC2_EAC:
-    case QOpenGLTexture::SRGB8_Alpha8_ETC2_EAC:
-    case QOpenGLTexture::RGBA_ASTC_4x4:
-    case QOpenGLTexture::RGBA_ASTC_5x4:
-    case QOpenGLTexture::RGBA_ASTC_5x5:
-    case QOpenGLTexture::RGBA_ASTC_6x5:
-    case QOpenGLTexture::RGBA_ASTC_6x6:
-    case QOpenGLTexture::RGBA_ASTC_8x5:
-    case QOpenGLTexture::RGBA_ASTC_8x6:
-    case QOpenGLTexture::RGBA_ASTC_8x8:
-    case QOpenGLTexture::RGBA_ASTC_10x5:
-    case QOpenGLTexture::RGBA_ASTC_10x6:
-    case QOpenGLTexture::RGBA_ASTC_10x8:
-    case QOpenGLTexture::RGBA_ASTC_10x10:
-    case QOpenGLTexture::RGBA_ASTC_12x10:
-    case QOpenGLTexture::RGBA_ASTC_12x12:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_4x4:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_5x4:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_5x5:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_6x5:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_6x6:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_8x5:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_8x6:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_8x8:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_10x5:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_10x6:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_10x8:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_10x10:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_12x10:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_12x12:
-        return true;
-
-    case QOpenGLTexture::RGB8_ETC1:
-        return false;
-
-    case QOpenGLTexture::DepthFormat:
-    case QOpenGLTexture::AlphaFormat:
-
-    case QOpenGLTexture::RGBFormat:
-    case QOpenGLTexture::RGBAFormat:
-
-    case QOpenGLTexture::LuminanceFormat:
-
-    case QOpenGLTexture::LuminanceAlphaFormat:
-        return false;
-    }
-
-    Q_UNREACHABLE();
-    return false;
-}
-
-static bool isTextureTargetMultisample(QOpenGLTexture::Target target)
-{
-    switch (target) {
-    case QOpenGLTexture::Target1D:
-    case QOpenGLTexture::Target1DArray:
-    case QOpenGLTexture::Target2D:
-    case QOpenGLTexture::Target2DArray:
-    case QOpenGLTexture::Target3D:
-    case QOpenGLTexture::TargetCubeMap:
-    case QOpenGLTexture::TargetCubeMapArray:
-        return false;
-
-    case QOpenGLTexture::Target2DMultisample:
-    case QOpenGLTexture::Target2DMultisampleArray:
-        return true;
-
-    case QOpenGLTexture::TargetRectangle:
-    case QOpenGLTexture::TargetBuffer:
-        return false;
-    }
-
-    Q_UNREACHABLE();
-    return false;
-}
-
-bool QOpenGLTexturePrivate::isUsingImmutableStorage() const
-{
-    // Use immutable storage whenever possible, falling back to mutable
-    // Note that if multisample textures are not supported at all, we'll still fail into
-    // the mutable storage allocation
-    return isSizedTextureFormat(format)
-            && (isTextureTargetMultisample(target)
-                ? features.testFlag(QOpenGLTexture::ImmutableMultisampleStorage)
-                : features.testFlag(QOpenGLTexture::ImmutableStorage));
-}
-
-void QOpenGLTexturePrivate::allocateStorage(QOpenGLTexture::PixelFormat pixelFormat, QOpenGLTexture::PixelType pixelType)
-{
-    // Resolve the actual number of mipmap levels we can use
-    mipLevels = evaluateMipLevels();
-
-    if (isUsingImmutableStorage())
-        allocateImmutableStorage();
-    else
-        allocateMutableStorage(pixelFormat, pixelType);
-}
-
-static QOpenGLTexture::PixelFormat pixelFormatCompatibleWithInternalFormat(QOpenGLTexture::TextureFormat internalFormat)
-{
-    switch (internalFormat) {
-    case QOpenGLTexture::NoFormat:
-        return QOpenGLTexture::NoSourceFormat;
-
-    case QOpenGLTexture::R8_UNorm:
-        return QOpenGLTexture::Red;
-
-    case QOpenGLTexture::RG8_UNorm:
-        return QOpenGLTexture::RG;
-
-    case QOpenGLTexture::RGB8_UNorm:
-        return QOpenGLTexture::RGB;
-
-    case QOpenGLTexture::RGBA8_UNorm:
-        return QOpenGLTexture::RGBA;
-
-    case QOpenGLTexture::R16_UNorm:
-        return QOpenGLTexture::Red;
-
-    case QOpenGLTexture::RG16_UNorm:
-        return QOpenGLTexture::RG;
-
-    case QOpenGLTexture::RGB16_UNorm:
-        return QOpenGLTexture::RGB;
-
-    case QOpenGLTexture::RGBA16_UNorm:
-        return QOpenGLTexture::RGBA;
-
-    case QOpenGLTexture::R8_SNorm:
-        return QOpenGLTexture::Red;
-
-    case QOpenGLTexture::RG8_SNorm:
-        return QOpenGLTexture::RG;
-
-    case QOpenGLTexture::RGB8_SNorm:
-        return QOpenGLTexture::RGB;
-
-    case QOpenGLTexture::RGBA8_SNorm:
-        return QOpenGLTexture::RGBA;
-
-    case QOpenGLTexture::R16_SNorm:
-        return QOpenGLTexture::Red;
-
-    case QOpenGLTexture::RG16_SNorm:
-        return QOpenGLTexture::RG;
-
-    case QOpenGLTexture::RGB16_SNorm:
-        return QOpenGLTexture::RGB;
-
-    case QOpenGLTexture::RGBA16_SNorm:
-        return QOpenGLTexture::RGBA;
-
-    case QOpenGLTexture::R8U:
-        return QOpenGLTexture::Red_Integer;
-
-    case QOpenGLTexture::RG8U:
-        return QOpenGLTexture::RG_Integer;
-
-    case QOpenGLTexture::RGB8U:
-        return QOpenGLTexture::RGB_Integer;
-
-    case QOpenGLTexture::RGBA8U:
-        return QOpenGLTexture::RGBA_Integer;
-
-    case QOpenGLTexture::R16U:
-        return QOpenGLTexture::Red_Integer;
-
-    case QOpenGLTexture::RG16U:
-        return QOpenGLTexture::RG_Integer;
-
-    case QOpenGLTexture::RGB16U:
-        return QOpenGLTexture::RGB_Integer;
-
-    case QOpenGLTexture::RGBA16U:
-        return QOpenGLTexture::RGBA_Integer;
-
-    case QOpenGLTexture::R32U:
-        return QOpenGLTexture::Red_Integer;
-
-    case QOpenGLTexture::RG32U:
-        return QOpenGLTexture::RG_Integer;
-
-    case QOpenGLTexture::RGB32U:
-        return QOpenGLTexture::RGB_Integer;
-
-    case QOpenGLTexture::RGBA32U:
-        return QOpenGLTexture::RGBA_Integer;
-
-    case QOpenGLTexture::R8I:
-        return QOpenGLTexture::Red_Integer;
-
-    case QOpenGLTexture::RG8I:
-        return QOpenGLTexture::RG_Integer;
-
-    case QOpenGLTexture::RGB8I:
-        return QOpenGLTexture::RGB_Integer;
-
-    case QOpenGLTexture::RGBA8I:
-        return QOpenGLTexture::RGBA_Integer;
-
-    case QOpenGLTexture::R16I:
-        return QOpenGLTexture::Red_Integer;
-
-    case QOpenGLTexture::RG16I:
-        return QOpenGLTexture::RG_Integer;
-
-    case QOpenGLTexture::RGB16I:
-        return QOpenGLTexture::RGB_Integer;
-
-    case QOpenGLTexture::RGBA16I:
-        return QOpenGLTexture::RGBA_Integer;
-
-    case QOpenGLTexture::R32I:
-        return QOpenGLTexture::Red_Integer;
-
-    case QOpenGLTexture::RG32I:
-        return QOpenGLTexture::RG_Integer;
-
-    case QOpenGLTexture::RGB32I:
-        return QOpenGLTexture::RGB_Integer;
-
-    case QOpenGLTexture::RGBA32I:
-        return QOpenGLTexture::RGBA_Integer;
-
-    case QOpenGLTexture::R16F:
-        return QOpenGLTexture::Red;
-
-    case QOpenGLTexture::RG16F:
-        return QOpenGLTexture::RG;
-
-    case QOpenGLTexture::RGB16F:
-        return QOpenGLTexture::RGB;
-
-    case QOpenGLTexture::RGBA16F:
-        return QOpenGLTexture::RGBA;
-
-    case QOpenGLTexture::R32F:
-        return QOpenGLTexture::Red;
-
-    case QOpenGLTexture::RG32F:
-        return QOpenGLTexture::RG;
-
-    case QOpenGLTexture::RGB32F:
-        return QOpenGLTexture::RGB;
-
-    case QOpenGLTexture::RGBA32F:
-        return QOpenGLTexture::RGBA;
-
-    case QOpenGLTexture::RGB9E5:
-        return QOpenGLTexture::RGB;
-
-    case QOpenGLTexture::RG11B10F:
-        return QOpenGLTexture::RGB;
-
-    case QOpenGLTexture::RG3B2:
-        return QOpenGLTexture::RGB;
-
-    case QOpenGLTexture::R5G6B5:
-        return QOpenGLTexture::RGB;
-
-    case QOpenGLTexture::RGB5A1:
-        return QOpenGLTexture::RGBA;
-
-    case QOpenGLTexture::RGBA4:
-        return QOpenGLTexture::RGBA;
-
-    case QOpenGLTexture::RGB10A2:
-        return QOpenGLTexture::RGBA;
-
-    case QOpenGLTexture::D16:
-    case QOpenGLTexture::D24:
-    case QOpenGLTexture::D32:
-    case QOpenGLTexture::D32F:
-        return QOpenGLTexture::Depth;
-
-    case QOpenGLTexture::D24S8:
-    case QOpenGLTexture::D32FS8X24:
-        return QOpenGLTexture::DepthStencil;
-
-    case QOpenGLTexture::S8:
-        return QOpenGLTexture::Stencil;
-
-    case QOpenGLTexture::RGB_DXT1:
-    case QOpenGLTexture::RGBA_DXT1:
-    case QOpenGLTexture::RGBA_DXT3:
-    case QOpenGLTexture::RGBA_DXT5:
-    case QOpenGLTexture::R_ATI1N_UNorm:
-    case QOpenGLTexture::R_ATI1N_SNorm:
-    case QOpenGLTexture::RG_ATI2N_UNorm:
-    case QOpenGLTexture::RG_ATI2N_SNorm:
-    case QOpenGLTexture::RGB_BP_UNSIGNED_FLOAT:
-    case QOpenGLTexture::RGB_BP_SIGNED_FLOAT:
-    case QOpenGLTexture::RGB_BP_UNorm:
-    case QOpenGLTexture::SRGB8:
-    case QOpenGLTexture::SRGB8_Alpha8:
-    case QOpenGLTexture::SRGB_DXT1:
-    case QOpenGLTexture::SRGB_Alpha_DXT1:
-    case QOpenGLTexture::SRGB_Alpha_DXT3:
-    case QOpenGLTexture::SRGB_Alpha_DXT5:
-    case QOpenGLTexture::SRGB_BP_UNorm:
-    case QOpenGLTexture::RGB8_ETC1:
-        return QOpenGLTexture::RGBA;
-
-    case QOpenGLTexture::R11_EAC_UNorm:
-    case QOpenGLTexture::R11_EAC_SNorm:
-        return QOpenGLTexture::Red;
-
-    case QOpenGLTexture::RG11_EAC_UNorm:
-    case QOpenGLTexture::RG11_EAC_SNorm:
-        return QOpenGLTexture::RG;
-
-    case QOpenGLTexture::RGB8_ETC2:
-    case QOpenGLTexture::SRGB8_ETC2:
-        return QOpenGLTexture::RGB;
-
-    case QOpenGLTexture::RGB8_PunchThrough_Alpha1_ETC2:
-    case QOpenGLTexture::SRGB8_PunchThrough_Alpha1_ETC2:
-        return QOpenGLTexture::RGBA;
-
-    case QOpenGLTexture::RGBA8_ETC2_EAC:
-    case QOpenGLTexture::SRGB8_Alpha8_ETC2_EAC:
-        return QOpenGLTexture::RGBA;
-
-    case QOpenGLTexture::RGBA_ASTC_4x4:
-    case QOpenGLTexture::RGBA_ASTC_5x4:
-    case QOpenGLTexture::RGBA_ASTC_5x5:
-    case QOpenGLTexture::RGBA_ASTC_6x5:
-    case QOpenGLTexture::RGBA_ASTC_6x6:
-    case QOpenGLTexture::RGBA_ASTC_8x5:
-    case QOpenGLTexture::RGBA_ASTC_8x6:
-    case QOpenGLTexture::RGBA_ASTC_8x8:
-    case QOpenGLTexture::RGBA_ASTC_10x5:
-    case QOpenGLTexture::RGBA_ASTC_10x6:
-    case QOpenGLTexture::RGBA_ASTC_10x8:
-    case QOpenGLTexture::RGBA_ASTC_10x10:
-    case QOpenGLTexture::RGBA_ASTC_12x10:
-    case QOpenGLTexture::RGBA_ASTC_12x12:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_4x4:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_5x4:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_5x5:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_6x5:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_6x6:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_8x5:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_8x6:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_8x8:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_10x5:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_10x6:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_10x8:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_10x10:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_12x10:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_12x12:
-        return QOpenGLTexture::RGBA;
-
-    case QOpenGLTexture::DepthFormat:
-        return QOpenGLTexture::Depth;
-
-    case QOpenGLTexture::AlphaFormat:
-        return QOpenGLTexture::Alpha;
-
-    case QOpenGLTexture::RGBFormat:
-        return QOpenGLTexture::RGB;
-
-    case QOpenGLTexture::RGBAFormat:
-        return QOpenGLTexture::RGBA;
-
-    case QOpenGLTexture::LuminanceFormat:
-        return QOpenGLTexture::Luminance;
-
-    case QOpenGLTexture::LuminanceAlphaFormat:
-        return QOpenGLTexture::LuminanceAlpha;
-    }
-
-    Q_UNREACHABLE();
-    return QOpenGLTexture::NoSourceFormat;
-}
-
-static QOpenGLTexture::PixelType pixelTypeCompatibleWithInternalFormat(QOpenGLTexture::TextureFormat internalFormat)
-{
-    switch (internalFormat) {
-    case QOpenGLTexture::NoFormat:
-        return QOpenGLTexture::NoPixelType;
-
-    case QOpenGLTexture::R8_UNorm:
-    case QOpenGLTexture::RG8_UNorm:
-    case QOpenGLTexture::RGB8_UNorm:
-    case QOpenGLTexture::RGBA8_UNorm:
-    case QOpenGLTexture::R16_UNorm:
-    case QOpenGLTexture::RG16_UNorm:
-    case QOpenGLTexture::RGB16_UNorm:
-    case QOpenGLTexture::RGBA16_UNorm:
-        return QOpenGLTexture::UInt8;
-
-    case QOpenGLTexture::R8_SNorm:
-    case QOpenGLTexture::RG8_SNorm:
-    case QOpenGLTexture::RGB8_SNorm:
-    case QOpenGLTexture::RGBA8_SNorm:
-    case QOpenGLTexture::R16_SNorm:
-    case QOpenGLTexture::RG16_SNorm:
-    case QOpenGLTexture::RGB16_SNorm:
-    case QOpenGLTexture::RGBA16_SNorm:
-        return QOpenGLTexture::Int8;
-
-    case QOpenGLTexture::R8U:
-    case QOpenGLTexture::RG8U:
-    case QOpenGLTexture::RGB8U:
-    case QOpenGLTexture::RGBA8U:
-    case QOpenGLTexture::R16U:
-    case QOpenGLTexture::RG16U:
-    case QOpenGLTexture::RGB16U:
-    case QOpenGLTexture::RGBA16U:
-    case QOpenGLTexture::R32U:
-    case QOpenGLTexture::RG32U:
-    case QOpenGLTexture::RGB32U:
-    case QOpenGLTexture::RGBA32U:
-        return QOpenGLTexture::UInt8;
-
-    case QOpenGLTexture::R8I:
-    case QOpenGLTexture::RG8I:
-    case QOpenGLTexture::RGB8I:
-    case QOpenGLTexture::RGBA8I:
-    case QOpenGLTexture::R16I:
-    case QOpenGLTexture::RG16I:
-    case QOpenGLTexture::RGB16I:
-    case QOpenGLTexture::RGBA16I:
-    case QOpenGLTexture::R32I:
-    case QOpenGLTexture::RG32I:
-    case QOpenGLTexture::RGB32I:
-    case QOpenGLTexture::RGBA32I:
-        return QOpenGLTexture::Int8;
-
-    case QOpenGLTexture::R16F:
-    case QOpenGLTexture::RG16F:
-    case QOpenGLTexture::RGB16F:
-    case QOpenGLTexture::RGBA16F:
-        return QOpenGLTexture::Float16;
-
-    case QOpenGLTexture::R32F:
-    case QOpenGLTexture::RG32F:
-    case QOpenGLTexture::RGB32F:
-    case QOpenGLTexture::RGBA32F:
-        return QOpenGLTexture::Float32;
-
-    case QOpenGLTexture::RGB9E5:
-        return QOpenGLTexture::UInt16_RGB5A1_Rev;
-
-    case QOpenGLTexture::RG11B10F:
-        return QOpenGLTexture::UInt32_RG11B10F;
-
-    case QOpenGLTexture::RG3B2:
-        return QOpenGLTexture::UInt8_RG3B2;
-
-    case QOpenGLTexture::R5G6B5:
-        return QOpenGLTexture::UInt16_R5G6B5;
-
-    case QOpenGLTexture::RGB5A1:
-        return QOpenGLTexture::UInt16_RGB5A1;
-
-    case QOpenGLTexture::RGBA4:
-        return QOpenGLTexture::UInt16_RGBA4;
-
-    case QOpenGLTexture::RGB10A2:
-        return QOpenGLTexture::UInt32_RGB10A2;
-
-    case QOpenGLTexture::D16:
-        return QOpenGLTexture::UInt16;
-
-    case QOpenGLTexture::D24:
-    case QOpenGLTexture::D32:
-        return QOpenGLTexture::UInt32;
-
-    case QOpenGLTexture::D32F:
-        return QOpenGLTexture::Float32;
-
-    case QOpenGLTexture::D24S8:
-        return QOpenGLTexture::UInt32_D24S8;
-
-    case QOpenGLTexture::D32FS8X24:
-        return QOpenGLTexture::Float32_D32_UInt32_S8_X24;
-
-    case QOpenGLTexture::S8:
-        return QOpenGLTexture::UInt8;
-
-    case QOpenGLTexture::RGB_DXT1:
-    case QOpenGLTexture::RGBA_DXT1:
-    case QOpenGLTexture::RGBA_DXT3:
-    case QOpenGLTexture::RGBA_DXT5:
-    case QOpenGLTexture::R_ATI1N_UNorm:
-    case QOpenGLTexture::R_ATI1N_SNorm:
-    case QOpenGLTexture::RG_ATI2N_UNorm:
-    case QOpenGLTexture::RG_ATI2N_SNorm:
-    case QOpenGLTexture::RGB_BP_UNSIGNED_FLOAT:
-    case QOpenGLTexture::RGB_BP_SIGNED_FLOAT:
-    case QOpenGLTexture::RGB_BP_UNorm:
-    case QOpenGLTexture::SRGB8:
-    case QOpenGLTexture::SRGB8_Alpha8:
-    case QOpenGLTexture::SRGB_DXT1:
-    case QOpenGLTexture::SRGB_Alpha_DXT1:
-    case QOpenGLTexture::SRGB_Alpha_DXT3:
-    case QOpenGLTexture::SRGB_Alpha_DXT5:
-    case QOpenGLTexture::SRGB_BP_UNorm:
-    case QOpenGLTexture::R11_EAC_UNorm:
-    case QOpenGLTexture::R11_EAC_SNorm:
-    case QOpenGLTexture::RG11_EAC_UNorm:
-    case QOpenGLTexture::RG11_EAC_SNorm:
-    case QOpenGLTexture::RGB8_ETC2:
-    case QOpenGLTexture::SRGB8_ETC2:
-    case QOpenGLTexture::RGB8_PunchThrough_Alpha1_ETC2:
-    case QOpenGLTexture::SRGB8_PunchThrough_Alpha1_ETC2:
-    case QOpenGLTexture::RGBA8_ETC2_EAC:
-    case QOpenGLTexture::SRGB8_Alpha8_ETC2_EAC:
-    case QOpenGLTexture::RGB8_ETC1:
-    case QOpenGLTexture::RGBA_ASTC_4x4:
-    case QOpenGLTexture::RGBA_ASTC_5x4:
-    case QOpenGLTexture::RGBA_ASTC_5x5:
-    case QOpenGLTexture::RGBA_ASTC_6x5:
-    case QOpenGLTexture::RGBA_ASTC_6x6:
-    case QOpenGLTexture::RGBA_ASTC_8x5:
-    case QOpenGLTexture::RGBA_ASTC_8x6:
-    case QOpenGLTexture::RGBA_ASTC_8x8:
-    case QOpenGLTexture::RGBA_ASTC_10x5:
-    case QOpenGLTexture::RGBA_ASTC_10x6:
-    case QOpenGLTexture::RGBA_ASTC_10x8:
-    case QOpenGLTexture::RGBA_ASTC_10x10:
-    case QOpenGLTexture::RGBA_ASTC_12x10:
-    case QOpenGLTexture::RGBA_ASTC_12x12:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_4x4:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_5x4:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_5x5:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_6x5:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_6x6:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_8x5:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_8x6:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_8x8:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_10x5:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_10x6:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_10x8:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_10x10:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_12x10:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_12x12:
-        return QOpenGLTexture::UInt8;
-
-    case QOpenGLTexture::DepthFormat:
-        return QOpenGLTexture::UInt32;
-
-    case QOpenGLTexture::AlphaFormat:
-    case QOpenGLTexture::RGBFormat:
-    case QOpenGLTexture::RGBAFormat:
-    case QOpenGLTexture::LuminanceFormat:
-    case QOpenGLTexture::LuminanceAlphaFormat:
-        return QOpenGLTexture::UInt8;
-    }
-
-    Q_UNREACHABLE();
-    return QOpenGLTexture::NoPixelType;
-}
-
-static bool isCompressedFormat(QOpenGLTexture::TextureFormat internalFormat)
-{
-    switch (internalFormat) {
-    case QOpenGLTexture::NoFormat:
-
-    case QOpenGLTexture::R8_UNorm:
-    case QOpenGLTexture::RG8_UNorm:
-    case QOpenGLTexture::RGB8_UNorm:
-    case QOpenGLTexture::RGBA8_UNorm:
-    case QOpenGLTexture::R16_UNorm:
-    case QOpenGLTexture::RG16_UNorm:
-    case QOpenGLTexture::RGB16_UNorm:
-    case QOpenGLTexture::RGBA16_UNorm:
-    case QOpenGLTexture::R8_SNorm:
-    case QOpenGLTexture::RG8_SNorm:
-    case QOpenGLTexture::RGB8_SNorm:
-    case QOpenGLTexture::RGBA8_SNorm:
-    case QOpenGLTexture::R16_SNorm:
-    case QOpenGLTexture::RG16_SNorm:
-    case QOpenGLTexture::RGB16_SNorm:
-    case QOpenGLTexture::RGBA16_SNorm:
-    case QOpenGLTexture::R8U:
-    case QOpenGLTexture::RG8U:
-    case QOpenGLTexture::RGB8U:
-    case QOpenGLTexture::RGBA8U:
-    case QOpenGLTexture::R16U:
-    case QOpenGLTexture::RG16U:
-    case QOpenGLTexture::RGB16U:
-    case QOpenGLTexture::RGBA16U:
-    case QOpenGLTexture::R32U:
-    case QOpenGLTexture::RG32U:
-    case QOpenGLTexture::RGB32U:
-    case QOpenGLTexture::RGBA32U:
-    case QOpenGLTexture::R8I:
-    case QOpenGLTexture::RG8I:
-    case QOpenGLTexture::RGB8I:
-    case QOpenGLTexture::RGBA8I:
-    case QOpenGLTexture::R16I:
-    case QOpenGLTexture::RG16I:
-    case QOpenGLTexture::RGB16I:
-    case QOpenGLTexture::RGBA16I:
-    case QOpenGLTexture::R32I:
-    case QOpenGLTexture::RG32I:
-    case QOpenGLTexture::RGB32I:
-    case QOpenGLTexture::RGBA32I:
-    case QOpenGLTexture::R16F:
-    case QOpenGLTexture::RG16F:
-    case QOpenGLTexture::RGB16F:
-    case QOpenGLTexture::RGBA16F:
-    case QOpenGLTexture::R32F:
-    case QOpenGLTexture::RG32F:
-    case QOpenGLTexture::RGB32F:
-    case QOpenGLTexture::RGBA32F:
-    case QOpenGLTexture::RGB9E5:
-    case QOpenGLTexture::RG11B10F:
-    case QOpenGLTexture::RG3B2:
-    case QOpenGLTexture::R5G6B5:
-    case QOpenGLTexture::RGB5A1:
-    case QOpenGLTexture::RGBA4:
-    case QOpenGLTexture::RGB10A2:
-
-    case QOpenGLTexture::D16:
-    case QOpenGLTexture::D24:
-    case QOpenGLTexture::D32:
-    case QOpenGLTexture::D32F:
-
-    case QOpenGLTexture::D24S8:
-    case QOpenGLTexture::D32FS8X24:
-
-    case QOpenGLTexture::S8:
-        return false;
-
-    case QOpenGLTexture::RGB_DXT1:
-    case QOpenGLTexture::RGBA_DXT1:
-    case QOpenGLTexture::RGBA_DXT3:
-    case QOpenGLTexture::RGBA_DXT5:
-    case QOpenGLTexture::R_ATI1N_UNorm:
-    case QOpenGLTexture::R_ATI1N_SNorm:
-    case QOpenGLTexture::RG_ATI2N_UNorm:
-    case QOpenGLTexture::RG_ATI2N_SNorm:
-    case QOpenGLTexture::RGB_BP_UNSIGNED_FLOAT:
-    case QOpenGLTexture::RGB_BP_SIGNED_FLOAT:
-    case QOpenGLTexture::RGB_BP_UNorm:
-    case QOpenGLTexture::SRGB8:
-    case QOpenGLTexture::SRGB8_Alpha8:
-    case QOpenGLTexture::SRGB_DXT1:
-    case QOpenGLTexture::SRGB_Alpha_DXT1:
-    case QOpenGLTexture::SRGB_Alpha_DXT3:
-    case QOpenGLTexture::SRGB_Alpha_DXT5:
-    case QOpenGLTexture::SRGB_BP_UNorm:
-    case QOpenGLTexture::R11_EAC_UNorm:
-    case QOpenGLTexture::R11_EAC_SNorm:
-    case QOpenGLTexture::RG11_EAC_UNorm:
-    case QOpenGLTexture::RG11_EAC_SNorm:
-    case QOpenGLTexture::RGB8_ETC2:
-    case QOpenGLTexture::SRGB8_ETC2:
-    case QOpenGLTexture::RGB8_PunchThrough_Alpha1_ETC2:
-    case QOpenGLTexture::SRGB8_PunchThrough_Alpha1_ETC2:
-    case QOpenGLTexture::RGBA8_ETC2_EAC:
-    case QOpenGLTexture::SRGB8_Alpha8_ETC2_EAC:
-    case QOpenGLTexture::RGB8_ETC1:
-    case QOpenGLTexture::RGBA_ASTC_4x4:
-    case QOpenGLTexture::RGBA_ASTC_5x4:
-    case QOpenGLTexture::RGBA_ASTC_5x5:
-    case QOpenGLTexture::RGBA_ASTC_6x5:
-    case QOpenGLTexture::RGBA_ASTC_6x6:
-    case QOpenGLTexture::RGBA_ASTC_8x5:
-    case QOpenGLTexture::RGBA_ASTC_8x6:
-    case QOpenGLTexture::RGBA_ASTC_8x8:
-    case QOpenGLTexture::RGBA_ASTC_10x5:
-    case QOpenGLTexture::RGBA_ASTC_10x6:
-    case QOpenGLTexture::RGBA_ASTC_10x8:
-    case QOpenGLTexture::RGBA_ASTC_10x10:
-    case QOpenGLTexture::RGBA_ASTC_12x10:
-    case QOpenGLTexture::RGBA_ASTC_12x12:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_4x4:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_5x4:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_5x5:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_6x5:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_6x6:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_8x5:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_8x6:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_8x8:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_10x5:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_10x6:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_10x8:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_10x10:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_12x10:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_12x12:
-        return true;
-
-    case QOpenGLTexture::DepthFormat:
-    case QOpenGLTexture::AlphaFormat:
-    case QOpenGLTexture::RGBFormat:
-    case QOpenGLTexture::RGBAFormat:
-    case QOpenGLTexture::LuminanceFormat:
-    case QOpenGLTexture::LuminanceAlphaFormat:
-        return false;
-    }
-
-    Q_UNREACHABLE();
-    return false;
-}
-
-void QOpenGLTexturePrivate::allocateMutableStorage(QOpenGLTexture::PixelFormat pixelFormat, QOpenGLTexture::PixelType pixelType)
-{
-    // There is no way to allocate mutable storage for compressed textures in in
-    // versions older than OpenGL 3.1 and OpenGL ES 3.0, because the older specs
-    // do not mandate accepting null data pointers for glCompressedTexImage*D,
-    // unlike glTexImage*D (which in turn does not accept compressed formats).
-    if (isCompressedFormat(format)) {
-        storageAllocated = true;
-        return;
-    }
-
-    switch (target) {
-    case QOpenGLTexture::TargetBuffer:
-        // Buffer textures get their storage from an external OpenGL buffer
-        qWarning("Buffer textures do not allocate storage");
-        return;
-
-    case QOpenGLTexture::Target1D:
-        if (features.testFlag(QOpenGLTexture::Texture1D)) {
-            for (int level = 0; level < mipLevels; ++level)
-                texFuncs->glTextureImage1D(textureId, target, bindingTarget, level, format,
-                                           mipLevelSize(level, dimensions[0]),
-                                           0,
-                                           pixelFormat, pixelType, nullptr);
-        } else {
-            qWarning("1D textures are not supported");
-            return;
-        }
-        break;
-
-    case QOpenGLTexture::Target1DArray:
-        if (features.testFlag(QOpenGLTexture::Texture1D)
-                && features.testFlag(QOpenGLTexture::TextureArrays)) {
-            for (int level = 0; level < mipLevels; ++level)
-                texFuncs->glTextureImage2D(textureId, target, bindingTarget, level, format,
-                                           mipLevelSize(level, dimensions[0]),
-                                           layers,
-                                           0,
-                                           pixelFormat, pixelType, nullptr);
-        } else {
-            qWarning("1D array textures are not supported");
-            return;
-        }
-        break;
-
-    case QOpenGLTexture::Target2D:
-    case QOpenGLTexture::TargetRectangle:
-        for (int level = 0; level < mipLevels; ++level)
-            texFuncs->glTextureImage2D(textureId, target, bindingTarget, level, format,
-                                       mipLevelSize(level, dimensions[0]),
-                                       mipLevelSize(level, dimensions[1]),
-                                       0,
-                                       pixelFormat, pixelType, nullptr);
-        break;
-
-    case QOpenGLTexture::TargetCubeMap: {
-        // Cubemaps are the odd one out. We have to allocate storage for each
-        // face and miplevel using the special cubemap face targets rather than
-        // GL_TARGET_CUBEMAP.
-        const QOpenGLTexture::CubeMapFace faceTargets[] = {
-            QOpenGLTexture::CubeMapPositiveX, QOpenGLTexture::CubeMapNegativeX,
-            QOpenGLTexture::CubeMapPositiveY, QOpenGLTexture::CubeMapNegativeY,
-            QOpenGLTexture::CubeMapPositiveZ, QOpenGLTexture::CubeMapNegativeZ
-        };
-
-        for (int faceTarget = 0; faceTarget < 6; ++faceTarget) {
-            for (int level = 0; level < mipLevels; ++level) {
-                texFuncs->glTextureImage2D(textureId, faceTargets[faceTarget], bindingTarget,
-                                           level, format,
-                                           mipLevelSize(level, dimensions[0]),
-                                           mipLevelSize(level, dimensions[1]),
-                                           0,
-                                           pixelFormat, pixelType, nullptr);
-            }
-        }
-        break;
-    }
-
-    case QOpenGLTexture::Target2DArray:
-        if (features.testFlag(QOpenGLTexture::TextureArrays)) {
-            for (int level = 0; level < mipLevels; ++level)
-                texFuncs->glTextureImage3D(textureId, target, bindingTarget, level, format,
-                                           mipLevelSize(level, dimensions[0]),
-                                           mipLevelSize(level, dimensions[1]),
-                                           layers,
-                                           0,
-                                           pixelFormat, pixelType, nullptr);
-        } else {
-            qWarning("Array textures are not supported");
-            return;
-        }
-        break;
-
-    case QOpenGLTexture::TargetCubeMapArray:
-        // Cubemap arrays must specify number of layer-faces (6 * layers) as depth parameter
-        if (features.testFlag(QOpenGLTexture::TextureCubeMapArrays)) {
-            for (int level = 0; level < mipLevels; ++level)
-                texFuncs->glTextureImage3D(textureId, target, bindingTarget, level, format,
-                                           mipLevelSize(level, dimensions[0]),
-                                           mipLevelSize(level, dimensions[1]),
-                                           6 * layers,
-                                           0,
-                                           pixelFormat, pixelType, nullptr);
-        } else {
-            qWarning("Cubemap Array textures are not supported");
-            return;
-        }
-        break;
-
-    case QOpenGLTexture::Target3D:
-        if (features.testFlag(QOpenGLTexture::Texture3D)) {
-            for (int level = 0; level < mipLevels; ++level)
-                texFuncs->glTextureImage3D(textureId, target, bindingTarget, level, format,
-                                           mipLevelSize(level, dimensions[0]),
-                                           mipLevelSize(level, dimensions[1]),
-                                           mipLevelSize(level, dimensions[2]),
-                                           0,
-                                           pixelFormat, pixelType, nullptr);
-        } else {
-            qWarning("3D textures are not supported");
-            return;
-        }
-        break;
-
-    case QOpenGLTexture::Target2DMultisample:
-        if (features.testFlag(QOpenGLTexture::TextureMultisample)) {
-            texFuncs->glTextureImage2DMultisample(textureId, target, bindingTarget, samples, format,
-                                                  dimensions[0], dimensions[1],
-                                                  fixedSamplePositions);
-        } else {
-            qWarning("Multisample textures are not supported");
-            return;
-        }
-        break;
-
-    case QOpenGLTexture::Target2DMultisampleArray:
-        if (features.testFlag(QOpenGLTexture::TextureMultisample)
-                && features.testFlag(QOpenGLTexture::TextureArrays)) {
-            texFuncs->glTextureImage3DMultisample(textureId, target, bindingTarget, samples, format,
-                                                  dimensions[0], dimensions[1], layers,
-                                                  fixedSamplePositions);
-        } else {
-            qWarning("Multisample array textures are not supported");
-            return;
-        }
-        break;
-    }
-
-    storageAllocated = true;
-}
-
-void QOpenGLTexturePrivate::allocateImmutableStorage()
-{
-    switch (target) {
-    case QOpenGLTexture::TargetBuffer:
-        // Buffer textures get their storage from an external OpenGL buffer
-        qWarning("Buffer textures do not allocate storage");
-        return;
-
-    case QOpenGLTexture::Target1D:
-        if (features.testFlag(QOpenGLTexture::Texture1D)) {
-            texFuncs->glTextureStorage1D(textureId, target, bindingTarget, mipLevels, format,
-                                         dimensions[0]);
-        } else {
-            qWarning("1D textures are not supported");
-            return;
-        }
-        break;
-
-    case QOpenGLTexture::Target1DArray:
-        if (features.testFlag(QOpenGLTexture::Texture1D)
-                && features.testFlag(QOpenGLTexture::TextureArrays)) {
-            texFuncs->glTextureStorage2D(textureId, target, bindingTarget, mipLevels, format,
-                                         dimensions[0], layers);
-        } else {
-            qWarning("1D array textures are not supported");
-            return;
-        }
-        break;
-
-    case QOpenGLTexture::Target2D:
-    case QOpenGLTexture::TargetCubeMap:
-    case QOpenGLTexture::TargetRectangle:
-        texFuncs->glTextureStorage2D(textureId, target, bindingTarget, mipLevels, format,
-                                     dimensions[0], dimensions[1]);
-        break;
-
-    case QOpenGLTexture::Target2DArray:
-        if (features.testFlag(QOpenGLTexture::TextureArrays)) {
-            texFuncs->glTextureStorage3D(textureId, target, bindingTarget, mipLevels, format,
-                                         dimensions[0], dimensions[1], layers);
-        } else {
-            qWarning("Array textures are not supported");
-            return;
-        }
-        break;
-
-    case QOpenGLTexture::TargetCubeMapArray:
-        // Cubemap arrays must specify number of layer-faces (6 * layers) as depth parameter
-        if (features.testFlag(QOpenGLTexture::TextureCubeMapArrays)) {
-            texFuncs->glTextureStorage3D(textureId, target, bindingTarget, mipLevels, format,
-                                         dimensions[0], dimensions[1], 6 * layers);
-        } else {
-            qWarning("Cubemap Array textures are not supported");
-            return;
-        }
-        break;
-
-    case QOpenGLTexture::Target3D:
-        if (features.testFlag(QOpenGLTexture::Texture3D)) {
-            texFuncs->glTextureStorage3D(textureId, target, bindingTarget, mipLevels, format,
-                                         dimensions[0], dimensions[1], dimensions[2]);
-        } else {
-            qWarning("3D textures are not supported");
-            return;
-        }
-        break;
-
-    case QOpenGLTexture::Target2DMultisample:
-        if (features.testFlag(QOpenGLTexture::ImmutableMultisampleStorage)) {
-            texFuncs->glTextureStorage2DMultisample(textureId, target, bindingTarget, samples, format,
-                                                    dimensions[0], dimensions[1],
-                                                    fixedSamplePositions);
-        } else {
-            qWarning("Multisample textures are not supported");
-            return;
-        }
-        break;
-
-    case QOpenGLTexture::Target2DMultisampleArray:
-        if (features.testFlag(QOpenGLTexture::ImmutableMultisampleStorage)
-                && features.testFlag(QOpenGLTexture::TextureArrays)) {
-            texFuncs->glTextureStorage3DMultisample(textureId, target, bindingTarget, samples, format,
-                                                    dimensions[0], dimensions[1], layers,
-                                                    fixedSamplePositions);
-        } else {
-            qWarning("Multisample array textures are not supported");
-            return;
-        }
-        break;
-    }
-
-    storageAllocated = true;
-}
-
-void QOpenGLTexturePrivate::setData(int mipLevel, int layer, int layerCount, QOpenGLTexture::CubeMapFace cubeFace,
-                                    QOpenGLTexture::PixelFormat sourceFormat, QOpenGLTexture::PixelType sourceType,
-                                    const void *data, const QOpenGLPixelTransferOptions * const options)
-{
-    switch (target) {
-    case QOpenGLTexture::Target1D:
-        Q_UNUSED(layer);
-        Q_UNUSED(cubeFace);
-        Q_UNUSED(layerCount);
-        texFuncs->glTextureSubImage1D(textureId, target, bindingTarget, mipLevel,
-                                      0, mipLevelSize( mipLevel, dimensions[0] ),
-                                      sourceFormat, sourceType, data, options);
-        break;
-
-    case QOpenGLTexture::Target1DArray:
-        Q_UNUSED(cubeFace);
-        texFuncs->glTextureSubImage2D(textureId, target, bindingTarget, mipLevel,
-                                      0, layer,
-                                      mipLevelSize(mipLevel, dimensions[0]),
-                                      layerCount,
-                                      sourceFormat, sourceType, data, options);
-        break;
-
-    case QOpenGLTexture::Target2D:
-        Q_UNUSED(layer);
-        Q_UNUSED(cubeFace);
-        Q_UNUSED(layerCount);
-        texFuncs->glTextureSubImage2D(textureId, target, bindingTarget, mipLevel,
-                                      0, 0,
-                                      mipLevelSize(mipLevel, dimensions[0]),
-                                      mipLevelSize(mipLevel, dimensions[1]),
-                                      sourceFormat, sourceType, data, options);
-        break;
-
-    case QOpenGLTexture::Target2DArray:
-        Q_UNUSED(cubeFace);
-        texFuncs->glTextureSubImage3D(textureId, target, bindingTarget, mipLevel,
-                                      0, 0, layer,
-                                      mipLevelSize(mipLevel, dimensions[0]),
-                                      mipLevelSize(mipLevel, dimensions[1]),
-                                      layerCount,
-                                      sourceFormat, sourceType, data, options);
-        break;
-
-    case QOpenGLTexture::Target3D:
-        Q_UNUSED(cubeFace);
-        Q_UNUSED(layerCount);
-        texFuncs->glTextureSubImage3D(textureId, target, bindingTarget, mipLevel,
-                                      0, 0, layer,
-                                      mipLevelSize(mipLevel, dimensions[0]),
-                                      mipLevelSize(mipLevel, dimensions[1]),
-                                      mipLevelSize(mipLevel, dimensions[2]),
-                                      sourceFormat, sourceType, data, options);
-        break;
-
-    case QOpenGLTexture::TargetCubeMap:
-        Q_UNUSED(layer);
-        Q_UNUSED(layerCount);
-        texFuncs->glTextureSubImage2D(textureId, cubeFace, bindingTarget, mipLevel,
-                                      0, 0,
-                                      mipLevelSize(mipLevel, dimensions[0]),
-                                      mipLevelSize(mipLevel, dimensions[1]),
-                                      sourceFormat, sourceType, data, options);
-        break;
-
-    case QOpenGLTexture::TargetCubeMapArray: {
-        int faceIndex = cubeFace - QOpenGLTexture::CubeMapPositiveX;
-        int layerFace = 6 * layer + faceIndex;
-        texFuncs->glTextureSubImage3D(textureId, target, bindingTarget, mipLevel,
-                                      0, 0, layerFace,
-                                      mipLevelSize(mipLevel, dimensions[0]),
-                                      mipLevelSize(mipLevel, dimensions[1]),
-                                      layerCount,
-                                      sourceFormat, sourceType, data, options);
-        break;
-    }
-
-    case QOpenGLTexture::TargetRectangle:
-        Q_UNUSED(mipLevel);
-        Q_UNUSED(layer);
-        Q_UNUSED(cubeFace);
-        Q_UNUSED(layerCount);
-        texFuncs->glTextureSubImage2D(textureId, target, bindingTarget, 0,
-                                      0, 0,
-                                      dimensions[0],
-                                      dimensions[1],
-                                      sourceFormat, sourceType, data, options);
-        break;
-
-    case QOpenGLTexture::Target2DMultisample:
-    case QOpenGLTexture::Target2DMultisampleArray:
-    case QOpenGLTexture::TargetBuffer:
-        // We don't upload pixel data for these targets
-        qWarning("QOpenGLTexture::setData(): Texture target does not support pixel data upload");
-        break;
-    }
-
-    // If requested perform automatic mip map generation
-    if (mipLevel == 0 && autoGenerateMipMaps && mipLevels > 1) {
-        Q_Q(QOpenGLTexture);
-        q->generateMipMaps();
-    }
-}
-
-void QOpenGLTexturePrivate::setData(int xOffset, int yOffset, int zOffset, int width, int height, int depth,
-                                    int mipLevel, int layer, int layerCount, QOpenGLTexture::CubeMapFace cubeFace,
-                                    QOpenGLTexture::PixelFormat sourceFormat, QOpenGLTexture::PixelType sourceType,
-                                    const void *data, const QOpenGLPixelTransferOptions * const options)
-{
-    switch (target) {
-    case QOpenGLTexture::Target1D:
-        Q_UNUSED(layer);
-        Q_UNUSED(cubeFace);
-        Q_UNUSED(layerCount);
-        Q_UNUSED(yOffset);
-        Q_UNUSED(zOffset);
-        Q_UNUSED(height);
-        Q_UNUSED(depth);
-        texFuncs->glTextureSubImage1D(textureId, target, bindingTarget, mipLevel,
-                                      xOffset, width,
-                                      sourceFormat, sourceType, data, options);
-        break;
-
-    case QOpenGLTexture::Target1DArray:
-        Q_UNUSED(cubeFace);
-        Q_UNUSED(yOffset);
-        Q_UNUSED(zOffset);
-        Q_UNUSED(height);
-        Q_UNUSED(depth);
-        texFuncs->glTextureSubImage2D(textureId, target, bindingTarget, mipLevel,
-                                      xOffset, layer,
-                                      width,
-                                      layerCount,
-                                      sourceFormat, sourceType, data, options);
-        break;
-
-    case QOpenGLTexture::Target2D:
-        Q_UNUSED(layer);
-        Q_UNUSED(cubeFace);
-        Q_UNUSED(layerCount);
-        Q_UNUSED(zOffset);
-        Q_UNUSED(depth);
-        texFuncs->glTextureSubImage2D(textureId, target, bindingTarget, mipLevel,
-                                      xOffset, yOffset,
-                                      width, height,
-                                      sourceFormat, sourceType, data, options);
-        break;
-
-    case QOpenGLTexture::Target2DArray:
-        Q_UNUSED(cubeFace);
-        Q_UNUSED(zOffset);
-        Q_UNUSED(depth);
-        texFuncs->glTextureSubImage3D(textureId, target, bindingTarget, mipLevel,
-                                      xOffset, yOffset, layer,
-                                      width, height, layerCount,
-                                      sourceFormat, sourceType, data, options);
-        break;
-
-    case QOpenGLTexture::Target3D:
-        Q_UNUSED(cubeFace);
-        Q_UNUSED(layerCount);
-        texFuncs->glTextureSubImage3D(textureId, target, bindingTarget, mipLevel,
-                                      xOffset, yOffset, zOffset,
-                                      width, height, depth,
-                                      sourceFormat, sourceType, data, options);
-        break;
-
-    case QOpenGLTexture::TargetCubeMap:
-        Q_UNUSED(layer);
-        Q_UNUSED(layerCount);
-        Q_UNUSED(zOffset);
-        Q_UNUSED(depth);
-        texFuncs->glTextureSubImage2D(textureId, cubeFace, bindingTarget, mipLevel,
-                                      xOffset, yOffset,
-                                      width, height,
-                                      sourceFormat, sourceType, data, options);
-        break;
-
-    case QOpenGLTexture::TargetCubeMapArray: {
-        Q_UNUSED(zOffset);
-        Q_UNUSED(depth);
-        int faceIndex = cubeFace - QOpenGLTexture::CubeMapPositiveX;
-        int layerFace = 6 * layer + faceIndex;
-        texFuncs->glTextureSubImage3D(textureId, target, bindingTarget, mipLevel,
-                                      xOffset, yOffset, layerFace,
-                                      width, height,
-                                      layerCount,
-                                      sourceFormat, sourceType, data, options);
-        break;
-    }
-
-    case QOpenGLTexture::TargetRectangle:
-        Q_UNUSED(mipLevel);
-        Q_UNUSED(layer);
-        Q_UNUSED(cubeFace);
-        Q_UNUSED(layerCount);
-        Q_UNUSED(zOffset);
-        Q_UNUSED(depth);
-        texFuncs->glTextureSubImage2D(textureId, target, bindingTarget, 0,
-                                      xOffset, yOffset,
-                                      width, height,
-                                      sourceFormat, sourceType, data, options);
-        break;
-
-    case QOpenGLTexture::Target2DMultisample:
-    case QOpenGLTexture::Target2DMultisampleArray:
-    case QOpenGLTexture::TargetBuffer:
-        // We don't upload pixel data for these targets
-        qWarning("QOpenGLTexture::setData(): Texture target does not support pixel data upload");
-        break;
-    }
-
-    // If requested perform automatic mip map generation
-    if (mipLevel == 0 && autoGenerateMipMaps && mipLevels > 1) {
-        Q_Q(QOpenGLTexture);
-        q->generateMipMaps();
-    }
-}
-
-
-void QOpenGLTexturePrivate::setCompressedData(int mipLevel, int layer, int layerCount,
-                                              QOpenGLTexture::CubeMapFace cubeFace,
-                                              int dataSize, const void *data,
-                                              const QOpenGLPixelTransferOptions * const options)
-{
-    if (!isCompressedFormat(format)) {
-        qWarning("Cannot set compressed data for non-compressed format 0x%x", format);
-        return;
-    }
-
-    const bool needsFullSpec = !isUsingImmutableStorage(); // was allocateStorage() a no-op?
-
-    switch (target) {
-    case QOpenGLTexture::Target1D:
-        Q_UNUSED(layer);
-        Q_UNUSED(cubeFace);
-        Q_UNUSED(layerCount);
-        if (needsFullSpec) {
-            texFuncs->glCompressedTextureImage1D(textureId, target, bindingTarget, mipLevel,
-                                                 format,
-                                                 mipLevelSize(mipLevel, dimensions[0]),
-                                                 0, dataSize, data, options);
-        } else {
-            texFuncs->glCompressedTextureSubImage1D(textureId, target, bindingTarget, mipLevel,
-                                                    0, mipLevelSize( mipLevel, dimensions[0] ),
-                                                    format, dataSize, data, options);
-        }
-        break;
-
-    case QOpenGLTexture::Target1DArray:
-        Q_UNUSED(cubeFace);
-        if (!needsFullSpec) {
-            texFuncs->glCompressedTextureSubImage2D(textureId, target, bindingTarget, mipLevel,
-                                                    0, layer,
-                                                    mipLevelSize(mipLevel, dimensions[0]),
-                                                    layerCount,
-                                                    format, dataSize, data, options);
-        }
-        break;
-
-    case QOpenGLTexture::Target2D:
-        Q_UNUSED(layer);
-        Q_UNUSED(cubeFace);
-        Q_UNUSED(layerCount);
-        if (needsFullSpec) {
-            texFuncs->glCompressedTextureImage2D(textureId, target, bindingTarget, mipLevel,
-                                                 format,
-                                                 mipLevelSize(mipLevel, dimensions[0]),
-                                                 mipLevelSize(mipLevel, dimensions[1]),
-                                                 0, dataSize, data, options);
-        } else {
-            texFuncs->glCompressedTextureSubImage2D(textureId, target, bindingTarget, mipLevel,
-                                                    0, 0,
-                                                    mipLevelSize(mipLevel, dimensions[0]),
-                                                    mipLevelSize(mipLevel, dimensions[1]),
-                                                    format, dataSize, data, options);
-        }
-        break;
-
-    case QOpenGLTexture::Target2DArray:
-        Q_UNUSED(cubeFace);
-        if (!needsFullSpec) {
-            texFuncs->glCompressedTextureSubImage3D(textureId, target, bindingTarget, mipLevel,
-                                                    0, 0, layer,
-                                                    mipLevelSize(mipLevel, dimensions[0]),
-                                                    mipLevelSize(mipLevel, dimensions[1]),
-                                                    layerCount,
-                                                    format, dataSize, data, options);
-        }
-        break;
-
-    case QOpenGLTexture::Target3D:
-        Q_UNUSED(cubeFace);
-        Q_UNUSED(layerCount);
-        if (needsFullSpec) {
-            texFuncs->glCompressedTextureImage3D(textureId, target, bindingTarget, mipLevel,
-                                                 format,
-                                                 mipLevelSize(mipLevel, dimensions[0]),
-                                                 mipLevelSize(mipLevel, dimensions[1]),
-                                                 mipLevelSize(mipLevel, dimensions[2]),
-                                                 0, dataSize, data, options);
-        } else {
-            texFuncs->glCompressedTextureSubImage3D(textureId, target, bindingTarget, mipLevel,
-                                                    0, 0, layer,
-                                                    mipLevelSize(mipLevel, dimensions[0]),
-                                                    mipLevelSize(mipLevel, dimensions[1]),
-                                                    mipLevelSize(mipLevel, dimensions[2]),
-                                                    format, dataSize, data, options);
-        }
-        break;
-
-    case QOpenGLTexture::TargetCubeMap:
-        Q_UNUSED(layer);
-        Q_UNUSED(layerCount);
-        if (needsFullSpec) {
-            texFuncs->glCompressedTextureImage2D(textureId, cubeFace, bindingTarget, mipLevel,
-                                                 format,
-                                                 mipLevelSize(mipLevel, dimensions[0]),
-                                                 mipLevelSize(mipLevel, dimensions[1]),
-                                                 0, dataSize, data, options);
-        } else {
-            texFuncs->glCompressedTextureSubImage2D(textureId, cubeFace, bindingTarget, mipLevel,
-                                                    0, 0,
-                                                    mipLevelSize(mipLevel, dimensions[0]),
-                                                    mipLevelSize(mipLevel, dimensions[1]),
-                                                    format, dataSize, data, options);
-        }
-        break;
-
-    case QOpenGLTexture::TargetCubeMapArray: {
-        int faceIndex = cubeFace - QOpenGLTexture::CubeMapPositiveX;
-        int layerFace = 6 * layer + faceIndex;
-        if (!needsFullSpec) {
-            texFuncs->glCompressedTextureSubImage3D(textureId, target, bindingTarget, mipLevel,
-                                                    0, 0, layerFace,
-                                                    mipLevelSize(mipLevel, dimensions[0]),
-                                                    mipLevelSize(mipLevel, dimensions[1]),
-                                                    layerCount,
-                                                    format, dataSize, data, options);
-        }
-        break;
-    }
-
-    case QOpenGLTexture::TargetRectangle:
-    case QOpenGLTexture::Target2DMultisample:
-    case QOpenGLTexture::Target2DMultisampleArray:
-    case QOpenGLTexture::TargetBuffer:
-        // We don't upload pixel data for these targets
-        qWarning("QOpenGLTexture::setCompressedData(): Texture target does not support pixel data upload");
-        break;
-    }
-
-    // If requested perform automatic mip map generation
-    if (mipLevel == 0 && autoGenerateMipMaps && mipLevels > 1) {
-        Q_Q(QOpenGLTexture);
-        q->generateMipMaps();
-    }
-}
-
-void QOpenGLTexturePrivate::setWrapMode(QOpenGLTexture::WrapMode mode)
-{
-    switch (target) {
-    case QOpenGLTexture::Target1D:
-    case QOpenGLTexture::Target1DArray:
-    case QOpenGLTexture::TargetBuffer:
-        wrapModes[0] = mode;
-        texFuncs->glTextureParameteri(textureId, target, bindingTarget, GL_TEXTURE_WRAP_S, mode);
-        break;
-
-    case QOpenGLTexture::Target2D:
-    case QOpenGLTexture::Target2DArray:
-    case QOpenGLTexture::TargetCubeMap:
-    case QOpenGLTexture::TargetCubeMapArray:
-    case QOpenGLTexture::Target2DMultisample:
-    case QOpenGLTexture::Target2DMultisampleArray:
-    case QOpenGLTexture::TargetRectangle:
-        wrapModes[0] = wrapModes[1] = mode;
-        texFuncs->glTextureParameteri(textureId, target, bindingTarget, GL_TEXTURE_WRAP_S, mode);
-        texFuncs->glTextureParameteri(textureId, target, bindingTarget, GL_TEXTURE_WRAP_T, mode);
-        break;
-
-    case QOpenGLTexture::Target3D:
-        wrapModes[0] = wrapModes[1] = wrapModes[2] = mode;
-        texFuncs->glTextureParameteri(textureId, target, bindingTarget, GL_TEXTURE_WRAP_S, mode);
-        texFuncs->glTextureParameteri(textureId, target, bindingTarget, GL_TEXTURE_WRAP_T, mode);
-        texFuncs->glTextureParameteri(textureId, target, bindingTarget, GL_TEXTURE_WRAP_R, mode);
-        break;
-    }
-}
-
-void QOpenGLTexturePrivate::setWrapMode(QOpenGLTexture::CoordinateDirection direction, QOpenGLTexture::WrapMode mode)
-{
-    switch (target) {
-    case QOpenGLTexture::Target1D:
-    case QOpenGLTexture::Target1DArray:
-    case QOpenGLTexture::TargetBuffer:
-        switch (direction) {
-        case QOpenGLTexture::DirectionS:
-            wrapModes[0] = mode;
-            texFuncs->glTextureParameteri(textureId, target, bindingTarget, GL_TEXTURE_WRAP_S, mode);
-            break;
-
-        case QOpenGLTexture::DirectionT:
-        case QOpenGLTexture::DirectionR:
-            qWarning("QOpenGLTexture::setWrapMode() direction not valid for this texture target");
-            break;
-        }
-        break;
-
-    case QOpenGLTexture::Target2D:
-    case QOpenGLTexture::Target2DArray:
-    case QOpenGLTexture::TargetCubeMap:
-    case QOpenGLTexture::TargetCubeMapArray:
-    case QOpenGLTexture::Target2DMultisample:
-    case QOpenGLTexture::Target2DMultisampleArray:
-    case QOpenGLTexture::TargetRectangle:
-        switch (direction) {
-        case QOpenGLTexture::DirectionS:
-            wrapModes[0] = mode;
-            texFuncs->glTextureParameteri(textureId, target, bindingTarget, GL_TEXTURE_WRAP_S, mode);
-            break;
-
-        case QOpenGLTexture::DirectionT:
-            wrapModes[1] = mode;
-            texFuncs->glTextureParameteri(textureId, target, bindingTarget, GL_TEXTURE_WRAP_T, mode);
-            break;
-
-        case QOpenGLTexture::DirectionR:
-            qWarning("QOpenGLTexture::setWrapMode() direction not valid for this texture target");
-            break;
-        }
-        break;
-
-    case QOpenGLTexture::Target3D:
-        switch (direction) {
-        case QOpenGLTexture::DirectionS:
-            wrapModes[0] = mode;
-            texFuncs->glTextureParameteri(textureId, target, bindingTarget, direction, mode);
-            break;
-
-        case QOpenGLTexture::DirectionT:
-            wrapModes[1] = mode;
-            texFuncs->glTextureParameteri(textureId, target, bindingTarget, direction, mode);
-            break;
-
-        case QOpenGLTexture::DirectionR:
-            wrapModes[2] = mode;
-            texFuncs->glTextureParameteri(textureId, target, bindingTarget, direction, mode);
-            break;
-        }
-        break;
-    }
-}
-
-QOpenGLTexture::WrapMode QOpenGLTexturePrivate::wrapMode(QOpenGLTexture::CoordinateDirection direction) const
-{
-    switch (target) {
-    case QOpenGLTexture::Target1D:
-    case QOpenGLTexture::Target1DArray:
-    case QOpenGLTexture::TargetBuffer:
-        switch (direction) {
-        case QOpenGLTexture::DirectionS:
-            return wrapModes[0];
-
-        case QOpenGLTexture::DirectionT:
-        case QOpenGLTexture::DirectionR:
-            qWarning("QOpenGLTexture::wrapMode() direction not valid for this texture target");
-            return QOpenGLTexture::Repeat;
-        }
-        break;
-
-    case QOpenGLTexture::Target2D:
-    case QOpenGLTexture::Target2DArray:
-    case QOpenGLTexture::TargetCubeMap:
-    case QOpenGLTexture::TargetCubeMapArray:
-    case QOpenGLTexture::Target2DMultisample:
-    case QOpenGLTexture::Target2DMultisampleArray:
-    case QOpenGLTexture::TargetRectangle:
-        switch (direction) {
-        case QOpenGLTexture::DirectionS:
-            return wrapModes[0];
-
-        case QOpenGLTexture::DirectionT:
-            return wrapModes[1];
-
-        case QOpenGLTexture::DirectionR:
-            qWarning("QOpenGLTexture::wrapMode() direction not valid for this texture target");
-            return QOpenGLTexture::Repeat;
-        }
-        break;
-
-    case QOpenGLTexture::Target3D:
-        switch (direction) {
-        case QOpenGLTexture::DirectionS:
-            return wrapModes[0];
-
-        case QOpenGLTexture::DirectionT:
-            return wrapModes[1];
-
-        case QOpenGLTexture::DirectionR:
-            return wrapModes[2];
-        }
-        break;
-    }
-    // Should never get here
-    Q_ASSERT(false);
-    return QOpenGLTexture::Repeat;
-}
-
-QOpenGLTexture *QOpenGLTexturePrivate::createTextureView(QOpenGLTexture::Target viewTarget,
-                                                         QOpenGLTexture::TextureFormat viewFormat,
-                                                         int minimumMipmapLevel, int maximumMipmapLevel,
-                                                         int minimumLayer, int maximumLayer) const
-{
-    // Do sanity checks - see http://www.opengl.org/wiki/GLAPI/glTextureView
-
-    // Check the targets are compatible
-    bool viewTargetCompatible = false;
-    switch (target) {
-    case QOpenGLTexture::Target1D:
-    case QOpenGLTexture::Target1DArray:
-        viewTargetCompatible = (viewTarget == QOpenGLTexture::Target1D
-                             || viewTarget == QOpenGLTexture::Target1DArray);
-        break;
-
-
-    case QOpenGLTexture::Target2D:
-    case QOpenGLTexture::Target2DArray:
-        viewTargetCompatible = (viewTarget == QOpenGLTexture::Target2D
-                             || viewTarget == QOpenGLTexture::Target2DArray);
-        break;
-
-    case QOpenGLTexture::Target3D:
-        viewTargetCompatible = (viewTarget == QOpenGLTexture::Target3D);
-        break;
-
-    case QOpenGLTexture::TargetCubeMap:
-    case QOpenGLTexture::TargetCubeMapArray:
-        viewTargetCompatible = (viewTarget == QOpenGLTexture::TargetCubeMap
-                             || viewTarget == QOpenGLTexture::Target2D
-                             || viewTarget == QOpenGLTexture::Target2DArray
-                             || viewTarget == QOpenGLTexture::TargetCubeMapArray);
-        break;
-
-    case QOpenGLTexture::Target2DMultisample:
-    case QOpenGLTexture::Target2DMultisampleArray:
-        viewTargetCompatible = (viewTarget == QOpenGLTexture::Target2DMultisample
-                             || viewTarget == QOpenGLTexture::Target2DMultisampleArray);
-        break;
-
-    case QOpenGLTexture::TargetRectangle:
-        viewTargetCompatible = (viewTarget == QOpenGLTexture::TargetRectangle);
-        break;
-
-    case QOpenGLTexture::TargetBuffer:
-        // Cannot be used with texture views
-        break;
-    }
-
-    if (!viewTargetCompatible) {
-        qWarning("QOpenGLTexture::createTextureView(): Incompatible source and view targets");
-        return nullptr;
-    }
-
-    // Check the formats are compatible
-    bool viewFormatCompatible = false;
-    switch (formatClass) {
-    case QOpenGLTexture::NoFormatClass:
-        break;
-
-    case QOpenGLTexture::FormatClass_128Bit:
-        viewFormatCompatible = (viewFormat == QOpenGLTexture::RGBA32F
-                             || viewFormat == QOpenGLTexture::RGBA32U
-                             || viewFormat == QOpenGLTexture::RGBA32I);
-        break;
-
-    case QOpenGLTexture::FormatClass_96Bit:
-        viewFormatCompatible = (viewFormat == QOpenGLTexture::RGB32F
-                             || viewFormat == QOpenGLTexture::RGB32U
-                             || viewFormat == QOpenGLTexture::RGB32I);
-        break;
-
-    case QOpenGLTexture::FormatClass_64Bit:
-        viewFormatCompatible = (viewFormat == QOpenGLTexture::RGBA16F
-                             || viewFormat == QOpenGLTexture::RG32F
-                             || viewFormat == QOpenGLTexture::RGBA16U
-                             || viewFormat == QOpenGLTexture::RG32U
-                             || viewFormat == QOpenGLTexture::RGBA16I
-                             || viewFormat == QOpenGLTexture::RG32I
-                             || viewFormat == QOpenGLTexture::RGBA16_UNorm
-                             || viewFormat == QOpenGLTexture::RGBA16_SNorm);
-        break;
-
-    case QOpenGLTexture::FormatClass_48Bit:
-        viewFormatCompatible = (viewFormat == QOpenGLTexture::RGB16_UNorm
-                             || viewFormat == QOpenGLTexture::RGB16_SNorm
-                             || viewFormat == QOpenGLTexture::RGB16F
-                             || viewFormat == QOpenGLTexture::RGB16U
-                             || viewFormat == QOpenGLTexture::RGB16I);
-        break;
-
-    case QOpenGLTexture::FormatClass_32Bit:
-        viewFormatCompatible = (viewFormat == QOpenGLTexture::RG16F
-                             || viewFormat == QOpenGLTexture::RG11B10F
-                             || viewFormat == QOpenGLTexture::R32F
-                             || viewFormat == QOpenGLTexture::RGB10A2
-                             || viewFormat == QOpenGLTexture::RGBA8U
-                             || viewFormat == QOpenGLTexture::RG16U
-                             || viewFormat == QOpenGLTexture::R32U
-                             || viewFormat == QOpenGLTexture::RGBA8I
-                             || viewFormat == QOpenGLTexture::RG16I
-                             || viewFormat == QOpenGLTexture::R32I
-                             || viewFormat == QOpenGLTexture::RGBA8_UNorm
-                             || viewFormat == QOpenGLTexture::RG16_UNorm
-                             || viewFormat == QOpenGLTexture::RGBA8_SNorm
-                             || viewFormat == QOpenGLTexture::RG16_SNorm
-                             || viewFormat == QOpenGLTexture::SRGB8_Alpha8
-                             || viewFormat == QOpenGLTexture::RGB9E5);
-        break;
-
-    case QOpenGLTexture::FormatClass_24Bit:
-        viewFormatCompatible = (viewFormat == QOpenGLTexture::RGB8_UNorm
-                             || viewFormat == QOpenGLTexture::RGB8_SNorm
-                             || viewFormat == QOpenGLTexture::SRGB8
-                             || viewFormat == QOpenGLTexture::RGB8U
-                             || viewFormat == QOpenGLTexture::RGB8I);
-        break;
-
-    case QOpenGLTexture::FormatClass_16Bit:
-        viewFormatCompatible = (viewFormat == QOpenGLTexture::R16F
-                             || viewFormat == QOpenGLTexture::RG8U
-                             || viewFormat == QOpenGLTexture::R16U
-                             || viewFormat == QOpenGLTexture::RG8I
-                             || viewFormat == QOpenGLTexture::R16I
-                             || viewFormat == QOpenGLTexture::RG8_UNorm
-                             || viewFormat == QOpenGLTexture::R16_UNorm
-                             || viewFormat == QOpenGLTexture::RG8_SNorm
-                             || viewFormat == QOpenGLTexture::R16_SNorm);
-        break;
-
-    case QOpenGLTexture::FormatClass_8Bit:
-        viewFormatCompatible = (viewFormat == QOpenGLTexture::R8U
-                             || viewFormat == QOpenGLTexture::R8I
-                             || viewFormat == QOpenGLTexture::R8_UNorm
-                             || viewFormat == QOpenGLTexture::R8_SNorm);
-        break;
-
-    case QOpenGLTexture::FormatClass_RGTC1_R:
-        viewFormatCompatible = (viewFormat == QOpenGLTexture::R_ATI1N_UNorm
-                             || viewFormat == QOpenGLTexture::R_ATI1N_SNorm);
-        break;
-
-    case QOpenGLTexture::FormatClass_RGTC2_RG:
-        viewFormatCompatible = (viewFormat == QOpenGLTexture::RG_ATI2N_UNorm
-                             || viewFormat == QOpenGLTexture::RG_ATI2N_SNorm);
-        break;
-
-    case QOpenGLTexture::FormatClass_BPTC_Unorm:
-        viewFormatCompatible = (viewFormat == QOpenGLTexture::RGB_BP_UNorm
-                             || viewFormat == QOpenGLTexture::SRGB_BP_UNorm);
-        break;
-
-    case QOpenGLTexture::FormatClass_BPTC_Float:
-        viewFormatCompatible = (viewFormat == QOpenGLTexture::RGB_BP_UNSIGNED_FLOAT
-                             || viewFormat == QOpenGLTexture::RGB_BP_SIGNED_FLOAT);
-        break;
-
-    case QOpenGLTexture::FormatClass_S3TC_DXT1_RGB:
-        viewFormatCompatible = (viewFormat == QOpenGLTexture::RGB_DXT1
-                             || viewFormat == QOpenGLTexture::SRGB_DXT1);
-        break;
-
-    case QOpenGLTexture::FormatClass_S3TC_DXT1_RGBA:
-        viewFormatCompatible = (viewFormat == QOpenGLTexture::RGBA_DXT1
-                             || viewFormat == QOpenGLTexture::SRGB_Alpha_DXT1);
-        break;
-
-    case QOpenGLTexture::FormatClass_S3TC_DXT3_RGBA:
-        viewFormatCompatible = (viewFormat == QOpenGLTexture::RGBA_DXT3
-                             || viewFormat == QOpenGLTexture::SRGB_Alpha_DXT3);
-        break;
-
-    case QOpenGLTexture::FormatClass_S3TC_DXT5_RGBA:
-        viewFormatCompatible = (viewFormat == QOpenGLTexture::RGBA_DXT5
-                             || viewFormat == QOpenGLTexture::SRGB_Alpha_DXT5);
-        break;
-
-    case QOpenGLTexture::FormatClass_Unique:
-        viewFormatCompatible = (viewFormat == format);
-        break;
-    }
-
-    if (!viewFormatCompatible) {
-        qWarning("QOpenGLTexture::createTextureView(): Incompatible source and view formats");
-        return nullptr;
-    }
-
-
-    // Create a view
-    QOpenGLTexture *view = new QOpenGLTexture(viewTarget);
-    view->setFormat(viewFormat);
-    view->create();
-    view->d_ptr->textureView = true;
-    texFuncs->glTextureView(view->textureId(), viewTarget, textureId, viewFormat,
-                            minimumMipmapLevel, maximumMipmapLevel - minimumMipmapLevel + 1,
-                            minimumLayer, maximumLayer - minimumLayer + 1);
-    return view;
-}
-
-
-/*!
-    \class QOpenGLTexture
-    \inmodule QtGui
-    \since 5.2
-    \wrapper
-    \brief The QOpenGLTexture class encapsulates an OpenGL texture object.
-
-    QOpenGLTexture makes it easy to work with OpenGL textures and the myriad features
-    and targets that they offer depending upon the capabilities of your OpenGL implementation.
-
-    The typical usage pattern for QOpenGLTexture is
-    \list
-        \li Instantiate the object specifying the texture target type
-        \li Set properties that affect the storage requirements e.g. storage format, dimensions
-        \li Allocate the server-side storage
-        \li Optionally upload pixel data
-        \li Optionally set any additional properties e.g. filtering and border options
-        \li Render with texture or render to texture
-    \endlist
-
-    In the common case of simply using a QImage as the source of texture pixel data
-    most of the above steps are performed automatically.
-
-    \code
-    // Prepare texture
-    QOpenGLTexture *texture = new QOpenGLTexture(QImage(fileName).mirrored());
-    texture->setMinificationFilter(QOpenGLTexture::LinearMipMapLinear);
-    texture->setMagnificationFilter(QOpenGLTexture::Linear);
-    ...
-    // Render with texture
-    texture->bind();
-    glDrawArrays(...);
-    \endcode
-
-    Note that the QImage is mirrored vertically to account for the fact that
-    OpenGL and QImage use opposite directions for the y axis. Another option
-    would be to transform your texture coordinates.
-*/
-
-/*!
-    \enum QOpenGLTexture::Filter
-    This enum defines the filtering parameters for a QOpenGLTexture object.
-    \value Nearest Equivalent to GL_NEAREST
-    \value Linear Equivalent to GL_LINEAR
-    \value NearestMipMapNearest Equivalent to GL_NEAREST_MIPMAP_NEAREST
-    \value NearestMipMapLinear Equivalent to GL_NEAREST_MIPMAP_LINEAR
-    \value LinearMipMapNearest Equivalent to GL_LINEAR_MIPMAP_NEAREST
-    \value LinearMipMapLinear Equivalent to GL_LINEAR_MIPMAP_LINEAR
-*/
-
-/*!
-    \enum QOpenGLTexture::Target
-    This enum defines the texture target of a QOpenGLTexture object.
-
-    \value Target1D A 1-dimensional texture.
-           Equivalent to GL_TEXTURE_1D.
-    \value Target1DArray An array of 1-dimensional textures.
-           Equivalent to GL_TEXTURE_1D_ARRAY
-    \value Target2D A 2-dimensional texture.
-           Equivalent to GL_TEXTURE_2D
-    \value Target2DArray An array of 1-dimensional textures.
-           Equivalent to GL_TEXTURE_2D_ARRAY
-    \value Target3D A 3-dimensional texture.
-           Equivalent to GL_TEXTURE_3D
-    \value TargetCubeMap A cubemap texture.
-           Equivalent to GL_TEXTURE_CUBE_MAP
-    \value TargetCubeMapArray An array of cubemap textures.
-           Equivalent to GL_TEXTURE_CUBE_MAP_ARRAY
-    \value Target2DMultisample A 2-dimensional texture with multisample support.
-           Equivalent to GL_TEXTURE_2D_MULTISAMPLE
-    \value Target2DMultisampleArray An array of 2-dimensional textures with multisample support.
-           Equivalent to GL_TEXTURE_2D_MULTISAMPLE_ARRAY
-    \value TargetRectangle A rectangular 2-dimensional texture.
-           Equivalent to GL_TEXTURE_RECTANGLE
-    \value TargetBuffer A texture with data from an OpenGL buffer object.
-           Equivalent to GL_TEXTURE_BUFFER
-*/
-
-/*!
-    \enum QOpenGLTexture::BindingTarget
-    This enum defines the possible binding targets of texture units.
-
-    \value BindingTarget1D Equivalent to GL_TEXTURE_BINDING_1D
-    \value BindingTarget1DArray Equivalent to GL_TEXTURE_BINDING_1D_ARRAY
-    \value BindingTarget2D Equivalent to GL_TEXTURE_BINDING_2D
-    \value BindingTarget2DArray Equivalent to GL_TEXTURE_BINDING_2D_ARRAY
-    \value BindingTarget3D Equivalent to GL_TEXTURE_BINDING_3D
-    \value BindingTargetCubeMap Equivalent to GL_TEXTURE_BINDING_CUBE_MAP
-    \value BindingTargetCubeMapArray Equivalent to GL_TEXTURE_BINDING_CUBE_MAP_ARRAY
-    \value BindingTarget2DMultisample Equivalent to GL_TEXTURE_BINDING_2D_MULTISAMPLE
-    \value BindingTarget2DMultisampleArray Equivalent to GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY
-    \value BindingTargetRectangle Equivalent to GL_TEXTURE_BINDING_RECTANGLE
-    \value BindingTargetBuffer Equivalent to GL_TEXTURE_BINDING_BUFFER
-*/
-
-/*!
-    \enum QOpenGLTexture::MipMapGeneration
-    This enum defines the options to control mipmap generation.
-
-    \value GenerateMipMaps Mipmaps should be generated
-    \value DontGenerateMipMaps Mipmaps should not be generated
-*/
-
-/*!
-    \enum QOpenGLTexture::TextureUnitReset
-    This enum defines options ot control texture unit activation.
-
-    \value ResetTextureUnit The previous active texture unit will be reset
-    \value DontResetTextureUnit The previous active texture unit will not be rest
-*/
-
-/*!
-    \enum QOpenGLTexture::TextureFormat
-    This enum defines the possible texture formats. Depending upon your OpenGL
-    implementation only a subset of these may be supported.
-
-    \value NoFormat Equivalent to GL_NONE
-
-    \value R8_UNorm Equivalent to GL_R8
-    \value RG8_UNorm Equivalent to GL_RG8
-    \value RGB8_UNorm Equivalent to GL_RGB8
-    \value RGBA8_UNorm Equivalent to GL_RGBA8
-
-    \value R16_UNorm Equivalent to GL_R16
-    \value RG16_UNorm Equivalent to GL_RG16
-    \value RGB16_UNorm Equivalent to GL_RGB16
-    \value RGBA16_UNorm Equivalent to GL_RGBA16
-
-    \value R8_SNorm Equivalent to GL_R8_SNORM
-    \value RG8_SNorm Equivalent to GL_RG8_SNORM
-    \value RGB8_SNorm Equivalent to GL_RGB8_SNORM
-    \value RGBA8_SNorm Equivalent to GL_RGBA8_SNORM
-
-    \value R16_SNorm Equivalent to GL_R16_SNORM
-    \value RG16_SNorm Equivalent to GL_RG16_SNORM
-    \value RGB16_SNorm Equivalent to GL_RGB16_SNORM
-    \value RGBA16_SNorm Equivalent to GL_RGBA16_SNORM
-
-    \value R8U Equivalent to GL_R8UI
-    \value RG8U Equivalent to GL_RG8UI
-    \value RGB8U Equivalent to GL_RGB8UI
-    \value RGBA8U Equivalent to GL_RGBA8UI
-
-    \value R16U Equivalent to GL_R16UI
-    \value RG16U Equivalent to GL_RG16UI
-    \value RGB16U Equivalent to GL_RGB16UI
-    \value RGBA16U Equivalent to GL_RGBA16UI
-
-    \value R32U Equivalent to GL_R32UI
-    \value RG32U Equivalent to GL_RG32UI
-    \value RGB32U Equivalent to GL_RGB32UI
-    \value RGBA32U Equivalent to GL_RGBA32UI
-
-    \value R8I Equivalent to GL_R8I
-    \value RG8I Equivalent to GL_RG8I
-    \value RGB8I Equivalent to GL_RGB8I
-    \value RGBA8I Equivalent to GL_RGBA8I
-
-    \value R16I Equivalent to GL_R16I
-    \value RG16I Equivalent to GL_RG16I
-    \value RGB16I Equivalent to GL_RGB16I
-    \value RGBA16I Equivalent to GL_RGBA16I
-
-    \value R32I Equivalent to GL_R32I
-    \value RG32I Equivalent to GL_RG32I
-    \value RGB32I Equivalent to GL_RGB32I
-    \value RGBA32I Equivalent to GL_RGBA32I
-
-    \value R16F Equivalent to GL_R16F
-    \value RG16F Equivalent to GL_RG16F
-    \value RGB16F Equivalent to GL_RGB16F
-    \value RGBA16F Equivalent to GL_RGBA16F
-
-    \value R32F Equivalent to GL_R32F
-    \value RG32F Equivalent to GL_RG32F
-    \value RGB32F Equivalent to GL_RGB32F
-    \value RGBA32F Equivalent to GL_RGBA32F
-
-    \value RGB9E5 Equivalent to GL_RGB9_E5
-    \value RG11B10F Equivalent to GL_R11F_G11F_B10F
-    \value RG3B2 Equivalent to GL_R3_G3_B2
-    \value R5G6B5 Equivalent to GL_RGB565
-    \value RGB5A1 Equivalent to GL_RGB5_A1
-    \value RGBA4 Equivalent to GL_RGBA4
-    \value RGB10A2 Equivalent to GL_RGB10_A2UI
-
-    \value D16 Equivalent to GL_DEPTH_COMPONENT16
-    \value D24 Equivalent to GL_DEPTH_COMPONENT24
-    \value D24S8 Equivalent to GL_DEPTH24_STENCIL8
-    \value D32 Equivalent to GL_DEPTH_COMPONENT32
-    \value D32F Equivalent to GL_DEPTH_COMPONENT32F
-    \value D32FS8X24 Equivalent to GL_DEPTH32F_STENCIL8
-    \value S8 Equivalent to GL_STENCIL_INDEX8. Introduced in Qt 5.4
-
-    \value RGB_DXT1 Equivalent to GL_COMPRESSED_RGB_S3TC_DXT1_EXT
-    \value RGBA_DXT1 Equivalent to GL_COMPRESSED_RGBA_S3TC_DXT1_EXT
-    \value RGBA_DXT3 Equivalent to GL_COMPRESSED_RGBA_S3TC_DXT3_EXT
-    \value RGBA_DXT5 Equivalent to GL_COMPRESSED_RGBA_S3TC_DXT5_EXT
-    \value R_ATI1N_UNorm Equivalent to GL_COMPRESSED_RED_RGTC1
-    \value R_ATI1N_SNorm Equivalent to GL_COMPRESSED_SIGNED_RED_RGTC1
-    \value RG_ATI2N_UNorm Equivalent to GL_COMPRESSED_RG_RGTC2
-    \value RG_ATI2N_SNorm Equivalent to GL_COMPRESSED_SIGNED_RG_RGTC2
-    \value RGB_BP_UNSIGNED_FLOAT Equivalent to GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB
-    \value RGB_BP_SIGNED_FLOAT Equivalent to GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB
-    \value RGB_BP_UNorm Equivalent to GL_COMPRESSED_RGBA_BPTC_UNORM_ARB
-    \value R11_EAC_UNorm Equivalent to GL_COMPRESSED_R11_EAC
-    \value R11_EAC_SNorm Equivalent to GL_COMPRESSED_SIGNED_R11_EAC
-    \value RG11_EAC_UNorm Equivalent to GL_COMPRESSED_RG11_EAC
-    \value RG11_EAC_SNorm Equivalent to GL_COMPRESSED_SIGNED_RG11_EAC
-    \value RGB8_ETC2 Equivalent to GL_COMPRESSED_RGB8_ETC2
-    \value SRGB8_ETC2 Equivalent to GL_COMPRESSED_SRGB8_ETC2
-    \value RGB8_PunchThrough_Alpha1_ETC2 Equivalent to GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2
-    \value SRGB8_PunchThrough_Alpha1_ETC2 Equivalent to GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2
-    \value RGBA8_ETC2_EAC Equivalent to GL_COMPRESSED_RGBA8_ETC2_EAC
-    \value SRGB8_Alpha8_ETC2_EAC Equivalent to GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC
-    \value RGB8_ETC1 Equivalent to GL_ETC1_RGB8_OES
-    \value RGBA_ASTC_4x4 Equivalent to GL_COMPRESSED_RGBA_ASTC_4x4_KHR
-    \value RGBA_ASTC_5x4 Equivalent to GL_COMPRESSED_RGBA_ASTC_5x4_KHR
-    \value RGBA_ASTC_5x5 Equivalent to GL_COMPRESSED_RGBA_ASTC_5x5_KHR
-    \value RGBA_ASTC_6x5 Equivalent to GL_COMPRESSED_RGBA_ASTC_6x5_KHR
-    \value RGBA_ASTC_6x6 Equivalent to GL_COMPRESSED_RGBA_ASTC_6x6_KHR
-    \value RGBA_ASTC_8x5 Equivalent to GL_COMPRESSED_RGBA_ASTC_8x5_KHR
-    \value RGBA_ASTC_8x6 Equivalent to GL_COMPRESSED_RGBA_ASTC_8x6_KHR
-    \value RGBA_ASTC_8x8 Equivalent to GL_COMPRESSED_RGBA_ASTC_8x8_KHR
-    \value RGBA_ASTC_10x5 Equivalent to GL_COMPRESSED_RGBA_ASTC_10x5_KHR
-    \value RGBA_ASTC_10x6 Equivalent to GL_COMPRESSED_RGBA_ASTC_10x6_KHR
-    \value RGBA_ASTC_10x8 Equivalent to GL_COMPRESSED_RGBA_ASTC_10x8_KHR
-    \value RGBA_ASTC_10x10 Equivalent to GL_COMPRESSED_RGBA_ASTC_10x10_KHR
-    \value RGBA_ASTC_12x10 Equivalent to GL_COMPRESSED_RGBA_ASTC_12x10_KHR
-    \value RGBA_ASTC_12x12 Equivalent to GL_COMPRESSED_RGBA_ASTC_12x12_KHR
-    \value SRGB8_Alpha8_ASTC_4x4 Equivalent to GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR
-    \value SRGB8_Alpha8_ASTC_5x4 Equivalent to GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR
-    \value SRGB8_Alpha8_ASTC_5x5 Equivalent to GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR
-    \value SRGB8_Alpha8_ASTC_6x5 Equivalent to GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR
-    \value SRGB8_Alpha8_ASTC_6x6 Equivalent to GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR
-    \value SRGB8_Alpha8_ASTC_8x5 Equivalent to GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR
-    \value SRGB8_Alpha8_ASTC_8x6 Equivalent to GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR
-    \value SRGB8_Alpha8_ASTC_8x8 Equivalent to GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR
-    \value SRGB8_Alpha8_ASTC_10x5 Equivalent to GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR
-    \value SRGB8_Alpha8_ASTC_10x6 Equivalent to GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR
-    \value SRGB8_Alpha8_ASTC_10x8 Equivalent to GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR
-    \value SRGB8_Alpha8_ASTC_10x10 Equivalent to GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR
-    \value SRGB8_Alpha8_ASTC_12x10 Equivalent to GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR
-    \value SRGB8_Alpha8_ASTC_12x12 Equivalent to GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR
-
-    \value SRGB8 Equivalent to GL_SRGB8
-    \value SRGB8_Alpha8 Equivalent to GL_SRGB8_ALPHA8
-    \value SRGB_DXT1 Equivalent to GL_COMPRESSED_SRGB_S3TC_DXT1_EXT
-    \value SRGB_Alpha_DXT1 Equivalent to GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT
-    \value SRGB_Alpha_DXT3 Equivalent to GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT
-    \value SRGB_Alpha_DXT5 Equivalent to GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT
-    \value SRGB_BP_UNorm Equivalent to GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB
-
-    \value DepthFormat Equivalent to GL_DEPTH_COMPONENT (only OpenGL ES 3 or ES 2 with OES_depth_texture)
-    \value AlphaFormat Equivalent to GL_ALPHA (OpenGL ES 2 only)
-    \value RGBFormat Equivalent to GL_RGB (OpenGL ES 2 only)
-    \value RGBAFormat Equivalent to GL_RGBA (OpenGL ES 2 only)
-    \value LuminanceFormat Equivalent to GL_LUMINANCE (OpenGL ES 2 only)
-    \value LuminanceAlphaFormat Equivalent to GL_LUMINANCE_ALPHA (OpenGL ES 2 only)
-*/
-
-/*!
-    \enum QOpenGLTexture::CubeMapFace
-    This enum defines the possible CubeMap faces.
-
-    \value CubeMapPositiveX Equivalent to GL_TEXTURE_CUBE_MAP_POSITIVE_X
-    \value CubeMapNegativeX Equivalent to GL_TEXTURE_CUBE_MAP_NEGATIVE_X
-    \value CubeMapPositiveY Equivalent to GL_TEXTURE_CUBE_MAP_POSITIVE_Y
-    \value CubeMapNegativeY Equivalent to GL_TEXTURE_CUBE_MAP_NEGATIVE_Y
-    \value CubeMapPositiveZ Equivalent to GL_TEXTURE_CUBE_MAP_POSITIVE_Z
-    \value CubeMapNegativeZ Equivalent to GL_TEXTURE_CUBE_MAP_NEGATIVE_Z
-*/
-
-/*!
-    \enum QOpenGLTexture::PixelFormat
-    This enum defines the possible client-side pixel formats for a pixel
-    transfer operation.
-
-    \value NoSourceFormat Equivalent to GL_NONE
-    \value Red Equivalent to GL_RED
-    \value RG Equivalent to GL_RG
-    \value RGB Equivalent to GL_RGB
-    \value BGR Equivalent to GL_BGR
-    \value RGBA Equivalent to GL_RGBA
-    \value BGRA Equivalent to GL_BGRA
-    \value Red_Integer Equivalent to GL_RED_INTEGER
-    \value RG_Integer Equivalent to GL_RG_INTEGER
-    \value RGB_Integer Equivalent to GL_RGB_INTEGER
-    \value BGR_Integer Equivalent to GL_BGR_INTEGER
-    \value RGBA_Integer Equivalent to GL_RGBA_INTEGER
-    \value BGRA_Integer Equivalent to GL_BGRA_INTEGER
-    \value Stencil Equivalent to GL_STENCIL_INDEX. Introduced in Qt 5.4
-    \value Depth Equivalent to GL_DEPTH_COMPONENT
-    \value DepthStencil Equivalent to GL_DEPTH_STENCIL
-    \value Alpha Equivalent to GL_ALPHA (OpenGL ES 2 only)
-    \value Luminance Equivalent to GL_LUMINANCE (OpenGL ES 2 only)
-    \value LuminanceAlpha Equivalent to GL_LUMINANCE_ALPHA (OpenGL ES 2 only)
-
-*/
-
-/*!
-    \enum QOpenGLTexture::PixelType
-    This enum defines the possible pixel data types for a pixel transfer operation
-
-    \value NoPixelType Equivalent to GL_NONE
-    \value Int8 Equivalent to GL_BYTE
-    \value UInt8 Equivalent to GL_UNSIGNED_BYTE
-    \value Int16 Equivalent to GL_SHORT
-    \value UInt16 Equivalent to GL_UNSIGNED_SHORT
-    \value Int32 Equivalent to GL_INT
-    \value UInt32 Equivalent to GL_UNSIGNED_INT
-    \value Float16 Equivalent to GL_HALF_FLOAT
-    \value Float16OES Equivalent to GL_HALF_FLOAT_OES
-    \value Float32 Equivalent to GL_FLOAT
-    \value UInt32_RGB9_E5 Equivalent to GL_UNSIGNED_INT_5_9_9_9_REV
-    \value UInt32_RG11B10F Equivalent to GL_UNSIGNED_INT_10F_11F_11F_REV
-    \value UInt8_RG3B2 Equivalent to GL_UNSIGNED_BYTE_3_3_2
-    \value UInt8_RG3B2_Rev Equivalent to GL_UNSIGNED_BYTE_2_3_3_REV
-    \value UInt16_RGB5A1 Equivalent to GL_UNSIGNED_SHORT_5_5_5_1
-    \value UInt16_RGB5A1_Rev Equivalent to GL_UNSIGNED_SHORT_1_5_5_5_REV
-    \value UInt16_R5G6B5 Equivalent to GL_UNSIGNED_SHORT_5_6_5
-    \value UInt16_R5G6B5_Rev Equivalent to GL_UNSIGNED_SHORT_5_6_5_REV
-    \value UInt16_RGBA4 Equivalent to GL_UNSIGNED_SHORT_4_4_4_4
-    \value UInt16_RGBA4_Rev Equivalent to GL_UNSIGNED_SHORT_4_4_4_4_REV
-    \value UInt32_RGBA8 Equivalent to GL_UNSIGNED_INT_8_8_8_8
-    \value UInt32_RGBA8_Rev Equivalent to GL_UNSIGNED_INT_8_8_8_8_REV
-    \value UInt32_RGB10A2 Equivalent to GL_UNSIGNED_INT_10_10_10_2
-    \value UInt32_RGB10A2_Rev Equivalent to GL_UNSIGNED_INT_2_10_10_10_REV
-    \value UInt32_D24S8 Equivalent to GL_UNSIGNED_INT_24_8. Introduced in Qt 5.4
-    \value Float32_D32_UInt32_S8_X24 Equivalent to GL_FLOAT_32_UNSIGNED_INT_24_8_REV. Introduced in Qt 5.4
-*/
-
-/*!
-    \enum QOpenGLTexture::Feature
-    This enum defines the OpenGL texture-related features that can be tested for.
-
-    \value ImmutableStorage Support for immutable texture storage
-    \value ImmutableMultisampleStorage Support for immutable texture storage with
-           multisample targets
-    \value TextureRectangle Support for the GL_TEXTURE_RECTANGLE target
-    \value TextureArrays Support for texture targets with array layers
-    \value Texture3D Support for the 3 dimensional texture target
-    \value TextureMultisample Support for texture targets that have multisample capabilities
-    \value TextureBuffer Support for textures that use OpenGL buffer objects
-           as their data source
-    \value TextureCubeMapArrays Support for cubemap array texture target
-    \value Swizzle Support for texture component swizzle masks
-    \value StencilTexturing Support for stencil texturing (i.e. looking up depth or stencil
-           components of a combined depth/stencil format texture in GLSL shaders).
-    \value AnisotropicFiltering Support for anisotropic texture filtering
-    \value NPOTTextures Basic support for non-power-of-two textures
-    \value NPOTTextureRepeat Full support for non-power-of-two textures including texture
-           repeat modes
-    \value Texture1D Support for the 1 dimensional texture target
-    \value TextureComparisonOperators Support for texture comparison operators
-    \value TextureMipMapLevel Support for setting the base and maximum mipmap levels
-*/
-
-/*!
-    \enum QOpenGLTexture::SwizzleComponent
-    This enum defines the texture color components that can be assigned a swizzle mask.
-
-    \value SwizzleRed The red component. Equivalent to GL_TEXTURE_SWIZZLE_R
-    \value SwizzleGreen The green component. Equivalent to GL_TEXTURE_SWIZZLE_G
-    \value SwizzleBlue The blue component. Equivalent to GL_TEXTURE_SWIZZLE_B
-    \value SwizzleAlpha The alpha component. Equivalent to GL_TEXTURE_SWIZZLE_A
-*/
-
-/*!
-    \enum QOpenGLTexture::SwizzleValue
-    This enum defines the possible mask values for texture swizzling.
-
-    \value RedValue Maps the component to the red channel. Equivalent to GL_RED
-    \value GreenValue Maps the component to the green channel. Equivalent to GL_GREEN
-    \value BlueValue Maps the component to the blue channel. Equivalent to GL_BLUE
-    \value AlphaValue Maps the component to the alpha channel. Equivalent to GL_ALPHA
-    \value ZeroValue Maps the component to a fixed value of 0. Equivalent to GL_ZERO
-    \value OneValue Maps the component to a fixed value of 1. Equivalent to GL_ONE
-*/
-
-/*!
-    \enum QOpenGLTexture::WrapMode
-    This enum defines the possible texture coordinate wrapping modes.
-
-    \value Repeat Texture coordinate is repeated. Equivalent to GL_REPEAT
-    \value MirroredRepeat Texture coordinate is reflected about 0 and 1. Equivalent to GL_MIRRORED_REPEAT
-    \value ClampToEdge Clamps the texture coordinates to [0,1]. Equivalent to GL_CLAMP_TO_EDGE
-    \value ClampToBorder As for ClampToEdge but also blends samples at 0 and 1 with a
-           fixed border color. Equivalent to GL_CLAMP_TO_BORDER
-*/
-
-/*!
-    \enum QOpenGLTexture::CoordinateDirection
-    This enum defines the possible texture coordinate directions
-
-    \value DirectionS The horizontal direction. Equivalent to GL_TEXTURE_WRAP_S
-    \value DirectionT The vertical direction. Equivalent to GL_TEXTURE_WRAP_T
-    \value DirectionR The depth direction. Equivalent to GL_TEXTURE_WRAP_R
-*/
-
-/*!
-    Creates a QOpenGLTexture object that can later be bound to \a target.
-
-    This does not create the underlying OpenGL texture object. Therefore,
-    construction using this constructor does not require a valid current
-    OpenGL context.
-*/
-QOpenGLTexture::QOpenGLTexture(Target target)
-    : d_ptr(new QOpenGLTexturePrivate(target, this))
-{
-}
-
-/*!
-    Creates a QOpenGLTexture object that can later be bound to the 2D texture
-    target and contains the pixel data contained in \a image. If you wish
-    to have a chain of mipmaps generated then set \a genMipMaps to \c true (this
-    is the default).
-
-    This does create the underlying OpenGL texture object. Therefore,
-    construction using this constructor does require a valid current
-    OpenGL context.
-*/
-QOpenGLTexture::QOpenGLTexture(const QImage& image, MipMapGeneration genMipMaps)
-    : QOpenGLTexture(QOpenGLTexture::Target2D)
-{
-    setData(image, genMipMaps);
-}
-
-QOpenGLTexture::~QOpenGLTexture()
-{
-}
-
-/*!
-    Returns the binding target of this texture.
-
-    \since 5.4
-*/
-QOpenGLTexture::Target QOpenGLTexture::target() const
-{
-    Q_D(const QOpenGLTexture);
-    return d->target;
-}
-
-/*!
-    Creates the underlying OpenGL texture object. This requires a current valid
-    OpenGL context. If the texture object already exists, this function does
-    nothing.
-
-    Once the texture object is created you can obtain the object
-    name from the textureId() function. This may be useful if you wish to make
-    some raw OpenGL calls related to this texture.
-
-    Normally it should not be necessary to call this function directly as all
-    functions that set properties of the texture object implicitly call create()
-    on your behalf.
-
-    Returns \c true if the creation succeeded, otherwise returns \c false.
-
-    \sa destroy(), isCreated(), textureId()
-*/
-bool QOpenGLTexture::create()
-{
-    Q_D(QOpenGLTexture);
-    return d->create();
-}
-
-/*!
-    Destroys the underlying OpenGL texture object. This requires a current valid
-    OpenGL context.
-
-    \sa create(), isCreated(), textureId()
-*/
-void QOpenGLTexture::destroy()
-{
-    Q_D(QOpenGLTexture);
-    return d->destroy();
-}
-
-/*!
-    Returns \c true if the underlying OpenGL texture object has been created.
-
-    \sa create(), destroy(), textureId()
-*/
-bool QOpenGLTexture::isCreated() const
-{
-    Q_D(const QOpenGLTexture);
-    return d->textureId != 0;
-}
-
-/*!
-    Returns the name of the underlying OpenGL texture object or 0 if it has
-    not yet been created.
-
-    \sa create(), destroy(), isCreated()
-*/
-GLuint QOpenGLTexture::textureId() const
-{
-    Q_D(const QOpenGLTexture);
-    return d->textureId;
-}
-
-/*!
-    Binds this texture to the currently active texture unit ready for
-    rendering. Note that you do not need to bind QOpenGLTexture objects
-    in order to modify them as the implementation makes use of the
-    EXT_direct_state_access extension where available and simulates it
-    where it is not.
-
-    \sa release()
-*/
-void QOpenGLTexture::bind()
-{
-    Q_D(QOpenGLTexture);
-    Q_ASSERT(d->textureId);
-    d->bind();
-}
-
-/*!
-    Binds this texture to texture unit \a unit ready for
-    rendering. Note that you do not need to bind QOpenGLTexture objects
-    in order to modify them as the implementation makes use of the
-    EXT_direct_state_access extension where available and simulates it
-    where it is not.
-
-    If parameter \a reset is \c true then this function will restore
-    the active unit to the texture unit that was active upon entry.
-
-    \sa release()
-*/
-void QOpenGLTexture::bind(uint unit, TextureUnitReset reset)
-{
-    Q_D(QOpenGLTexture);
-    Q_ASSERT(d->textureId);
-    d->bind(unit, reset);
-}
-
-/*!
-    Unbinds this texture from the currently active texture unit.
-
-    \sa bind()
-*/
-void QOpenGLTexture::release()
-{
-    Q_D(QOpenGLTexture);
-    d->release();
-}
-
-/*!
-    Unbinds this texture from texture unit \a unit.
-
-    If parameter \a reset is \c true then this function
-    will restore the active unit to the texture unit that was active
-    upon entry.
-*/
-void QOpenGLTexture::release(uint unit, TextureUnitReset reset)
-{
-    Q_D(QOpenGLTexture);
-    d->release(unit, reset);
-}
-
-/*!
-    Returns \c true if this texture is bound to the corresponding target
-    of the currently active texture unit.
-
-    \sa bind(), release()
-*/
-bool QOpenGLTexture::isBound() const
-{
-    Q_D(const QOpenGLTexture);
-    Q_ASSERT(d->textureId);
-    return d->isBound();
-}
-
-/*!
-    Returns \c true if this texture is bound to the corresponding target
-    of texture unit \a unit.
-
-    \sa bind(), release()
-*/
-bool QOpenGLTexture::isBound(uint unit)
-{
-    Q_D(const QOpenGLTexture);
-    Q_ASSERT(d->textureId);
-    return d->isBound(unit);
-}
-
-/*!
-    Returns the textureId of the texture that is bound to the \a target
-    of the currently active texture unit.
-*/
-GLuint QOpenGLTexture::boundTextureId(BindingTarget target)
-{
-    QOpenGLContext *ctx = QOpenGLContext::currentContext();
-    if (!ctx) {
-        qWarning("QOpenGLTexture::boundTextureId() requires a valid current context");
-        return 0;
-    }
-
-    GLint textureId = 0;
-    ctx->functions()->glGetIntegerv(target, &textureId);
-    return static_cast<GLuint>(textureId);
-}
-
-/*!
-    Returns the textureId of the texture that is bound to the \a target
-    of the texture unit \a unit.
-*/
-GLuint QOpenGLTexture::boundTextureId(uint unit, BindingTarget target)
-{
-    QOpenGLContext *ctx = QOpenGLContext::currentContext();
-    if (!ctx) {
-        qWarning("QOpenGLTexture::boundTextureId() requires a valid current context");
-        return 0;
-    }
-
-    QOpenGLFunctions *funcs = ctx->functions();
-    funcs->initializeOpenGLFunctions();
-
-    GLint oldTextureUnit = 0;
-    funcs->glGetIntegerv(GL_ACTIVE_TEXTURE, &oldTextureUnit);
-
-    funcs->glActiveTexture(unit);
-    GLint textureId = 0;
-    funcs->glGetIntegerv(target, &textureId);
-    funcs->glActiveTexture(oldTextureUnit);
-
-    return static_cast<GLuint>(textureId);
-}
-
-/*!
-    Sets the format of this texture object to \a format. This function
-    must be called before texture storage is allocated.
-
-    Note that all formats may not be supported. The exact set of supported
-    formats is dependent upon your OpenGL implementation and version.
-
-    \sa format(), allocateStorage()
-*/
-void QOpenGLTexture::setFormat(TextureFormat format)
-{
-    Q_D(QOpenGLTexture);
-    d->create();
-    if (isStorageAllocated()) {
-        qWarning("QOpenGLTexture::setFormat(): Cannot change format once storage has been allocated");
-        return;
-    }
-
-    d->format = format;
-
-    switch (format) {
-    case NoFormat:
-        d->formatClass = NoFormatClass;
-        break;
-
-    case RGBA32F:
-    case RGBA32U:
-    case RGBA32I:
-        d->formatClass = FormatClass_128Bit;
-        break;
-
-    case RGB32F:
-    case RGB32U:
-    case RGB32I:
-        d->formatClass = FormatClass_96Bit;
-        break;
-
-    case RGBA16F:
-    case RG32F:
-    case RGBA16U:
-    case RG32U:
-    case RGBA16I:
-    case RG32I:
-    case RGBA16_UNorm:
-    case RGBA16_SNorm:
-        d->formatClass = FormatClass_64Bit;
-        break;
-
-    case RGB16_UNorm:
-    case RGB16_SNorm:
-    case RGB16F:
-    case RGB16U:
-    case RGB16I:
-        d->formatClass = FormatClass_48Bit;
-        break;
-
-    case RG16F:
-    case RG11B10F:
-    case R32F:
-    case RGB10A2:
-    case RGBA8U:
-    case RG16U:
-    case R32U:
-    case RGBA8I:
-    case RG16I:
-    case R32I:
-    case RGBA8_UNorm:
-    case RG16_UNorm:
-    case RGBA8_SNorm:
-    case RG16_SNorm:
-    case SRGB8_Alpha8:
-    case RGB9E5:
-        d->formatClass = FormatClass_32Bit;
-        break;
-
-    case RGB8_UNorm:
-    case RGB8_SNorm:
-    case SRGB8:
-    case RGB8U:
-    case RGB8I:
-        d->formatClass = FormatClass_24Bit;
-        break;
-
-    case R16F:
-    case RG8U:
-    case R16U:
-    case RG8I:
-    case R16I:
-    case RG8_UNorm:
-    case R16_UNorm:
-    case RG8_SNorm:
-    case R16_SNorm:
-        d->formatClass = FormatClass_16Bit;
-        break;
-
-    case R8U:
-    case R8I:
-    case R8_UNorm:
-    case R8_SNorm:
-        d->formatClass = FormatClass_8Bit;
-        break;
-
-    case R_ATI1N_UNorm:
-    case R_ATI1N_SNorm:
-        d->formatClass = FormatClass_RGTC1_R;
-        break;
-
-    case RG_ATI2N_UNorm:
-    case RG_ATI2N_SNorm:
-        d->formatClass = FormatClass_RGTC2_RG;
-        break;
-
-    case RGB_BP_UNorm:
-    case SRGB_BP_UNorm:
-        d->formatClass = FormatClass_BPTC_Unorm;
-        break;
-
-    case RGB_BP_UNSIGNED_FLOAT:
-    case RGB_BP_SIGNED_FLOAT:
-        d->formatClass = FormatClass_BPTC_Float;
-        break;
-
-    case RGB_DXT1:
-    case SRGB_DXT1:
-        d->formatClass = FormatClass_S3TC_DXT1_RGB;
-        break;
-
-    case RGBA_DXT1:
-    case SRGB_Alpha_DXT1:
-        d->formatClass = FormatClass_S3TC_DXT1_RGBA;
-        break;
-
-    case RGBA_DXT3:
-    case SRGB_Alpha_DXT3:
-        d->formatClass = FormatClass_S3TC_DXT3_RGBA;
-        break;
-
-    case RGBA_DXT5:
-    case SRGB_Alpha_DXT5:
-        d->formatClass = FormatClass_S3TC_DXT5_RGBA;
-        break;
-
-    case QOpenGLTexture::R11_EAC_UNorm:
-    case QOpenGLTexture::R11_EAC_SNorm:
-    case QOpenGLTexture::RG11_EAC_UNorm:
-    case QOpenGLTexture::RG11_EAC_SNorm:
-    case QOpenGLTexture::RGB8_ETC2:
-    case QOpenGLTexture::SRGB8_ETC2:
-    case QOpenGLTexture::RGB8_PunchThrough_Alpha1_ETC2:
-    case QOpenGLTexture::SRGB8_PunchThrough_Alpha1_ETC2:
-    case QOpenGLTexture::RGBA8_ETC2_EAC:
-    case QOpenGLTexture::SRGB8_Alpha8_ETC2_EAC:
-    case QOpenGLTexture::RGB8_ETC1:
-    case RG3B2:
-    case R5G6B5:
-    case RGB5A1:
-    case RGBA4:
-    case D16:
-    case D24:
-    case D24S8:
-    case D32:
-    case D32F:
-    case D32FS8X24:
-    case S8:
-    case DepthFormat:
-    case AlphaFormat:
-    case RGBFormat:
-    case RGBAFormat:
-    case LuminanceFormat:
-    case LuminanceAlphaFormat:
-    case QOpenGLTexture::RGBA_ASTC_4x4:
-    case QOpenGLTexture::RGBA_ASTC_5x4:
-    case QOpenGLTexture::RGBA_ASTC_5x5:
-    case QOpenGLTexture::RGBA_ASTC_6x5:
-    case QOpenGLTexture::RGBA_ASTC_6x6:
-    case QOpenGLTexture::RGBA_ASTC_8x5:
-    case QOpenGLTexture::RGBA_ASTC_8x6:
-    case QOpenGLTexture::RGBA_ASTC_8x8:
-    case QOpenGLTexture::RGBA_ASTC_10x5:
-    case QOpenGLTexture::RGBA_ASTC_10x6:
-    case QOpenGLTexture::RGBA_ASTC_10x8:
-    case QOpenGLTexture::RGBA_ASTC_10x10:
-    case QOpenGLTexture::RGBA_ASTC_12x10:
-    case QOpenGLTexture::RGBA_ASTC_12x12:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_4x4:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_5x4:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_5x5:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_6x5:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_6x6:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_8x5:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_8x6:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_8x8:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_10x5:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_10x6:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_10x8:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_10x10:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_12x10:
-    case QOpenGLTexture::SRGB8_Alpha8_ASTC_12x12:
-        d->formatClass = FormatClass_Unique;
-        break;
-    }
-}
-
-/*!
-    Returns the format of this texture object.
-
-    \sa setFormat()
-*/
-QOpenGLTexture::TextureFormat QOpenGLTexture::format() const
-{
-    Q_D(const QOpenGLTexture);
-    return d->format;
-}
-
-static bool isNpot(int width, int height = 1, int depth = 1)
-{
-    return width & (width-1) || height & (height-1) || depth & (depth-1);
-}
-
-/*!
-    Sets the dimensions of this texture object to \a width,
-    \a height, and \a depth. The default for each dimension is 1.
-    The maximum allowable texture size is dependent upon your OpenGL
-    implementation. Allocating storage for a texture less than the
-    maximum size can still fail if your system is low on resources.
-
-    If a non-power-of-two \a width, \a height or \a depth is provided and your
-    OpenGL implementation doesn't have support for repeating non-power-of-two
-    textures, then the wrap mode is automatically set to ClampToEdge.
-
-    \sa width(), height(), depth()
-*/
-void QOpenGLTexture::setSize(int width, int height, int depth)
-{
-    Q_D(QOpenGLTexture);
-    d->create();
-    if (isStorageAllocated()) {
-        qWarning("Cannot resize a texture that already has storage allocated.\n"
-                 "To do so, destroy() the texture and then create() and setSize()");
-        return;
-    }
-
-    if (isNpot(width, height, depth) && !hasFeature(Feature::NPOTTextureRepeat) && d->target != Target::TargetRectangle)
-        d->setWrapMode(WrapMode::ClampToEdge);
-
-    switch (d->target) {
-    case QOpenGLTexture::Target1D:
-    case QOpenGLTexture::Target1DArray:
-    case QOpenGLTexture::TargetBuffer:
-        d->dimensions[0] = width;
-        Q_UNUSED(height);
-        Q_UNUSED(depth);
-        break;
-
-    case QOpenGLTexture::Target2D:
-    case QOpenGLTexture::Target2DArray:
-    case QOpenGLTexture::TargetRectangle:
-    case QOpenGLTexture::Target2DMultisample:
-    case QOpenGLTexture::Target2DMultisampleArray:
-        d->dimensions[0] = width;
-        d->dimensions[1] = height;
-        Q_UNUSED(depth);
-        break;
-
-    case QOpenGLTexture::TargetCubeMap:
-    case QOpenGLTexture::TargetCubeMapArray:
-        if (width != height)
-            qWarning("QAbstractOpenGLTexture::setSize(): Cube map textures must be square");
-        d->dimensions[0] = d->dimensions[1] = width;
-        Q_UNUSED(depth);
-        break;
-
-    case QOpenGLTexture::Target3D:
-        d->dimensions[0] = width;
-        d->dimensions[1] = height;
-        d->dimensions[2] = depth;
-        break;
-    }
-}
-
-/*!
-    Returns the width of a 1D, 2D or 3D texture.
-
-    \sa height(), depth(), setSize()
-*/
-int QOpenGLTexture::width() const
-{
-    Q_D(const QOpenGLTexture);
-    return d->dimensions[0];
-}
-
-/*!
-    Returns the height of a 2D or 3D texture.
-
-    \sa width(), depth(), setSize()
-*/
-int QOpenGLTexture::height() const
-{
-    Q_D(const QOpenGLTexture);
-    return d->dimensions[1];
-}
-
-/*!
-    Returns the depth of a 3D texture.
-
-    \sa width(), height(), setSize()
-*/
-int QOpenGLTexture::depth() const
-{
-    Q_D(const QOpenGLTexture);
-    return d->dimensions[2];
-}
-
-/*!
-    For texture targets that support mipmaps, this function
-    sets the requested number of mipmap \a levels to allocate storage
-    for. This function should be called before storage is allocated
-    for the texture.
-
-    If the texture target does not support mipmaps this function
-    has no effect.
-
-    \sa mipLevels(), maximumMipLevels(), isStorageAllocated()
-*/
-void QOpenGLTexture::setMipLevels(int levels)
-{
-    Q_D(QOpenGLTexture);
-    d->create();
-    if (isStorageAllocated()) {
-        qWarning("Cannot set mip levels on a texture that already has storage allocated.\n"
-                 "To do so, destroy() the texture and then create() and setMipLevels()");
-        return;
-    }
-
-    switch (d->target) {
-    case QOpenGLTexture::Target1D:
-    case QOpenGLTexture::Target1DArray:
-    case QOpenGLTexture::Target2D:
-    case QOpenGLTexture::Target2DArray:
-    case QOpenGLTexture::TargetCubeMap:
-    case QOpenGLTexture::TargetCubeMapArray:
-    case QOpenGLTexture::Target3D:
-        d->requestedMipLevels = levels;
-        break;
-
-    case QOpenGLTexture::TargetBuffer:
-    case QOpenGLTexture::TargetRectangle:
-    case QOpenGLTexture::Target2DMultisample:
-    case QOpenGLTexture::Target2DMultisampleArray:
-        qWarning("QAbstractOpenGLTexture::setMipLevels(): This texture target does not support mipmaps");
-        break;
-    }
-}
-
-/*!
-    Returns the number of mipmap levels for this texture. If storage
-    has not yet been allocated for this texture it returns the
-    requested number of mipmap levels.
-
-    \sa setMipLevels(), maximumMipLevels(), isStorageAllocated()
-*/
-int QOpenGLTexture::mipLevels() const
-{
-    Q_D(const QOpenGLTexture);
-    return isStorageAllocated() ? d->mipLevels : d->requestedMipLevels;
-}
-
-/*!
-    Returns the maximum number of mipmap levels that this texture
-    can have given the current dimensions.
-
-    \sa setMipLevels(), mipLevels(), setSize()
-*/
-int QOpenGLTexture::maximumMipLevels() const
-{
-    Q_D(const QOpenGLTexture);
-    return d->maximumMipLevelCount();
-}
-
-/*!
-    Sets the number of array \a layers to allocate storage for. This
-    function should be called before storage is allocated for the texture.
-
-    For targets that do not support array layers this function has
-    no effect.
-
-    \sa layers(), isStorageAllocated()
-*/
-void QOpenGLTexture::setLayers(int layers)
-{
-    Q_D(QOpenGLTexture);
-    d->create();
-    if (isStorageAllocated()) {
-        qWarning("Cannot set layers on a texture that already has storage allocated.\n"
-                 "To do so, destroy() the texture and then create() and setLayers()");
-        return;
-    }
-
-    switch (d->target) {
-    case QOpenGLTexture::Target1DArray:
-    case QOpenGLTexture::Target2DArray:
-    case QOpenGLTexture::TargetCubeMapArray:
-    case QOpenGLTexture::Target2DMultisampleArray:
-        d->layers = layers;
-        break;
-
-    case QOpenGLTexture::Target1D:
-    case QOpenGLTexture::Target2D:
-    case QOpenGLTexture::Target3D:
-    case QOpenGLTexture::TargetCubeMap:
-    case QOpenGLTexture::TargetBuffer:
-    case QOpenGLTexture::TargetRectangle:
-    case QOpenGLTexture::Target2DMultisample:
-        qWarning("Texture target does not support array layers");
-        break;
-    }
-}
-
-/*!
-    Returns the number of array layers for this texture. If
-    storage has not yet been allocated for this texture then
-    this function returns the requested number of array layers.
-
-    For texture targets that do not support array layers this
-    will return 1.
-
-    \sa setLayers(), isStorageAllocated()
-*/
-int QOpenGLTexture::layers() const
-{
-    Q_D(const QOpenGLTexture);
-    return d->layers;
-}
-
-/*!
-    Returns the number of faces for this texture. For cubemap
-    and cubemap array type targets this will be 6.
-
-    For non-cubemap type targets this will return 1.
-*/
-int QOpenGLTexture::faces() const
-{
-    Q_D(const QOpenGLTexture);
-    return d->faces;
-}
-
-/*!
-    Sets the number of \a samples to allocate storage for when rendering to
-    a multisample capable texture target. This function should
-    be called before storage is allocated for the texture.
-
-    For targets that do not support multisampling this function has
-    no effect.
-
-    \sa samples(), isStorageAllocated()
-*/
-void QOpenGLTexture::setSamples(int samples)
-{
-    Q_D(QOpenGLTexture);
-    d->create();
-    if (isStorageAllocated()) {
-        qWarning("Cannot set sample count on a texture that already has storage allocated.\n"
-                 "To do so, destroy() the texture and then create() and setSamples()");
-        return;
-    }
-
-    switch (d->target) {
-    case QOpenGLTexture::Target2DMultisample:
-    case QOpenGLTexture::Target2DMultisampleArray:
-        d->samples = samples;
-        break;
-
-    case QOpenGLTexture::Target1D:
-    case QOpenGLTexture::Target2D:
-    case QOpenGLTexture::Target3D:
-    case QOpenGLTexture::Target1DArray:
-    case QOpenGLTexture::Target2DArray:
-    case QOpenGLTexture::TargetCubeMap:
-    case QOpenGLTexture::TargetCubeMapArray:
-    case QOpenGLTexture::TargetBuffer:
-    case QOpenGLTexture::TargetRectangle:
-
-        qWarning("Texture target does not support multisampling");
-        break;
-    }
-}
-
-/*!
-    Returns the number of multisample sample points for this texture.
-    If storage has not yet been allocated for this texture then
-    this function returns the requested number of samples.
-
-    For texture targets that do not support multisampling this
-    will return 0.
-
-    \sa setSamples(), isStorageAllocated()
-*/
-int QOpenGLTexture::samples() const
-{
-    Q_D(const QOpenGLTexture);
-    return d->samples;
-}
-
-/*!
-    Sets whether the sample positions and number of samples used with
-    a multisample capable texture target to \a fixed. If set to \c true
-    the sample positions and number of samples used are the same for
-    all texels in the image and will not depend upon the image size or
-    internal format. This function should be called before storage is allocated
-    for the texture.
-
-    For targets that do not support multisampling this function has
-    no effect.
-
-    The default value is \c true.
-
-    \sa isFixedSamplePositions(), isStorageAllocated()
-*/
-void QOpenGLTexture::setFixedSamplePositions(bool fixed)
-{
-    Q_D(QOpenGLTexture);
-    d->create();
-    if (isStorageAllocated()) {
-        qWarning("Cannot set sample positions on a texture that already has storage allocated.\n"
-                 "To do so, destroy() the texture and then create() and setFixedSamplePositions()");
-        return;
-    }
-
-    switch (d->target) {
-    case QOpenGLTexture::Target2DMultisample:
-    case QOpenGLTexture::Target2DMultisampleArray:
-        d->fixedSamplePositions = fixed;
-        break;
-
-    case QOpenGLTexture::Target1D:
-    case QOpenGLTexture::Target2D:
-    case QOpenGLTexture::Target3D:
-    case QOpenGLTexture::Target1DArray:
-    case QOpenGLTexture::Target2DArray:
-    case QOpenGLTexture::TargetCubeMap:
-    case QOpenGLTexture::TargetCubeMapArray:
-    case QOpenGLTexture::TargetBuffer:
-    case QOpenGLTexture::TargetRectangle:
-
-        qWarning("Texture target does not support multisampling");
-        break;
-    }
-}
-
-/*!
-    Returns whether this texture uses a fixed pattern of multisample
-    samples. If storage has not yet been allocated for this texture then
-    this function returns the requested fixed sample position setting.
-
-    For texture targets that do not support multisampling this
-    will return \c true.
-
-    \sa setFixedSamplePositions(), isStorageAllocated()
-*/
-bool QOpenGLTexture::isFixedSamplePositions() const
-{
-    Q_D(const QOpenGLTexture);
-    return d->fixedSamplePositions;
-}
-
-/*!
-    Allocates server-side storage for this texture object taking
-    into account, the format, dimensions, mipmap levels, array
-    layers and cubemap faces.
-
-    Once storage has been allocated it is no longer possible to change
-    these properties.
-
-    If supported QOpenGLTexture makes use of immutable texture
-    storage.
-
-    Once storage has been allocated for the texture then pixel data
-    can be uploaded via one of the setData() overloads.
-
-    \note If immutable texture storage is not available,
-    then a default pixel format and pixel type will be used to
-    create the mutable storage. You can use the other
-    allocateStorage() overload to specify exactly the pixel format
-    and the pixel type to use when allocating mutable storage;
-    this is particulary useful under certain OpenGL ES implementations
-    (notably, OpenGL ES 2), where the pixel format and the pixel type
-    used at allocation time must perfectly match the format
-    and the type passed to any subsequent setData() call.
-
-    \sa isStorageAllocated(), setData()
-*/
-void QOpenGLTexture::allocateStorage()
-{
-    Q_D(QOpenGLTexture);
-    if (d->create()) {
-        const QOpenGLTexture::PixelFormat pixelFormat = pixelFormatCompatibleWithInternalFormat(d->format);
-        const QOpenGLTexture::PixelType pixelType = pixelTypeCompatibleWithInternalFormat(d->format);
-        d->allocateStorage(pixelFormat, pixelType);
-    }
-}
-
-/*!
-    \since 5.5
-
-    Allocates server-side storage for this texture object taking
-    into account, the format, dimensions, mipmap levels, array
-    layers and cubemap faces.
-
-    Once storage has been allocated it is no longer possible to change
-    these properties.
-
-    If supported QOpenGLTexture makes use of immutable texture
-    storage. However, if immutable texture storage is not available,
-    then the specified \a pixelFormat and \a pixelType will be used
-    to allocate mutable storage; note that in certain OpenGL implementations
-    (notably, OpenGL ES 2) they must perfectly match the format
-    and the type passed to any subsequent setData() call.
-
-    Once storage has been allocated for the texture then pixel data
-    can be uploaded via one of the setData() overloads.
-
-    \sa isStorageAllocated(), setData()
-*/
-void QOpenGLTexture::allocateStorage(QOpenGLTexture::PixelFormat pixelFormat, QOpenGLTexture::PixelType pixelType)
-{
-    Q_D(QOpenGLTexture);
-    if (d->create())
-        d->allocateStorage(pixelFormat, pixelType);
-}
-
-/*!
-    Returns \c true if server-side storage for this texture as been
-    allocated.
-
-    The texture format, dimensions, mipmap levels and array layers
-    cannot be altered once storage ihas been allocated.
-
-    \sa allocateStorage(), setSize(), setMipLevels(), setLayers(), setFormat()
-*/
-bool QOpenGLTexture::isStorageAllocated() const
-{
-    Q_D(const QOpenGLTexture);
-    return d->storageAllocated;
-}
-
-/*!
-    Attempts to create a texture view onto this texture. A texture
-    view is somewhat analogous to a view in SQL in that it presents
-    a restricted or reinterpreted view of the original data. Texture
-    views do not allocate any more server-side storage, insted relying
-    on the storage buffer of the source texture.
-
-    Texture views are only available when using immutable storage. For
-    more information on texture views see
-    http://www.opengl.org/wiki/Texture_Storage#Texture_views.
-
-    The \a target argument specifies the target to use for the view.
-    Only some targets can be used depending upon the target of the original
-    target. For e.g. a view onto a Target1DArray texture can specify
-    either Target1DArray or Target1D but for the latter the number of
-    array layers specified with \a minimumLayer and \a maximumLayer must
-    be exactly 1.
-
-    Simpliar constraints apply for the \a viewFormat. See the above link
-    and the specification for more details.
-
-    The \a minimumMipmapLevel, \a maximumMipmapLevel, \a minimumLayer,
-    and \a maximumLayer arguments serve to restrict the parts of the
-    texture accessible by the texture view.
-
-    If creation of the texture view fails this function will return
-    0. If the function succeeds it will return a pointer to a new
-    QOpenGLTexture object that will return \c true from its isTextureView()
-    function.
-
-    \sa isTextureView()
-*/
-QOpenGLTexture *QOpenGLTexture::createTextureView(Target target,
-                                                  TextureFormat viewFormat,
-                                                  int minimumMipmapLevel, int maximumMipmapLevel,
-                                                  int minimumLayer, int maximumLayer) const
-{
-    Q_D(const QOpenGLTexture);
-    if (!isStorageAllocated()) {
-        qWarning("Cannot set create a texture view of a texture that does not have storage allocated.");
-        return nullptr;
-    }
-    Q_ASSERT(maximumMipmapLevel >= minimumMipmapLevel);
-    Q_ASSERT(maximumLayer >= minimumLayer);
-    return d->createTextureView(target, viewFormat,
-                                minimumMipmapLevel, maximumMipmapLevel,
-                                minimumLayer, maximumLayer);
-}
-
-/*!
-    Returns \c true if this texture object is actually a view onto another
-    texture object.
-
-    \sa createTextureView()
-*/
-bool QOpenGLTexture::isTextureView() const
-{
-    Q_D(const QOpenGLTexture);
-    Q_ASSERT(d->textureId);
-    return d->textureView;
-}
-
-/*!
-    Uploads pixel \a data for this texture object \a mipLevel, array \a layer, and \a cubeFace.
-    Storage must have been allocated before uploading pixel data. Some overloads of setData()
-    will set appropriate dimensions, mipmap levels, and array layers and then allocate storage
-    for you if they have enough information to do so. This will be noted in the function
-    documentation.
-
-    The structure of the pixel data pointed to by \a data is specified by \a sourceFormat
-    and \a sourceType. The pixel data upload can optionally be controlled by \a options.
-
-    If using a compressed format() then you should use setCompressedData() instead of this
-    function.
-
-    \since 5.3
-    \sa setCompressedData()
-*/
-void QOpenGLTexture::setData(int mipLevel, int layer, CubeMapFace cubeFace,
-                             PixelFormat sourceFormat, PixelType sourceType,
-                             const void *data, const QOpenGLPixelTransferOptions * const options)
-{
-    Q_D(QOpenGLTexture);
-    Q_ASSERT(d->textureId);
-    if (!isStorageAllocated()) {
-        qWarning("Cannot set data on a texture that does not have storage allocated.\n"
-                 "To do so call allocateStorage() before this function");
-        return;
-    }
-    d->setData(mipLevel, layer, 1, cubeFace, sourceFormat, sourceType, data, options);
-}
-
-/*!
-    \since 5.9
-    \overload
-
-    Parameter \a layerCount is the number of layers in a texture array
-    that are being uploaded/populated by this call.
-*/
-void QOpenGLTexture::setData(int mipLevel, int layer, int layerCount, QOpenGLTexture::CubeMapFace cubeFace, QOpenGLTexture::PixelFormat sourceFormat, QOpenGLTexture::PixelType sourceType, const void *data, const QOpenGLPixelTransferOptions * const options)
-{
-    Q_D(QOpenGLTexture);
-    Q_ASSERT(d->textureId);
-    if (!isStorageAllocated()) {
-        qWarning("Cannot set data on a texture that does not have storage allocated.\n"
-                 "To do so call allocateStorage() before this function");
-        return;
-    }
-    d->setData(mipLevel, layer, layerCount, cubeFace, sourceFormat, sourceType, data, options);
-}
-
-/*!
-    \since 5.3
-    \overload
-*/
-void QOpenGLTexture::setData(int mipLevel, int layer,
-                             PixelFormat sourceFormat, PixelType sourceType,
-                             const void *data, const QOpenGLPixelTransferOptions * const options)
-{
-    Q_D(QOpenGLTexture);
-    Q_ASSERT(d->textureId);
-    d->setData(mipLevel, layer, 1, QOpenGLTexture::CubeMapPositiveX, sourceFormat, sourceType, data, options);
-}
-
-/*!
-    \since 5.3
-    \overload
-*/
-void QOpenGLTexture::setData(int mipLevel,
-                             PixelFormat sourceFormat, PixelType sourceType,
-                             const void *data, const QOpenGLPixelTransferOptions * const options)
-{
-    Q_D(QOpenGLTexture);
-    Q_ASSERT(d->textureId);
-    d->setData(mipLevel, 0, 1, QOpenGLTexture::CubeMapPositiveX, sourceFormat, sourceType, data, options);
-}
-
-/*!
-    \since 5.3
-    \overload
-*/
-void QOpenGLTexture::setData(PixelFormat sourceFormat, PixelType sourceType,
-                             const void *data, const QOpenGLPixelTransferOptions * const options)
-{
-    Q_D(QOpenGLTexture);
-    Q_ASSERT(d->textureId);
-    d->setData(0, 0, 1, QOpenGLTexture::CubeMapPositiveX, sourceFormat, sourceType, data, options);
-}
-
-/*!
-    \since 5.14
-    \overload
-
-    This overload is to be used to update a part of the texture. Parameters \a
-    xOffset, \a yOffset, \a zOffset specify the texel offsets within the
-    texture. Parameters \a width, \a height and \a depth specify the dimensions
-    of the sub image.
-
-    The structure of the pixel data pointed to by \a data is specified by \a
-    sourceFormat and \a sourceType. The pixel data upload can optionally be
-    controlled by \a options.
-*/
-void QOpenGLTexture::setData(int xOffset, int yOffset, int zOffset,
-                             int width, int height, int depth,
-                             PixelFormat sourceFormat, PixelType sourceType,
-                             const void *data, const QOpenGLPixelTransferOptions * const options)
-{
-    Q_D(QOpenGLTexture);
-    Q_ASSERT(d->textureId);
-    d->setData(xOffset, yOffset, zOffset,
-               width, height, depth,
-               0, 0, 1,
-               QOpenGLTexture::CubeMapPositiveX, sourceFormat,
-               sourceType, data, options);
-}
-
-/*!
-    \since 5.14
-    \overload
-
-    This overload is to be used to update a part of the texture. Parameters \a
-    xOffset, \a yOffset, \a zOffset specify the texel offsets within the
-    texture. Parameters \a width, \a height and \a depth specify the dimensions
-    of the sub image. The mip map level the sub image we want to
-    update is specified with \a mipLevel.
-
-    The structure of the pixel data pointed to by \a data is specified by \a
-    sourceFormat and \a sourceType. The pixel data upload can optionally be
-    controlled by \a options.
-*/
-void QOpenGLTexture::setData(int xOffset, int yOffset, int zOffset,
-                             int width, int height, int depth,
-                             int mipLevel,
-                             PixelFormat sourceFormat, PixelType sourceType,
-                             const void *data, const QOpenGLPixelTransferOptions * const options)
-{
-    Q_D(QOpenGLTexture);
-    Q_ASSERT(d->textureId);
-    d->setData(xOffset, yOffset, zOffset,
-               width, height, depth,
-               mipLevel, 0, 1,
-               QOpenGLTexture::CubeMapPositiveX, sourceFormat,
-               sourceType, data, options);
-}
-
-/*!
-    \since 5.14
-    \overload
-
-    This overload is to be used to update a part of the texture. Parameters \a
-    xOffset, \a yOffset, \a zOffset specify the texel offsets within the
-    texture. Parameters \a width, \a height and \a depth specify the dimensions
-    of the sub image. The mip map level and layerof the sub image we want to
-    update are specified with \a mipLevel and \a layer.
-
-    The structure of the pixel data pointed to by \a data is specified by \a
-    sourceFormat and \a sourceType. The pixel data upload can optionally be
-    controlled by \a options.
-*/
-void QOpenGLTexture::setData(int xOffset, int yOffset, int zOffset,
-                             int width, int height, int depth,
-                             int mipLevel, int layer,
-                             PixelFormat sourceFormat, PixelType sourceType,
-                             const void *data, const QOpenGLPixelTransferOptions * const options)
-{
-    Q_D(QOpenGLTexture);
-    Q_ASSERT(d->textureId);
-    d->setData(xOffset, yOffset, zOffset,
-               width, height, depth,
-               mipLevel, layer, 1,
-               QOpenGLTexture::CubeMapPositiveX, sourceFormat,
-               sourceType, data, options);
-}
-
-/*!
-    \since 5.14
-    \overload
-
-    This overload is to be used to update a part of the texture. Parameters \a
-    xOffset, \a yOffset, \a zOffset specify the texel offsets within the
-    texture. Parameters \a width, \a height and \a depth specify the dimensions
-    of the sub image.The mip map level, layer and cube map face of the sub
-    image we want to update are specified with \a mipLevel, \a layer and \a
-    face.
-
-    The structure of the pixel data pointed to by \a data is specified by \a
-    sourceFormat and \a sourceType. The pixel data upload can optionally be
-    controlled by \a options.
-*/
-void QOpenGLTexture::setData(int xOffset, int yOffset, int zOffset,
-                             int width, int height, int depth,
-                             int mipLevel, int layer,
-                             CubeMapFace face,
-                             PixelFormat sourceFormat, PixelType sourceType,
-                             const void *data, const QOpenGLPixelTransferOptions * const options)
-{
-    Q_D(QOpenGLTexture);
-    Q_ASSERT(d->textureId);
-    d->setData(xOffset, yOffset, zOffset,
-               width, height, depth,
-               mipLevel, layer, 1,
-               face, sourceFormat,
-               sourceType, data, options);
-}
-
-/*!
-    \since 5.14
-    \overload
-
-    This overload is to be used to update a part of the texture. Parameters \a
-    xOffset, \a yOffset, \a zOffset specify the texel offsets within the
-    texture. Parameters \a width, \a height and \a depth specify the dimensions
-    of the sub image.The mip map level, starting layer, cube map face and
-    number of layers of the sub image we want to update are specified with \a
-    mipLevel, \a layer, \a face and \a layerCount.
-
-    The structure of the pixel data pointed to by \a data is specified by \a
-    sourceFormat and \a sourceType. The pixel data upload can optionally be
-    controlled by \a options.
-*/
-void QOpenGLTexture::setData(int xOffset, int yOffset, int zOffset,
-                             int width, int height, int depth,
-                             int mipLevel, int layer,
-                             CubeMapFace face, int layerCount,
-                             PixelFormat sourceFormat, PixelType sourceType,
-                             const void *data, const QOpenGLPixelTransferOptions * const options)
-{
-    Q_D(QOpenGLTexture);
-    Q_ASSERT(d->textureId);
-    d->setData(xOffset, yOffset, zOffset,
-               width, height, depth,
-               mipLevel, layer, layerCount,
-               face, sourceFormat,
-               sourceType, data, options);
-}
-
-#if QT_DEPRECATED_SINCE(5, 3)
-/*!
-    \obsolete
-    \overload
-
-    \sa setCompressedData()
-*/
-void QOpenGLTexture::setData(int mipLevel, int layer, CubeMapFace cubeFace,
-                             PixelFormat sourceFormat, PixelType sourceType,
-                             void *data, const QOpenGLPixelTransferOptions * const options)
-{
-    Q_D(QOpenGLTexture);
-    Q_ASSERT(d->textureId);
-    if (!isStorageAllocated()) {
-        qWarning("Cannot set data on a texture that does not have storage allocated.\n"
-                 "To do so call allocateStorage() before this function");
-        return;
-    }
-    d->setData(mipLevel, layer, 1, cubeFace, sourceFormat, sourceType, data, options);
-}
-
-/*!
-    \obsolete
-    \overload
-*/
-void QOpenGLTexture::setData(int mipLevel, int layer,
-                             PixelFormat sourceFormat, PixelType sourceType,
-                             void *data, const QOpenGLPixelTransferOptions * const options)
-{
-    Q_D(QOpenGLTexture);
-    Q_ASSERT(d->textureId);
-    d->setData(mipLevel, layer, 1, QOpenGLTexture::CubeMapPositiveX, sourceFormat, sourceType, data, options);
-}
-
-/*!
-    \obsolete
-    \overload
-*/
-void QOpenGLTexture::setData(int mipLevel,
-                             PixelFormat sourceFormat, PixelType sourceType,
-                             void *data, const QOpenGLPixelTransferOptions * const options)
-{
-    Q_D(QOpenGLTexture);
-    Q_ASSERT(d->textureId);
-    d->setData(mipLevel, 0, 1, QOpenGLTexture::CubeMapPositiveX, sourceFormat, sourceType, data, options);
-}
-
-/*!
-    \obsolete
-    \overload
-*/
-void QOpenGLTexture::setData(PixelFormat sourceFormat, PixelType sourceType,
-                             void *data, const QOpenGLPixelTransferOptions * const options)
-{
-    Q_D(QOpenGLTexture);
-    Q_ASSERT(d->textureId);
-    d->setData(0, 0, 1, QOpenGLTexture::CubeMapPositiveX, sourceFormat, sourceType, data, options);
-}
-#endif
-
-/*!
-    This overload of setData() will allocate storage for you.
-    The pixel data is contained in \a image. Mipmaps are generated by default.
-    Set \a genMipMaps to \l DontGenerateMipMaps to turn off mipmap generation.
-
-    \overload
-*/
-void QOpenGLTexture::setData(const QImage& image, MipMapGeneration genMipMaps)
-{
-    QOpenGLContext *context = QOpenGLContext::currentContext();
-    if (!context) {
-        qWarning("QOpenGLTexture::setData() requires a valid current context");
-        return;
-    }
-
-    if (image.isNull()) {
-        qWarning("QOpenGLTexture::setData() tried to set a null image");
-        return;
-    }
-
-    if (context->isOpenGLES() && context->format().majorVersion() < 3)
-        setFormat(QOpenGLTexture::RGBAFormat);
-    else
-        setFormat(QOpenGLTexture::RGBA8_UNorm);
-
-    setSize(image.width(), image.height());
-    setMipLevels(genMipMaps == GenerateMipMaps ? maximumMipLevels() : 1);
-    allocateStorage(QOpenGLTexture::RGBA, QOpenGLTexture::UInt8);
-
-    // Upload pixel data and generate mipmaps
-    QImage glImage = image.convertToFormat(QImage::Format_RGBA8888);
-    QOpenGLPixelTransferOptions uploadOptions;
-    uploadOptions.setAlignment(1);
-    setData(0, QOpenGLTexture::RGBA, QOpenGLTexture::UInt8, glImage.constBits(), &uploadOptions);
-}
-
-/*!
-    Uploads compressed pixel \a data to \a mipLevel, array \a layer, and \a cubeFace.
-    The pixel transfer can optionally be controlled with \a options. The \a dataSize
-    argument should specify the size of the data pointed to by \a data.
-
-    If not using a compressed format() then you should use setData() instead of this
-    function.
-
-    \since 5.3
-*/
-void QOpenGLTexture::setCompressedData(int mipLevel, int layer, CubeMapFace cubeFace,
-                                       int dataSize, const void *data,
-                                       const QOpenGLPixelTransferOptions * const options)
-{
-    Q_D(QOpenGLTexture);
-    Q_ASSERT(d->textureId);
-    if (!isStorageAllocated()) {
-        qWarning("Cannot set data on a texture that does not have storage allocated.\n"
-                 "To do so call allocateStorage() before this function");
-        return;
-    }
-    d->setCompressedData(mipLevel, layer, 1, cubeFace, dataSize, data, options);
-}
-
-/*!
-    \since 5.9
-    \overload
-
-    Parameter \a layerCount is the number of layers in a texture array
-    that are being uploaded/populated by this call.
-*/
-void QOpenGLTexture::setCompressedData(int mipLevel, int layer, int layerCount, QOpenGLTexture::CubeMapFace cubeFace, int dataSize, const void *data, const QOpenGLPixelTransferOptions * const options)
-{
-    Q_D(QOpenGLTexture);
-    Q_ASSERT(d->textureId);
-    if (!isStorageAllocated()) {
-        qWarning("Cannot set data on a texture that does not have storage allocated.\n"
-                 "To do so call allocateStorage() before this function");
-        return;
-    }
-    d->setCompressedData(mipLevel, layer, layerCount, cubeFace, dataSize, data, options);
-}
-
-/*!
-    \overload
-*/
-void QOpenGLTexture::setCompressedData(int mipLevel, int layer, int dataSize, const void *data,
-                                       const QOpenGLPixelTransferOptions * const options)
-{
-    Q_D(QOpenGLTexture);
-    Q_ASSERT(d->textureId);
-    d->setCompressedData(mipLevel, layer, 1, QOpenGLTexture::CubeMapPositiveX, dataSize, data, options);
-}
-
-/*!
-    \overload
-*/
-void QOpenGLTexture::setCompressedData(int mipLevel, int dataSize, const void *data,
-                                       const QOpenGLPixelTransferOptions * const options)
-{
-    Q_D(QOpenGLTexture);
-    Q_ASSERT(d->textureId);
-    d->setCompressedData(mipLevel, 0, 1, QOpenGLTexture::CubeMapPositiveX, dataSize, data, options);
-}
-
-/*!
-    \overload
-*/
-void QOpenGLTexture::setCompressedData(int dataSize, const void *data,
-                                       const QOpenGLPixelTransferOptions * const options)
-{
-    Q_D(QOpenGLTexture);
-    Q_ASSERT(d->textureId);
-    d->setCompressedData(0, 0, 1, QOpenGLTexture::CubeMapPositiveX, dataSize, data, options);
-}
-
-#if QT_DEPRECATED_SINCE(5, 3)
-/*!
-    \obsolete
-    \overload
-*/
-void QOpenGLTexture::setCompressedData(int mipLevel, int layer, CubeMapFace cubeFace,
-                                       int dataSize, void *data,
-                                       const QOpenGLPixelTransferOptions * const options)
-{
-    Q_D(QOpenGLTexture);
-    Q_ASSERT(d->textureId);
-    if (!isStorageAllocated()) {
-        qWarning("Cannot set data on a texture that does not have storage allocated.\n"
-                 "To do so call allocateStorage() before this function");
-        return;
-    }
-    d->setCompressedData(mipLevel, layer, 1, cubeFace, dataSize, data, options);
-}
-
-/*!
-    \obsolete
-    \overload
-*/
-void QOpenGLTexture::setCompressedData(int mipLevel, int layer, int dataSize, void *data,
-                                       const QOpenGLPixelTransferOptions * const options)
-{
-    Q_D(QOpenGLTexture);
-    Q_ASSERT(d->textureId);
-    d->setCompressedData(mipLevel, layer, 1, QOpenGLTexture::CubeMapPositiveX, dataSize, data, options);
-}
-
-/*!
-    \obsolete
-    \overload
-*/
-void QOpenGLTexture::setCompressedData(int mipLevel, int dataSize, void *data,
-                                       const QOpenGLPixelTransferOptions * const options)
-{
-    Q_D(QOpenGLTexture);
-    Q_ASSERT(d->textureId);
-    d->setCompressedData(mipLevel, 0, 1, QOpenGLTexture::CubeMapPositiveX, dataSize, data, options);
-}
-
-/*!
-    \obsolete
-    \overload
-*/
-void QOpenGLTexture::setCompressedData(int dataSize, void *data,
-                                       const QOpenGLPixelTransferOptions * const options)
-{
-    Q_D(QOpenGLTexture);
-    Q_ASSERT(d->textureId);
-    d->setCompressedData(0, 0, 1, QOpenGLTexture::CubeMapPositiveX, dataSize, data, options);
-}
-#endif
-
-/*!
-    Returns \c true if your OpenGL implementation and version supports the texture
-    feature \a feature.
-*/
-bool QOpenGLTexture::hasFeature(Feature feature)
-{
-    QOpenGLContext *ctx = QOpenGLContext::currentContext();
-    if (!ctx) {
-        qWarning("QOpenGLTexture::hasFeature() requires a valid current context");
-        return false;
-    }
-
-    QSurfaceFormat f = ctx->format();
-
-    bool supported = false;
-
-#if !defined(QT_OPENGL_ES_2)
-    if (!ctx->isOpenGLES()) {
-        switch (feature) {
-        case ImmutableMultisampleStorage:
-            supported = f.version() >= qMakePair(4, 3)
-                    || ctx->hasExtension(QByteArrayLiteral("GL_ARB_texture_storage_multisample"));
-            break;
-
-        case TextureBuffer:
-            supported = f.version() >= qMakePair(3, 0)
-                    || ctx->hasExtension(QByteArrayLiteral("GL_ARB_texture_buffer_object"));
-            break;
-
-        case StencilTexturing:
-            supported = f.version() >= qMakePair(4, 3)
-                    || ctx->hasExtension(QByteArrayLiteral("GL_ARB_stencil_texturing"));
-            break;
-
-        case ImmutableStorage:
-            supported = f.version() >= qMakePair(4, 2)
-                    || ctx->hasExtension(QByteArrayLiteral("GL_ARB_texture_storage"))
-                    || ctx->hasExtension(QByteArrayLiteral("GL_EXT_texture_storage"));
-            break;
-
-        case TextureCubeMapArrays:
-            supported = f.version() >= qMakePair(4, 0)
-                    || ctx->hasExtension(QByteArrayLiteral("ARB_texture_cube_map_array"));
-            break;
-
-        case Swizzle:
-            supported = f.version() >= qMakePair(3, 3)
-                    || ctx->hasExtension(QByteArrayLiteral("GL_ARB_texture_swizzle"));
-            break;
-
-        case TextureMultisample:
-            supported = f.version() >= qMakePair(3, 2)
-                    || ctx->hasExtension(QByteArrayLiteral("GL_ARB_texture_multisample"));
-            break;
-
-        case TextureArrays:
-            supported = f.version() >= qMakePair(3, 0)
-                    || ctx->hasExtension(QByteArrayLiteral("GL_EXT_texture_array"));
-            break;
-
-        case TextureRectangle:
-            supported = f.version() >= qMakePair(2, 1)
-                    || ctx->hasExtension(QByteArrayLiteral("ARB_texture_rectangle"));
-            break;
-
-        case Texture3D:
-            supported = f.version() >= qMakePair(1, 3);
-            break;
-
-        case AnisotropicFiltering:
-            supported = ctx->hasExtension(QByteArrayLiteral("GL_EXT_texture_filter_anisotropic"));
-            break;
-
-        case NPOTTextures:
-        case NPOTTextureRepeat:
-            supported = ctx->hasExtension(QByteArrayLiteral("GL_ARB_texture_non_power_of_two"));
-            break;
-
-        case Texture1D:
-            supported = f.version() >= qMakePair(1, 1);
-            break;
-
-        case TextureComparisonOperators:
-            // GL 1.4 and GL_ARB_shadow alone support only LEQUAL and GEQUAL;
-            // since we're talking about history anyhow avoid to be extra pedantic
-            // in the feature set, and simply claim supported if we have the full set of operators
-            // (which has been added into 1.5 / GL_EXT_shadow_funcs).
-            supported = f.version() >= qMakePair(1, 5)
-                    || (ctx->hasExtension(QByteArrayLiteral("GL_ARB_shadow"))
-                        && ctx->hasExtension(QByteArrayLiteral("GL_EXT_shadow_funcs")));
-            break;
-
-        case TextureMipMapLevel:
-            supported = f.version() >= qMakePair(1, 2);
-            break;
-
-        case MaxFeatureFlag:
-            break;
-        }
-    }
-
-    if (ctx->isOpenGLES())
-#endif
-    {
-        const char *renderer = reinterpret_cast<const char *>(ctx->functions()->glGetString(GL_RENDERER));
-        switch (feature) {
-        case ImmutableStorage:
-            supported = (f.version() >= qMakePair(3, 0) || ctx->hasExtension(QByteArrayLiteral("GL_EXT_texture_storage")))
-                && !(renderer && strstr(renderer, "Mali")); // do not use on Mali: QTBUG-45106
-            break;
-
-        case ImmutableMultisampleStorage:
-            supported = f.version() >= qMakePair(3, 1);
-            break;
-
-        case TextureRectangle:
-            break;
-
-        case TextureArrays:
-            supported = f.version() >= qMakePair(3, 0);
-            break;
-
-        case Texture3D:
-            supported = f.version() >= qMakePair(3, 0)
-                    || ctx->hasExtension(QByteArrayLiteral("GL_OES_texture_3D"));
-            break;
-
-        case TextureMultisample:
-            supported = f.version() >= qMakePair(3, 1);
-            break;
-
-        case TextureBuffer:
-            break;
-
-        case TextureCubeMapArrays:
-            break;
-
-        case Swizzle:
-            supported = f.version() >= qMakePair(3, 0);
-            break;
-
-        case StencilTexturing:
-            break;
-
-        case AnisotropicFiltering:
-            supported = ctx->hasExtension(QByteArrayLiteral("GL_EXT_texture_filter_anisotropic"));
-            break;
-
-        case NPOTTextures:
-        case NPOTTextureRepeat:
-            supported = f.version() >= qMakePair(3,0)
-                    || ctx->hasExtension(QByteArrayLiteral("GL_OES_texture_npot"))
-                    || ctx->hasExtension(QByteArrayLiteral("GL_ARB_texture_non_power_of_two"));
-            break;
-
-        case Texture1D:
-            break;
-
-        case TextureComparisonOperators:
-            supported = f.version() >= qMakePair(3, 0)
-                    || ctx->hasExtension(QByteArrayLiteral("GL_EXT_shadow_samplers"));
-            break;
-
-        case TextureMipMapLevel:
-            supported = f.version() >= qMakePair(3, 0);
-            break;
-
-        case MaxFeatureFlag:
-            break;
-        }
-    }
-
-    return supported;
-}
-
-/*!
-    Sets the base mipmap level used for all texture lookups with this texture to \a baseLevel.
-
-    \note This function has no effect on Qt built for OpenGL ES 2.
-    \sa mipBaseLevel(), setMipMaxLevel(), setMipLevelRange()
-*/
-void QOpenGLTexture::setMipBaseLevel(int baseLevel)
-{
-    Q_D(QOpenGLTexture);
-    d->create();
-    if (!d->features.testFlag(TextureMipMapLevel)) {
-        qWarning("QOpenGLTexture::setMipBaseLevel: requires OpenGL >= 1.2 or OpenGL ES >= 3.0");
-        return;
-    }
-    Q_ASSERT(d->textureId);
-    Q_ASSERT(d->texFuncs);
-    Q_ASSERT(baseLevel <= d->maxLevel);
-    d->baseLevel = baseLevel;
-    d->texFuncs->glTextureParameteri(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_BASE_LEVEL, baseLevel);
-}
-
-/*!
-    Returns the mipmap base level used for all texture lookups with this texture.
-    The default is 0.
-
-    \sa setMipBaseLevel(), mipMaxLevel(), mipLevelRange()
-*/
-int QOpenGLTexture::mipBaseLevel() const
-{
-    Q_D(const QOpenGLTexture);
-    return d->baseLevel;
-}
-
-/*!
-    Sets the maximum mipmap level used for all texture lookups with this texture to \a maxLevel.
-
-    \note This function has no effect on Qt built for OpenGL ES 2.
-    \sa mipMaxLevel(), setMipBaseLevel(), setMipLevelRange()
-*/
-void QOpenGLTexture::setMipMaxLevel(int maxLevel)
-{
-    Q_D(QOpenGLTexture);
-    d->create();
-    if (!d->features.testFlag(TextureMipMapLevel)) {
-        qWarning("QOpenGLTexture::setMipMaxLevel: requires OpenGL >= 1.2 or OpenGL ES >= 3.0");
-        return;
-    }
-    Q_ASSERT(d->textureId);
-    Q_ASSERT(d->texFuncs);
-    Q_ASSERT(d->baseLevel <= maxLevel);
-    d->maxLevel = maxLevel;
-    d->texFuncs->glTextureParameteri(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_MAX_LEVEL, maxLevel);
-}
-
-/*!
-    Returns the mipmap maximum level used for all texture lookups with this texture.
-
-    \sa setMipMaxLevel(), mipBaseLevel(), mipLevelRange()
-*/
-int QOpenGLTexture::mipMaxLevel() const
-{
-    Q_D(const QOpenGLTexture);
-    return d->maxLevel;
-}
-
-/*!
-    Sets the range of mipmap levels that can be used for texture lookups with this texture
-    to range from \a baseLevel to \a maxLevel.
-
-    \note This function has no effect on Qt built for OpenGL ES 2.
-    \sa setMipBaseLevel(), setMipMaxLevel(), mipLevelRange()
-*/
-void QOpenGLTexture::setMipLevelRange(int baseLevel, int maxLevel)
-{
-    Q_D(QOpenGLTexture);
-    d->create();
-    if (!d->features.testFlag(TextureMipMapLevel)) {
-        qWarning("QOpenGLTexture::setMipLevelRange: requires OpenGL >= 1.2 or OpenGL ES >= 3.0");
-        return;
-    }
-    Q_ASSERT(d->textureId);
-    Q_ASSERT(d->texFuncs);
-    Q_ASSERT(baseLevel <= maxLevel);
-    d->texFuncs->glTextureParameteri(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_BASE_LEVEL, baseLevel);
-    d->texFuncs->glTextureParameteri(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_MAX_LEVEL, maxLevel);
-}
-
-/*!
-    Returns the range of mipmap levels that can be used for texture lookups with this texture.
-
-    \sa mipBaseLevel(), mipMaxLevel()
-*/
-QPair<int, int> QOpenGLTexture::mipLevelRange() const
-{
-    Q_D(const QOpenGLTexture);
-    return qMakePair(d->baseLevel, d->maxLevel);
-}
-
-/*!
-    If \a enabled is \c true, enables automatic mipmap generation for this texture object
-    to occur whenever the level 0 mipmap data is set via setData().
-
-    The automatic mipmap generation is enabled by default.
-
-    \note Mipmap generation is not supported for compressed textures with OpenGL ES 2.0.
-
-    \sa isAutoMipMapGenerationEnabled(), generateMipMaps()
-*/
-void QOpenGLTexture::setAutoMipMapGenerationEnabled(bool enabled)
-{
-    Q_D(QOpenGLTexture);
-    d->autoGenerateMipMaps = enabled;
-}
-
-/*!
-    Returns whether auto mipmap generation is enabled for this texture object.
-
-    \sa setAutoMipMapGenerationEnabled(), generateMipMaps()
-*/
-bool QOpenGLTexture::isAutoMipMapGenerationEnabled() const
-{
-    Q_D(const QOpenGLTexture);
-    return d->autoGenerateMipMaps;
-}
-
-/*!
-    Generates mipmaps for this texture object from mipmap level 0. If you are
-    using a texture target and filtering option that requires mipmaps and you
-    have disabled automatic mipmap generation then you need to call this function
-    or the overload to create the mipmap chain.
-
-    \note Mipmap generation is not supported for compressed textures with OpenGL ES.
-
-    \sa setAutoMipMapGenerationEnabled(), setMipLevels(), mipLevels()
-*/
-void QOpenGLTexture::generateMipMaps()
-{
-    Q_D(QOpenGLTexture);
-    Q_ASSERT(d->texFuncs);
-    Q_ASSERT(d->textureId);
-    if (isCompressedFormat(d->format)) {
-        if (QOpenGLContext *ctx = QOpenGLContext::currentContext())
-            if (ctx->isOpenGLES())
-                return;
-    }
-    d->texFuncs->glGenerateTextureMipmap(d->textureId, d->target, d->bindingTarget);
-}
-
-/*!
-    Generates mipmaps for this texture object from mipmap level \a baseLevel. If you are
-    using a texture target and filtering option that requires mipmaps and you
-    have disabled automatic mipmap generation then you need to call this function
-    or the overload to create the mipmap chain.
-
-    The generation of mipmaps to above \a baseLevel is achieved by setting the mipmap
-    base level to \a baseLevel and then generating the mipmap chain. If \a resetBaseLevel
-    is \c true, then the baseLevel of the texture will be reset to its previous value.
-
-    \sa setAutoMipMapGenerationEnabled(), setMipLevels(), mipLevels()
-*/
-void QOpenGLTexture::generateMipMaps(int baseLevel, bool resetBaseLevel)
-{
-    Q_D(QOpenGLTexture);
-    Q_ASSERT(d->texFuncs);
-    Q_ASSERT(d->textureId);
-    if (isCompressedFormat(d->format)) {
-        if (QOpenGLContext *ctx = QOpenGLContext::currentContext())
-            if (ctx->isOpenGLES())
-                return;
-    }
-    int oldBaseLevel;
-    if (resetBaseLevel)
-        oldBaseLevel = mipBaseLevel();
-    setMipBaseLevel(baseLevel);
-    d->texFuncs->glGenerateTextureMipmap(d->textureId, d->target, d->bindingTarget);
-    if (resetBaseLevel)
-        setMipBaseLevel(oldBaseLevel);
-}
-
-/*!
-    GLSL shaders are able to reorder the components of the vec4 returned by texture
-    functions. It is also desirable to be able to control this reordering from CPU
-    side code. This is made possible by swizzle masks since OpenGL 3.3.
-
-    Each component of the texture can be mapped to one of the SwizzleValue options.
-
-    This function maps \a component to the output \a value.
-
-    \note This function has no effect on Mac and Qt built for OpenGL ES 2.
-    \sa swizzleMask()
-*/
-void QOpenGLTexture::setSwizzleMask(SwizzleComponent component, SwizzleValue value)
-{
-#if !defined(Q_OS_MAC) && !defined(QT_OPENGL_ES_2)
-    if (!QOpenGLContext::currentContext()->isOpenGLES()) {
-        Q_D(QOpenGLTexture);
-        d->create();
-        Q_ASSERT(d->texFuncs);
-        Q_ASSERT(d->textureId);
-        if (!d->features.testFlag(Swizzle)) {
-            qWarning("QOpenGLTexture::setSwizzleMask() requires OpenGL >= 3.3");
-            return;
-        }
-        d->swizzleMask[component - SwizzleRed] = value;
-        d->texFuncs->glTextureParameteri(d->textureId, d->target, d->bindingTarget, component, value);
-        return;
-    }
-#else
-    Q_UNUSED(component);
-    Q_UNUSED(value);
-#endif
-    qWarning("QOpenGLTexture: Texture swizzling is not supported");
-}
-
-/*!
-    Parameters \a {r}, \a {g}, \a {b}, and \a {a}  are values used for setting
-    the colors red, green, blue, and the alpha value.
-    \overload
-*/
-void QOpenGLTexture::setSwizzleMask(SwizzleValue r, SwizzleValue g,
-                                    SwizzleValue b, SwizzleValue a)
-{
-#if !defined(Q_OS_MAC) && !defined(QT_OPENGL_ES_2)
-    if (!QOpenGLContext::currentContext()->isOpenGLES()) {
-        Q_D(QOpenGLTexture);
-        d->create();
-        Q_ASSERT(d->texFuncs);
-        Q_ASSERT(d->textureId);
-        if (!d->features.testFlag(Swizzle)) {
-            qWarning("QOpenGLTexture::setSwizzleMask() requires OpenGL >= 3.3");
-            return;
-        }
-        GLint swizzleMask[] = {GLint(r), GLint(g), GLint(b), GLint(a)};
-        d->swizzleMask[0] = r;
-        d->swizzleMask[1] = g;
-        d->swizzleMask[2] = b;
-        d->swizzleMask[3] = a;
-        d->texFuncs->glTextureParameteriv(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask);
-        return;
-    }
-#else
-    Q_UNUSED(r);
-    Q_UNUSED(g);
-    Q_UNUSED(b);
-    Q_UNUSED(a);
-#endif
-    qWarning("QOpenGLTexture: Texture swizzling is not supported");
-}
-
-/*!
-    Returns the swizzle mask for texture \a component.
-*/
-QOpenGLTexture::SwizzleValue QOpenGLTexture::swizzleMask(SwizzleComponent component) const
-{
-    Q_D(const QOpenGLTexture);
-    return d->swizzleMask[component - SwizzleRed];
-}
-
-/*!
-    \enum QOpenGLTexture::DepthStencilMode
-    \since 5.4
-    This enum specifies which component of a depth/stencil texture is
-    accessed when the texture is sampled.
-
-    \value DepthMode Equivalent to GL_DEPTH_COMPONENT.
-    \value StencilMode Equivalent to GL_STENCIL_INDEX.
-*/
-
-/*!
-    If using a texture that has a combined depth/stencil format this function sets
-    which component of the texture is accessed to \a mode.
-
-    When the parameter is set to DepthMode, then accessing it from the
-    shader will access the depth component as a single float, as normal. But when
-    the parameter is set to StencilMode, the shader will access the stencil component.
-
-    \note This function has no effect on Mac and Qt built for OpenGL ES 2.
-    \since 5.4
-    \sa depthStencilMode()
-*/
-void QOpenGLTexture::setDepthStencilMode(QOpenGLTexture::DepthStencilMode mode)
-{
-#if !defined(Q_OS_MAC) && !defined(QT_OPENGL_ES_2)
-    if (!QOpenGLContext::currentContext()->isOpenGLES()) {
-        Q_D(QOpenGLTexture);
-        d->create();
-        Q_ASSERT(d->texFuncs);
-        Q_ASSERT(d->textureId);
-        if (!d->features.testFlag(StencilTexturing)) {
-            qWarning("QOpenGLTexture::setDepthStencilMode() requires OpenGL >= 4.3 or GL_ARB_stencil_texturing");
-            return;
-        }
-        d->depthStencilMode = mode;
-        d->texFuncs->glTextureParameteri(d->textureId, d->target, d->bindingTarget, GL_DEPTH_STENCIL_TEXTURE_MODE, mode);
-        return;
-    }
-#else
-    Q_UNUSED(mode);
-#endif
-    qWarning("QOpenGLTexture: DepthStencil Mode is not supported");
-}
-
-/*!
-    Returns the depth stencil mode for textures using a combined depth/stencil format.
-
-    \since 5.4
-    \sa setDepthStencilMode()
-*/
-QOpenGLTexture::DepthStencilMode QOpenGLTexture::depthStencilMode() const
-{
-    Q_D(const QOpenGLTexture);
-    return d->depthStencilMode;
-}
-
-/*!
-    \enum QOpenGLTexture::ComparisonFunction
-    \since 5.5
-    This enum specifies which comparison operator is used when texture comparison
-    is enabled on this texture.
-
-    \value CompareLessEqual Equivalent to GL_LEQUAL.
-    \value CompareGreaterEqual Equivalent to GL_GEQUAL.
-    \value CompareLess Equivalent to GL_LESS.
-    \value CompareGreater Equivalent to GL_GREATER.
-    \value CompareEqual Equivalent to GL_EQUAL.
-    \value CommpareNotEqual Equivalent to GL_NOTEQUAL.
-    \value CompareAlways Equivalent to GL_ALWAYS.
-    \value CompareNever Equivalent to GL_NEVER.
-
-*/
-
-/*!
-    \since 5.5
-
-    Sets the texture comparison function on this texture to \a function. The texture
-    comparison function is used by shadow samplers when sampling a depth texture.
-
-    \sa comparisonFunction()
-*/
-void QOpenGLTexture::setComparisonFunction(QOpenGLTexture::ComparisonFunction function)
-{
-    Q_D(QOpenGLTexture);
-    d->create();
-    if (!d->features.testFlag(TextureComparisonOperators)) {
-        qWarning("QOpenGLTexture::setComparisonFunction: requires OpenGL >= 1.5 or OpenGL ES >= 3.0");
-        return;
-    }
-    d->comparisonFunction = function;
-    d->texFuncs->glTextureParameteri(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_COMPARE_FUNC, function);
-}
-
-/*!
-    \since 5.5
-
-    Returns the texture comparison operator set on this texture. By default, a
-    texture has a CompareLessEqual comparison function.
-
-    \sa setComparisonFunction()
-*/
-QOpenGLTexture::ComparisonFunction QOpenGLTexture::comparisonFunction() const
-{
-    Q_D(const QOpenGLTexture);
-    return d->comparisonFunction;
-}
-
-/*!
-    \enum QOpenGLTexture::ComparisonMode
-    \since 5.5
-    This enum specifies which comparison mode is used when sampling this texture.
-
-    \value CompareRefToTexture Equivalent to GL_COMPARE_REF_TO_TEXTURE.
-    \value CompareNone Equivalent to GL_NONE.
-*/
-
-/*!
-    \since 5.5
-
-    Sets the texture comparison mode on this texture to \a mode. The texture
-    comparison mode is used by shadow samplers when sampling a depth texture.
-
-    \sa comparisonMode()
-*/
-void QOpenGLTexture::setComparisonMode(QOpenGLTexture::ComparisonMode mode)
-{
-    Q_D(QOpenGLTexture);
-    d->create();
-    if (!d->features.testFlag(TextureComparisonOperators)) {
-        qWarning("QOpenGLTexture::setComparisonMode: requires OpenGL >= 1.5 or OpenGL ES >= 3.0");
-        return;
-    }
-    d->comparisonMode = mode;
-    d->texFuncs->glTextureParameteri(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_COMPARE_MODE, mode);
-}
-
-/*!
-    \since 5.5
-
-    Returns the texture comparison mode set on this texture. By default, a
-    texture has a CompareNone comparison mode (i.e. comparisons are disabled).
-
-    \sa setComparisonMode()
-*/
-QOpenGLTexture::ComparisonMode QOpenGLTexture::comparisonMode() const
-{
-    Q_D(const QOpenGLTexture);
-    return d->comparisonMode;
-}
-
-/*!
-    Sets the filter used for minification to \a filter.
-
-    \sa minificationFilter(), setMagnificationFilter(), setMinMagFilters()
-*/
-void QOpenGLTexture::setMinificationFilter(QOpenGLTexture::Filter filter)
-{
-    Q_D(QOpenGLTexture);
-    d->create();
-    Q_ASSERT(d->texFuncs);
-    Q_ASSERT(d->textureId);
-    d->minFilter = filter;
-    d->texFuncs->glTextureParameteri(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_MIN_FILTER, filter);
-}
-
-/*!
-    Returns the minification filter.
-
-    \sa setMinificationFilter()
-*/
-QOpenGLTexture::Filter QOpenGLTexture::minificationFilter() const
-{
-    Q_D(const QOpenGLTexture);
-    return d->minFilter;
-}
-
-/*!
-    Sets the magnification filter to \a filter.
-
-    \sa magnificationFilter(), setMinificationFilter(), setMinMagFilters()
-*/
-void QOpenGLTexture::setMagnificationFilter(QOpenGLTexture::Filter filter)
-{
-    Q_D(QOpenGLTexture);
-    d->create();
-    Q_ASSERT(d->texFuncs);
-    Q_ASSERT(d->textureId);
-    d->magFilter = filter;
-    d->texFuncs->glTextureParameteri(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_MAG_FILTER, filter);
-}
-
-/*!
-    Returns the magnification filter.
-
-    \sa setMagnificationFilter()
-*/
-QOpenGLTexture::Filter QOpenGLTexture::magnificationFilter() const
-{
-    Q_D(const QOpenGLTexture);
-    return d->magFilter;
-}
-
-/*!
-    Sets the minification filter to \a minificationFilter and the magnification filter
-    to \a magnificationFilter.
-
-    \sa minMagFilters(), setMinificationFilter(), setMagnificationFilter()
-*/
-void QOpenGLTexture::setMinMagFilters(QOpenGLTexture::Filter minificationFilter,
-                                      QOpenGLTexture::Filter magnificationFilter)
-{
-    Q_D(QOpenGLTexture);
-    d->create();
-    Q_ASSERT(d->texFuncs);
-    Q_ASSERT(d->textureId);
-    d->minFilter = minificationFilter;
-    d->magFilter = magnificationFilter;
-    d->texFuncs->glTextureParameteri(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_MIN_FILTER, minificationFilter);
-    d->texFuncs->glTextureParameteri(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_MAG_FILTER, magnificationFilter);
-}
-
-/*!
-    Returns the current minification and magnification filters.
-
-    \sa setMinMagFilters()
-*/
-QPair<QOpenGLTexture::Filter, QOpenGLTexture::Filter> QOpenGLTexture::minMagFilters() const
-{
-    Q_D(const QOpenGLTexture);
-    return QPair<QOpenGLTexture::Filter, QOpenGLTexture::Filter>(d->minFilter, d->magFilter);
-}
-
-/*!
-    If your OpenGL implementation supports the GL_EXT_texture_filter_anisotropic extension
-    this function sets the maximum anisotropy level to \a anisotropy.
-
-    \sa maximumAnisotropy()
-*/
-void QOpenGLTexture::setMaximumAnisotropy(float anisotropy)
-{
-    Q_D(QOpenGLTexture);
-    d->create();
-    Q_ASSERT(d->texFuncs);
-    Q_ASSERT(d->textureId);
-    if (!d->features.testFlag(AnisotropicFiltering)) {
-        qWarning("QOpenGLTexture::setMaximumAnisotropy() requires GL_EXT_texture_filter_anisotropic");
-        return;
-    }
-    d->maxAnisotropy = anisotropy;
-    d->texFuncs->glTextureParameteri(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_MAX_ANISOTROPY_EXT, anisotropy);
-}
-
-/*!
-    Returns the maximum level of anisotropy to be accounted for when performing texture lookups.
-    This requires the GL_EXT_texture_filter_anisotropic extension.
-
-    \sa setMaximumAnisotropy()
-*/
-float QOpenGLTexture::maximumAnisotropy() const
-{
-    Q_D(const QOpenGLTexture);
-    return d->maxAnisotropy;
-}
-
-/*!
-    Sets the wrap (or repeat mode) for all texture dimentions to \a mode.
-
-    \sa wrapMode()
-*/
-void QOpenGLTexture::setWrapMode(QOpenGLTexture::WrapMode mode)
-{
-    Q_D(QOpenGLTexture);
-    d->create();
-    Q_ASSERT(d->texFuncs);
-    Q_ASSERT(d->textureId);
-    d->setWrapMode(mode);
-}
-
-/*!
-    Holds the texture dimension \a direction.
-    \overload
-*/
-void QOpenGLTexture::setWrapMode(QOpenGLTexture::CoordinateDirection direction, QOpenGLTexture::WrapMode mode)
-{
-    Q_D(QOpenGLTexture);
-    d->create();
-    Q_ASSERT(d->texFuncs);
-    Q_ASSERT(d->textureId);
-    d->setWrapMode(direction, mode);
-}
-
-/*!
-    Returns the wrap mode for the texture dimension \a direction.
-
-    \sa setWrapMode()
-*/
-QOpenGLTexture::WrapMode QOpenGLTexture::wrapMode(QOpenGLTexture::CoordinateDirection direction) const
-{
-    Q_D(const QOpenGLTexture);
-    return d->wrapMode(direction);
-}
-
-/*!
-    Sets the border color of the texture to \a color.
-
-    \note This function has no effect on Mac and Qt built for OpenGL ES 2.
-    \sa borderColor()
-*/
-void QOpenGLTexture::setBorderColor(const QColor &color)
-{
-    setBorderColor(static_cast<float>(color.redF()), static_cast<float>(color.greenF()),
-                   static_cast<float>(color.blueF()), static_cast<float>(color.alphaF()));
-}
-
-/*!
-    Sets the color red to \a {r}, green to \a {g}, blue to \a {b}, and \a {a} to the
-    alpha value.
-    \overload
-*/
-void QOpenGLTexture::setBorderColor(float r, float g, float b, float a)
-{
-#if !defined(QT_OPENGL_ES_2)
-    if (!QOpenGLContext::currentContext()->isOpenGLES()) {
-        Q_D(QOpenGLTexture);
-        d->create();
-        Q_ASSERT(d->texFuncs);
-        Q_ASSERT(d->textureId);
-        float values[4];
-        values[0] = r;
-        values[1] = g;
-        values[2] = b;
-        values[3] = a;
-        d->borderColor.clear();
-        for (int i = 0; i < 4; ++i)
-            d->borderColor.append(QVariant(values[i]));
-        d->texFuncs->glTextureParameterfv(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_BORDER_COLOR, values);
-        return;
-    }
-#else
-    Q_UNUSED(r);
-    Q_UNUSED(g);
-    Q_UNUSED(b);
-    Q_UNUSED(a);
-#endif
-    qWarning("QOpenGLTexture: Border color is not supported");
-}
-
-/*!
-    Sets the color red to \a {r}, green to \a {g}, blue to \a {b}, and the alpha
-    value to \a {a}.
-    \overload
-*/
-void QOpenGLTexture::setBorderColor(int r, int g, int b, int a)
-{
-#if !defined(QT_OPENGL_ES_2)
-    if (!QOpenGLContext::currentContext()->isOpenGLES()) {
-        Q_D(QOpenGLTexture);
-        d->create();
-        Q_ASSERT(d->texFuncs);
-        Q_ASSERT(d->textureId);
-        int values[4];
-        values[0] = r;
-        values[1] = g;
-        values[2] = b;
-        values[3] = a;
-        d->borderColor.clear();
-        for (int i = 0; i < 4; ++i)
-            d->borderColor.append(QVariant(values[i]));
-        d->texFuncs->glTextureParameteriv(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_BORDER_COLOR, values);
-        return;
-    }
-#else
-    Q_UNUSED(r);
-    Q_UNUSED(g);
-    Q_UNUSED(b);
-    Q_UNUSED(a);
-#endif
-    qWarning("QOpenGLTexture: Border color is not supported");
-
-    // TODO Handle case of using glTextureParameterIiv() based on format
-}
-
-/*!
-    Sets the color red to \a {r}, green to \a {g}, blue to \a {b}, and the alpha
-    value to \a {a}.
-    \overload
-*/
-void QOpenGLTexture::setBorderColor(uint r, uint g, uint b, uint a)
-{
-#if !defined(QT_OPENGL_ES_2)
-    if (!QOpenGLContext::currentContext()->isOpenGLES()) {
-        Q_D(QOpenGLTexture);
-        d->create();
-        Q_ASSERT(d->texFuncs);
-        Q_ASSERT(d->textureId);
-        int values[4];
-        values[0] = int(r);
-        values[1] = int(g);
-        values[2] = int(b);
-        values[3] = int(a);
-        d->borderColor.clear();
-        for (int i = 0; i < 4; ++i)
-            d->borderColor.append(QVariant(values[i]));
-        d->texFuncs->glTextureParameteriv(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_BORDER_COLOR, values);
-        return;
-    }
-#else
-    Q_UNUSED(r);
-    Q_UNUSED(g);
-    Q_UNUSED(b);
-    Q_UNUSED(a);
-#endif
-    qWarning("QOpenGLTexture: Border color is not supported");
-
-    // TODO Handle case of using glTextureParameterIuiv() based on format
-}
-
-/*!
-    Returns the borderColor of this texture.
-
-    \sa setBorderColor()
-*/
-QColor QOpenGLTexture::borderColor() const
-{
-    Q_D(const QOpenGLTexture);
-    QColor c(0.0f, 0.0f, 0.0f, 0.0f);
-    if (!d->borderColor.isEmpty()) {
-        c.setRedF(d->borderColor.at(0).toFloat());
-        c.setGreenF(d->borderColor.at(1).toFloat());
-        c.setBlueF(d->borderColor.at(2).toFloat());
-        c.setAlphaF(d->borderColor.at(3).toFloat());
-    }
-    return c;
-}
-
-/*!
-    Writes the texture border color into the first four elements
-    of the array pointed to by \a border.
-
-    \sa setBorderColor()
-*/
-void QOpenGLTexture::borderColor(float *border) const
-{
-    Q_D(const QOpenGLTexture);
-    Q_ASSERT(border);
-    if (d->borderColor.isEmpty()) {
-        for (int i = 0; i < 4; ++i)
-            border[i] = 0.0f;
-    } else {
-        for (int i = 0; i < 4; ++i)
-            border[i] = d->borderColor.at(i).toFloat();
-    }
-}
-
-/*!
-    Writes the texture border color into the first four elements
-    of the array pointed to by \a border.
-
-    \overload
-*/
-void QOpenGLTexture::borderColor(int *border) const
-{
-    Q_D(const QOpenGLTexture);
-    Q_ASSERT(border);
-    if (d->borderColor.isEmpty()) {
-        for (int i = 0; i < 4; ++i)
-            border[i] = 0;
-    } else {
-        for (int i = 0; i < 4; ++i)
-            border[i] = d->borderColor.at(i).toInt();
-    }
-}
-
-/*!
-    Writes the texture border color into the first four elements
-    of the array pointed to by \a border.
-
-    \overload
-*/
-void QOpenGLTexture::borderColor(unsigned int *border) const
-{
-    Q_D(const QOpenGLTexture);
-    Q_ASSERT(border);
-    if (d->borderColor.isEmpty()) {
-        for (int i = 0; i < 4; ++i)
-            border[i] = 0;
-    } else {
-        for (int i = 0; i < 4; ++i)
-            border[i] = d->borderColor.at(i).toUInt();
-    }
-}
-
-/*!
-    Sets the minimum level of detail to \a value. This limits the selection of highest
-    resolution mipmap (lowest mipmap level). The default value is -1000.
-
-    \note This function has no effect on Qt built for OpenGL ES 2.
-    \sa minimumLevelOfDetail(), setMaximumLevelOfDetail(), setLevelOfDetailRange()
-*/
-void QOpenGLTexture::setMinimumLevelOfDetail(float value)
-{
-#if !defined(QT_OPENGL_ES_2)
-    if (!QOpenGLContext::currentContext()->isOpenGLES()) {
-        Q_D(QOpenGLTexture);
-        d->create();
-        Q_ASSERT(d->texFuncs);
-        Q_ASSERT(d->textureId);
-        Q_ASSERT(value < d->maxLevelOfDetail);
-        d->minLevelOfDetail = value;
-        d->texFuncs->glTextureParameterf(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_MIN_LOD, value);
-        return;
-    }
-#else
-    Q_UNUSED(value);
-#endif
-    qWarning("QOpenGLTexture: Detail level is not supported");
-}
-
-/*!
-    Returns the minimum level of detail parameter.
-
-    \sa setMinimumLevelOfDetail(), maximumLevelOfDetail(), levelOfDetailRange()
-*/
-float QOpenGLTexture::minimumLevelOfDetail() const
-{
-    Q_D(const QOpenGLTexture);
-    return d->minLevelOfDetail;
-}
-
-/*!
-    Sets the maximum level of detail to \a value. This limits the selection of lowest
-    resolution mipmap (highest mipmap level). The default value is 1000.
-
-    \note This function has no effect on Qt built for OpenGL ES 2.
-    \sa maximumLevelOfDetail(), setMinimumLevelOfDetail(), setLevelOfDetailRange()
-*/
-void QOpenGLTexture::setMaximumLevelOfDetail(float value)
-{
-#if !defined(QT_OPENGL_ES_2)
-    if (!QOpenGLContext::currentContext()->isOpenGLES()) {
-        Q_D(QOpenGLTexture);
-        d->create();
-        Q_ASSERT(d->texFuncs);
-        Q_ASSERT(d->textureId);
-        Q_ASSERT(value > d->minLevelOfDetail);
-        d->maxLevelOfDetail = value;
-        d->texFuncs->glTextureParameterf(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_MAX_LOD, value);
-        return;
-    }
-#else
-    Q_UNUSED(value);
-#endif
-    qWarning("QOpenGLTexture: Detail level is not supported");
-}
-
-/*!
-    Returns the maximum level of detail parameter.
-
-    \sa setMaximumLevelOfDetail(), minimumLevelOfDetail(), levelOfDetailRange()
-*/
-float QOpenGLTexture::maximumLevelOfDetail() const
-{
-    Q_D(const QOpenGLTexture);
-    return d->maxLevelOfDetail;
-}
-
-/*!
-    Sets the minimum level of detail parameters to \a min and the maximum level
-    to \a max.
-    \note This function has no effect on Qt built for OpenGL ES 2.
-    \sa levelOfDetailRange(), setMinimumLevelOfDetail(), setMaximumLevelOfDetail()
-*/
-void QOpenGLTexture::setLevelOfDetailRange(float min, float max)
-{
-#if !defined(QT_OPENGL_ES_2)
-    if (!QOpenGLContext::currentContext()->isOpenGLES()) {
-        Q_D(QOpenGLTexture);
-        d->create();
-        Q_ASSERT(d->texFuncs);
-        Q_ASSERT(d->textureId);
-        Q_ASSERT(min < max);
-        d->minLevelOfDetail = min;
-        d->maxLevelOfDetail = max;
-        d->texFuncs->glTextureParameterf(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_MIN_LOD, min);
-        d->texFuncs->glTextureParameterf(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_MAX_LOD, max);
-        return;
-    }
-#else
-    Q_UNUSED(min);
-    Q_UNUSED(max);
-#endif
-    qWarning("QOpenGLTexture: Detail level is not supported");
-}
-
-/*!
-    Returns the minimum and maximum level of detail parameters.
-
-    \sa setLevelOfDetailRange(), minimumLevelOfDetail(), maximumLevelOfDetail()
-*/
-QPair<float, float> QOpenGLTexture::levelOfDetailRange() const
-{
-    Q_D(const QOpenGLTexture);
-    return qMakePair(d->minLevelOfDetail, d->maxLevelOfDetail);
-}
-
-/*!
-    Sets the level of detail bias to \a bias.
-    Level of detail bias affects the point at which mipmapping levels change.
-    Increasing values for level of detail bias makes the overall images blurrier
-    or smoother. Decreasing values make the overall images sharper.
-
-    \note This function has no effect on Qt built for OpenGL ES 2.
-    \sa levelofDetailBias()
-*/
-void QOpenGLTexture::setLevelofDetailBias(float bias)
-{
-#if !defined(QT_OPENGL_ES_2)
-    if (!QOpenGLContext::currentContext()->isOpenGLES()) {
-        Q_D(QOpenGLTexture);
-        d->create();
-        Q_ASSERT(d->texFuncs);
-        Q_ASSERT(d->textureId);
-        d->levelOfDetailBias = bias;
-        d->texFuncs->glTextureParameterf(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_LOD_BIAS, bias);
-        return;
-    }
-#else
-    Q_UNUSED(bias);
-#endif
-    qWarning("QOpenGLTexture: Detail level is not supported");
-}
-
-/*!
-    Returns the level of detail bias parameter.
-
-    \sa setLevelofDetailBias()
-*/
-float QOpenGLTexture::levelofDetailBias() const
-{
-    Q_D(const QOpenGLTexture);
-    return d->levelOfDetailBias;
-}
-
-#ifndef QT_NO_DEBUG_STREAM
-QDebug operator<<(QDebug debug, const QOpenGLTexture *t)
-{
-    QDebugStateSaver saver(debug);
-    debug.nospace();
-    debug << "QOpenGLTexture(";
-    if (t) {
-        const QOpenGLTexturePrivate *d = t->d_ptr.data();
-        debug << d->target << ", bindingTarget=" << d->bindingTarget
-            << ", size=[" << d->dimensions[0]
-            << ", " << d->dimensions[1];
-        if (d->target == QOpenGLTexture::Target3D)
-            debug << ", " << d->dimensions[2];
-        debug << "], format=" << d->format << ", formatClass=" << d->formatClass;
-        if (t->isCreated())
-            debug << ", textureId=" << d->textureId;
-        if (t->isBound())
-            debug << ", [bound]";
-        if (t->isTextureView())
-            debug << ", [view]";
-        if (d->fixedSamplePositions)
-            debug << ", [fixedSamplePositions]";
-        debug << ", mipLevels=" << d->requestedMipLevels << ", layers=" << d->layers
-            << ", faces=" << d->faces << ", samples=" << d->samples
-            << ", depthStencilMode=" << d->depthStencilMode << ", comparisonFunction="
-            << d->comparisonFunction << ", comparisonMode=" << d->comparisonMode
-            << ", features=" << d->features << ", minificationFilter=" << d->minFilter
-            << ", magnificationFilter=" << d->magFilter << ", wrapMode=" << d->wrapModes[0];
-    } else {
-        debug << '0';
-    }
-    debug << ')';
-    return debug;
-}
-#endif // QT_NO_DEBUG_STREAM
-
-QT_END_NAMESPACE
diff --git a/src/gui/opengl/qopengltexture.h b/src/gui/opengl/qopengltexture.h
deleted file mode 100644
index 539b6aa7b2..0000000000
--- a/src/gui/opengl/qopengltexture.h
+++ /dev/null
@@ -1,663 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB).
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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 QOPENGLABSTRACTTEXTURE_H
-#define QOPENGLABSTRACTTEXTURE_H
-
-#include <QtGui/qtguiglobal.h>
-
-#ifndef QT_NO_OPENGL
-
-#include <QtGui/qopengl.h>
-#include <QtGui/qimage.h>
-#include <QtCore/QScopedPointer>
-
-QT_BEGIN_NAMESPACE
-
-class QDebug;
-class QOpenGLTexturePrivate;
-class QOpenGLPixelTransferOptions;
-
-class Q_GUI_EXPORT QOpenGLTexture
-{
-    Q_GADGET
-public:
-    enum Target {
-        Target1D                   = 0x0DE0,    // GL_TEXTURE_1D
-        Target1DArray              = 0x8C18,    // GL_TEXTURE_1D_ARRAY
-        Target2D                   = 0x0DE1,    // GL_TEXTURE_2D
-        Target2DArray              = 0x8C1A,    // GL_TEXTURE_2D_ARRAY
-        Target3D                   = 0x806F,    // GL_TEXTURE_3D
-        TargetCubeMap              = 0x8513,    // GL_TEXTURE_CUBE_MAP
-        TargetCubeMapArray         = 0x9009,    // GL_TEXTURE_CUBE_MAP_ARRAY
-        Target2DMultisample        = 0x9100,    // GL_TEXTURE_2D_MULTISAMPLE
-        Target2DMultisampleArray   = 0x9102,    // GL_TEXTURE_2D_MULTISAMPLE_ARRAY
-        TargetRectangle            = 0x84F5,    // GL_TEXTURE_RECTANGLE
-        TargetBuffer               = 0x8C2A     // GL_TEXTURE_BUFFER
-    };
-    Q_ENUM(Target)
-
-    enum BindingTarget {
-        BindingTarget1D                    = 0x8068,   // GL_TEXTURE_BINDING_1D
-        BindingTarget1DArray               = 0x8C1C,   // GL_TEXTURE_BINDING_1D_ARRAY
-        BindingTarget2D                    = 0x8069,   // GL_TEXTURE_BINDING_2D
-        BindingTarget2DArray               = 0x8C1D,   // GL_TEXTURE_BINDING_2D_ARRAY
-        BindingTarget3D                    = 0x806A,   // GL_TEXTURE_BINDING_3D
-        BindingTargetCubeMap               = 0x8514,   // GL_TEXTURE_BINDING_CUBE_MAP
-        BindingTargetCubeMapArray          = 0x900A,   // GL_TEXTURE_BINDING_CUBE_MAP_ARRAY
-        BindingTarget2DMultisample         = 0x9104,   // GL_TEXTURE_BINDING_2D_MULTISAMPLE
-        BindingTarget2DMultisampleArray    = 0x9105,   // GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY
-        BindingTargetRectangle             = 0x84F6,   // GL_TEXTURE_BINDING_RECTANGLE
-        BindingTargetBuffer                = 0x8C2C    // GL_TEXTURE_BINDING_BUFFER
-    };
-    Q_ENUM(BindingTarget)
-
-    enum MipMapGeneration {
-        GenerateMipMaps,
-        DontGenerateMipMaps
-    };
-    Q_ENUM(MipMapGeneration)
-
-    enum TextureUnitReset {
-        ResetTextureUnit,
-        DontResetTextureUnit
-    };
-    Q_ENUM(TextureUnitReset)
-
-    enum TextureFormat {
-        NoFormat               = 0,         // GL_NONE
-
-        // Unsigned normalized formats
-        R8_UNorm               = 0x8229,    // GL_R8
-        RG8_UNorm              = 0x822B,    // GL_RG8
-        RGB8_UNorm             = 0x8051,    // GL_RGB8
-        RGBA8_UNorm            = 0x8058,    // GL_RGBA8
-
-        R16_UNorm              = 0x822A,    // GL_R16
-        RG16_UNorm             = 0x822C,    // GL_RG16
-        RGB16_UNorm            = 0x8054,    // GL_RGB16
-        RGBA16_UNorm           = 0x805B,    // GL_RGBA16
-
-        // Signed normalized formats
-        R8_SNorm               = 0x8F94,    // GL_R8_SNORM
-        RG8_SNorm              = 0x8F95,    // GL_RG8_SNORM
-        RGB8_SNorm             = 0x8F96,    // GL_RGB8_SNORM
-        RGBA8_SNorm            = 0x8F97,    // GL_RGBA8_SNORM
-
-        R16_SNorm              = 0x8F98,    // GL_R16_SNORM
-        RG16_SNorm             = 0x8F99,    // GL_RG16_SNORM
-        RGB16_SNorm            = 0x8F9A,    // GL_RGB16_SNORM
-        RGBA16_SNorm           = 0x8F9B,    // GL_RGBA16_SNORM
-
-        // Unsigned integer formats
-        R8U                    = 0x8232,    // GL_R8UI
-        RG8U                   = 0x8238,    // GL_RG8UI
-        RGB8U                  = 0x8D7D,    // GL_RGB8UI
-        RGBA8U                 = 0x8D7C,    // GL_RGBA8UI
-
-        R16U                   = 0x8234,    // GL_R16UI
-        RG16U                  = 0x823A,    // GL_RG16UI
-        RGB16U                 = 0x8D77,    // GL_RGB16UI
-        RGBA16U                = 0x8D76,    // GL_RGBA16UI
-
-        R32U                   = 0x8236,    // GL_R32UI
-        RG32U                  = 0x823C,    // GL_RG32UI
-        RGB32U                 = 0x8D71,    // GL_RGB32UI
-        RGBA32U                = 0x8D70,    // GL_RGBA32UI
-
-        // Signed integer formats
-        R8I                    = 0x8231,    // GL_R8I
-        RG8I                   = 0x8237,    // GL_RG8I
-        RGB8I                  = 0x8D8F,    // GL_RGB8I
-        RGBA8I                 = 0x8D8E,    // GL_RGBA8I
-
-        R16I                   = 0x8233,    // GL_R16I
-        RG16I                  = 0x8239,    // GL_RG16I
-        RGB16I                 = 0x8D89,    // GL_RGB16I
-        RGBA16I                = 0x8D88,    // GL_RGBA16I
-
-        R32I                   = 0x8235,    // GL_R32I
-        RG32I                  = 0x823B,    // GL_RG32I
-        RGB32I                 = 0x8D83,    // GL_RGB32I
-        RGBA32I                = 0x8D82,    // GL_RGBA32I
-
-        // Floating point formats
-        R16F                   = 0x822D,    // GL_R16F
-        RG16F                  = 0x822F,    // GL_RG16F
-        RGB16F                 = 0x881B,    // GL_RGB16F
-        RGBA16F                = 0x881A,    // GL_RGBA16F
-
-        R32F                   = 0x822E,    // GL_R32F
-        RG32F                  = 0x8230,    // GL_RG32F
-        RGB32F                 = 0x8815,    // GL_RGB32F
-        RGBA32F                = 0x8814,    // GL_RGBA32F
-
-        // Packed formats
-        RGB9E5                 = 0x8C3D,    // GL_RGB9_E5
-        RG11B10F               = 0x8C3A,    // GL_R11F_G11F_B10F
-        RG3B2                  = 0x2A10,    // GL_R3_G3_B2
-        R5G6B5                 = 0x8D62,    // GL_RGB565
-        RGB5A1                 = 0x8057,    // GL_RGB5_A1
-        RGBA4                  = 0x8056,    // GL_RGBA4
-        RGB10A2                = 0x906F,    // GL_RGB10_A2UI
-
-        // Depth formats
-        D16                    = 0x81A5,    // GL_DEPTH_COMPONENT16
-        D24                    = 0x81A6,    // GL_DEPTH_COMPONENT24
-        D24S8                  = 0x88F0,    // GL_DEPTH24_STENCIL8
-        D32                    = 0x81A7,    // GL_DEPTH_COMPONENT32
-        D32F                   = 0x8CAC,    // GL_DEPTH_COMPONENT32F
-        D32FS8X24              = 0x8CAD,    // GL_DEPTH32F_STENCIL8
-        S8                     = 0x8D48,    // GL_STENCIL_INDEX8
-
-        // Compressed formats
-        RGB_DXT1               = 0x83F0,    // GL_COMPRESSED_RGB_S3TC_DXT1_EXT
-        RGBA_DXT1              = 0x83F1,    // GL_COMPRESSED_RGBA_S3TC_DXT1_EXT
-        RGBA_DXT3              = 0x83F2,    // GL_COMPRESSED_RGBA_S3TC_DXT3_EXT
-        RGBA_DXT5              = 0x83F3,    // GL_COMPRESSED_RGBA_S3TC_DXT5_EXT
-        R_ATI1N_UNorm          = 0x8DBB,    // GL_COMPRESSED_RED_RGTC1
-        R_ATI1N_SNorm          = 0x8DBC,    // GL_COMPRESSED_SIGNED_RED_RGTC1
-        RG_ATI2N_UNorm         = 0x8DBD,    // GL_COMPRESSED_RG_RGTC2
-        RG_ATI2N_SNorm         = 0x8DBE,    // GL_COMPRESSED_SIGNED_RG_RGTC2
-        RGB_BP_UNSIGNED_FLOAT  = 0x8E8F,    // GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB
-        RGB_BP_SIGNED_FLOAT    = 0x8E8E,    // GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB
-        RGB_BP_UNorm           = 0x8E8C,    // GL_COMPRESSED_RGBA_BPTC_UNORM_ARB
-        R11_EAC_UNorm          = 0x9270,    // GL_COMPRESSED_R11_EAC
-        R11_EAC_SNorm          = 0x9271,    // GL_COMPRESSED_SIGNED_R11_EAC
-        RG11_EAC_UNorm         = 0x9272,    // GL_COMPRESSED_RG11_EAC
-        RG11_EAC_SNorm         = 0x9273,    // GL_COMPRESSED_SIGNED_RG11_EAC
-        RGB8_ETC2              = 0x9274,    // GL_COMPRESSED_RGB8_ETC2
-        SRGB8_ETC2             = 0x9275,    // GL_COMPRESSED_SRGB8_ETC2
-        RGB8_PunchThrough_Alpha1_ETC2 = 0x9276, // GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2
-        SRGB8_PunchThrough_Alpha1_ETC2 = 0x9277, // GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2
-        RGBA8_ETC2_EAC         = 0x9278,    // GL_COMPRESSED_RGBA8_ETC2_EAC
-        SRGB8_Alpha8_ETC2_EAC  = 0x9279,    // GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC
-        RGB8_ETC1              = 0x8D64,    // GL_ETC1_RGB8_OES
-        RGBA_ASTC_4x4          = 0x93B0,    // GL_COMPRESSED_RGBA_ASTC_4x4_KHR
-        RGBA_ASTC_5x4          = 0x93B1,    // GL_COMPRESSED_RGBA_ASTC_5x4_KHR
-        RGBA_ASTC_5x5          = 0x93B2,    // GL_COMPRESSED_RGBA_ASTC_5x5_KHR
-        RGBA_ASTC_6x5          = 0x93B3,    // GL_COMPRESSED_RGBA_ASTC_6x5_KHR
-        RGBA_ASTC_6x6          = 0x93B4,    // GL_COMPRESSED_RGBA_ASTC_6x6_KHR
-        RGBA_ASTC_8x5          = 0x93B5,    // GL_COMPRESSED_RGBA_ASTC_8x5_KHR
-        RGBA_ASTC_8x6          = 0x93B6,    // GL_COMPRESSED_RGBA_ASTC_8x6_KHR
-        RGBA_ASTC_8x8          = 0x93B7,    // GL_COMPRESSED_RGBA_ASTC_8x8_KHR
-        RGBA_ASTC_10x5         = 0x93B8,    // GL_COMPRESSED_RGBA_ASTC_10x5_KHR
-        RGBA_ASTC_10x6         = 0x93B9,    // GL_COMPRESSED_RGBA_ASTC_10x6_KHR
-        RGBA_ASTC_10x8         = 0x93BA,    // GL_COMPRESSED_RGBA_ASTC_10x8_KHR
-        RGBA_ASTC_10x10        = 0x93BB,    // GL_COMPRESSED_RGBA_ASTC_10x10_KHR
-        RGBA_ASTC_12x10        = 0x93BC,    // GL_COMPRESSED_RGBA_ASTC_12x10_KHR
-        RGBA_ASTC_12x12        = 0x93BD,    // GL_COMPRESSED_RGBA_ASTC_12x12_KHR
-        SRGB8_Alpha8_ASTC_4x4  = 0x93D0,    // GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR
-        SRGB8_Alpha8_ASTC_5x4  = 0x93D1,    // GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR
-        SRGB8_Alpha8_ASTC_5x5  = 0x93D2,    // GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR
-        SRGB8_Alpha8_ASTC_6x5  = 0x93D3,    // GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR
-        SRGB8_Alpha8_ASTC_6x6  = 0x93D4,    // GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR
-        SRGB8_Alpha8_ASTC_8x5  = 0x93D5,    // GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR
-        SRGB8_Alpha8_ASTC_8x6  = 0x93D6,    // GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR
-        SRGB8_Alpha8_ASTC_8x8  = 0x93D7,    // GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR
-        SRGB8_Alpha8_ASTC_10x5 = 0x93D8,    // GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR
-        SRGB8_Alpha8_ASTC_10x6 = 0x93D9,    // GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR
-        SRGB8_Alpha8_ASTC_10x8 = 0x93DA,    // GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR
-        SRGB8_Alpha8_ASTC_10x10 = 0x93DB,   // GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR
-        SRGB8_Alpha8_ASTC_12x10 = 0x93DC,   // GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR
-        SRGB8_Alpha8_ASTC_12x12 = 0x93DD,   // GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR
-
-        // sRGB formats
-        SRGB8                  = 0x8C41,    // GL_SRGB8
-        SRGB8_Alpha8           = 0x8C43,    // GL_SRGB8_ALPHA8
-        SRGB_DXT1              = 0x8C4C,    // GL_COMPRESSED_SRGB_S3TC_DXT1_EXT
-        SRGB_Alpha_DXT1        = 0x8C4D,    // GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT
-        SRGB_Alpha_DXT3        = 0x8C4E,    // GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT
-        SRGB_Alpha_DXT5        = 0x8C4F,    // GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT
-        SRGB_BP_UNorm          = 0x8E8D,    // GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB
-
-        // ES 2 formats
-        DepthFormat            = 0x1902,    // GL_DEPTH_COMPONENT
-        AlphaFormat            = 0x1906,    // GL_ALPHA
-        RGBFormat              = 0x1907,    // GL_RGB
-        RGBAFormat             = 0x1908,    // GL_RGBA
-        LuminanceFormat        = 0x1909,    // GL_LUMINANCE
-        LuminanceAlphaFormat   = 0x190A
-
-    };
-    Q_ENUM(TextureFormat)
-
-    // This is not used externally yet but is reserved to allow checking of
-    // compatibility between texture formats
-#ifndef Q_QDOC
-    enum TextureFormatClass {
-        NoFormatClass,
-        FormatClass_128Bit,
-        FormatClass_96Bit,
-        FormatClass_64Bit,
-        FormatClass_48Bit,
-        FormatClass_32Bit,
-        FormatClass_24Bit,
-        FormatClass_16Bit,
-        FormatClass_8Bit,
-        FormatClass_RGTC1_R,
-        FormatClass_RGTC2_RG,
-        FormatClass_BPTC_Unorm,
-        FormatClass_BPTC_Float,
-        FormatClass_S3TC_DXT1_RGB,
-        FormatClass_S3TC_DXT1_RGBA,
-        FormatClass_S3TC_DXT3_RGBA,
-        FormatClass_S3TC_DXT5_RGBA,
-        FormatClass_Unique
-    };
-#endif
-
-    enum CubeMapFace {
-        CubeMapPositiveX = 0x8515,  // GL_TEXTURE_CUBE_MAP_POSITIVE_X
-        CubeMapNegativeX = 0x8516,  // GL_TEXTURE_CUBE_MAP_NEGATIVE_X
-        CubeMapPositiveY = 0x8517,  // GL_TEXTURE_CUBE_MAP_POSITIVE_Y
-        CubeMapNegativeY = 0x8518,  // GL_TEXTURE_CUBE_MAP_NEGATIVE_Y
-        CubeMapPositiveZ = 0x8519,  // GL_TEXTURE_CUBE_MAP_POSITIVE_Z
-        CubeMapNegativeZ = 0x851A   // GL_TEXTURE_CUBE_MAP_NEGATIVE_Z
-    };
-    Q_ENUM(CubeMapFace)
-
-    enum PixelFormat {
-        NoSourceFormat = 0,         // GL_NONE
-        Red            = 0x1903,    // GL_RED
-        RG             = 0x8227,    // GL_RG
-        RGB            = 0x1907,    // GL_RGB
-        BGR            = 0x80E0,    // GL_BGR
-        RGBA           = 0x1908,    // GL_RGBA
-        BGRA           = 0x80E1,    // GL_BGRA
-        Red_Integer    = 0x8D94,    // GL_RED_INTEGER
-        RG_Integer     = 0x8228,    // GL_RG_INTEGER
-        RGB_Integer    = 0x8D98,    // GL_RGB_INTEGER
-        BGR_Integer    = 0x8D9A,    // GL_BGR_INTEGER
-        RGBA_Integer   = 0x8D99,    // GL_RGBA_INTEGER
-        BGRA_Integer   = 0x8D9B,    // GL_BGRA_INTEGER
-        Stencil        = 0x1901,    // GL_STENCIL_INDEX
-        Depth          = 0x1902,    // GL_DEPTH_COMPONENT
-        DepthStencil   = 0x84F9,    // GL_DEPTH_STENCIL
-        Alpha          = 0x1906,    // GL_ALPHA
-        Luminance      = 0x1909,    // GL_LUMINANCE
-        LuminanceAlpha = 0x190A     // GL_LUMINANCE_ALPHA
-    };
-    Q_ENUM(PixelFormat)
-
-    enum PixelType {
-        NoPixelType        = 0,         // GL_NONE
-        Int8               = 0x1400,    // GL_BYTE
-        UInt8              = 0x1401,    // GL_UNSIGNED_BYTE
-        Int16              = 0x1402,    // GL_SHORT
-        UInt16             = 0x1403,    // GL_UNSIGNED_SHORT
-        Int32              = 0x1404,    // GL_INT
-        UInt32             = 0x1405,    // GL_UNSIGNED_INT
-        Float16            = 0x140B,    // GL_HALF_FLOAT
-        Float16OES         = 0x8D61,    // GL_HALF_FLOAT_OES
-        Float32            = 0x1406,    // GL_FLOAT
-        UInt32_RGB9_E5     = 0x8C3E,    // GL_UNSIGNED_INT_5_9_9_9_REV
-        UInt32_RG11B10F    = 0x8C3B,    // GL_UNSIGNED_INT_10F_11F_11F_REV
-        UInt8_RG3B2        = 0x8032,    // GL_UNSIGNED_BYTE_3_3_2
-        UInt8_RG3B2_Rev    = 0x8362,    // GL_UNSIGNED_BYTE_2_3_3_REV
-        UInt16_RGB5A1      = 0x8034,    // GL_UNSIGNED_SHORT_5_5_5_1
-        UInt16_RGB5A1_Rev  = 0x8366,    // GL_UNSIGNED_SHORT_1_5_5_5_REV
-        UInt16_R5G6B5      = 0x8363,    // GL_UNSIGNED_SHORT_5_6_5
-        UInt16_R5G6B5_Rev  = 0x8364,    // GL_UNSIGNED_SHORT_5_6_5_REV
-        UInt16_RGBA4       = 0x8033,    // GL_UNSIGNED_SHORT_4_4_4_4
-        UInt16_RGBA4_Rev   = 0x8365,    // GL_UNSIGNED_SHORT_4_4_4_4_REV
-        UInt32_RGBA8       = 0x8035,    // GL_UNSIGNED_INT_8_8_8_8
-        UInt32_RGBA8_Rev   = 0x8367,    // GL_UNSIGNED_INT_8_8_8_8_REV
-        UInt32_RGB10A2     = 0x8036,    // GL_UNSIGNED_INT_10_10_10_2
-        UInt32_RGB10A2_Rev = 0x8368,    // GL_UNSIGNED_INT_2_10_10_10_REV
-        UInt32_D24S8       = 0x84FA,    // GL_UNSIGNED_INT_24_8
-        Float32_D32_UInt32_S8_X24 = 0x8DAD // GL_FLOAT_32_UNSIGNED_INT_24_8_REV
-    };
-    Q_ENUM(PixelType)
-
-    enum SwizzleComponent {
-        SwizzleRed   = 0x8E42,  // GL_TEXTURE_SWIZZLE_R
-        SwizzleGreen = 0x8E43,  // GL_TEXTURE_SWIZZLE_G
-        SwizzleBlue  = 0x8E44,  // GL_TEXTURE_SWIZZLE_B
-        SwizzleAlpha = 0x8E45   // GL_TEXTURE_SWIZZLE_A
-    };
-    Q_ENUM(SwizzleComponent)
-
-    enum SwizzleValue {
-        RedValue   = 0x1903, // GL_RED
-        GreenValue = 0x1904, // GL_GREEN
-        BlueValue  = 0x1905, // GL_BLUE
-        AlphaValue = 0x1906, // GL_ALPHA
-        ZeroValue  = 0,      // GL_ZERO
-        OneValue   = 1       // GL_ONE
-    };
-    Q_ENUM(SwizzleValue)
-
-    enum WrapMode {
-        Repeat         = 0x2901, // GL_REPEAT
-        MirroredRepeat = 0x8370, // GL_MIRRORED_REPEAT
-        ClampToEdge    = 0x812F, // GL_CLAMP_TO_EDGE
-        ClampToBorder  = 0x812D  // GL_CLAMP_TO_BORDER
-    };
-    Q_ENUM(WrapMode)
-
-    enum CoordinateDirection {
-        DirectionS = 0x2802, // GL_TEXTURE_WRAP_S
-        DirectionT = 0x2803, // GL_TEXTURE_WRAP_T
-        DirectionR = 0x8072  // GL_TEXTURE_WRAP_R
-    };
-    Q_ENUM(CoordinateDirection)
-
-    // Features
-    enum Feature {
-        ImmutableStorage            = 0x00000001,
-        ImmutableMultisampleStorage = 0x00000002,
-        TextureRectangle            = 0x00000004,
-        TextureArrays               = 0x00000008,
-        Texture3D                   = 0x00000010,
-        TextureMultisample          = 0x00000020,
-        TextureBuffer               = 0x00000040,
-        TextureCubeMapArrays        = 0x00000080,
-        Swizzle                     = 0x00000100,
-        StencilTexturing            = 0x00000200,
-        AnisotropicFiltering        = 0x00000400,
-        NPOTTextures                = 0x00000800,
-        NPOTTextureRepeat           = 0x00001000,
-        Texture1D                   = 0x00002000,
-        TextureComparisonOperators  = 0x00004000,
-        TextureMipMapLevel          = 0x00008000,
-#ifndef Q_QDOC
-        MaxFeatureFlag              = 0x00010000
-#endif
-    };
-    Q_DECLARE_FLAGS(Features, Feature)
-    Q_ENUM(Feature)
-
-    explicit QOpenGLTexture(Target target);
-    explicit QOpenGLTexture(const QImage& image, MipMapGeneration genMipMaps = GenerateMipMaps);
-    ~QOpenGLTexture();
-
-    Target target() const;
-
-    // Creation and destruction
-    bool create();
-    void destroy();
-    bool isCreated() const;
-    GLuint textureId() const;
-
-    // Binding and releasing
-    void bind();
-    void bind(uint unit, TextureUnitReset reset = DontResetTextureUnit);
-    void release();
-    void release(uint unit, TextureUnitReset reset = DontResetTextureUnit);
-
-    bool isBound() const;
-    bool isBound(uint unit);
-    static GLuint boundTextureId(BindingTarget target);
-    static GLuint boundTextureId(uint unit, BindingTarget target);
-
-    // Storage allocation
-    void setFormat(TextureFormat format);
-    TextureFormat format() const;
-    void setSize(int width, int height = 1, int depth = 1);
-    int width() const;
-    int height() const;
-    int depth() const;
-    void setMipLevels(int levels);
-    int mipLevels() const;
-    int maximumMipLevels() const;
-    void setLayers(int layers);
-    int layers() const;
-    int faces() const;
-    void setSamples(int samples);
-    int samples() const;
-    void setFixedSamplePositions(bool fixed);
-    bool isFixedSamplePositions() const;
-    void allocateStorage();
-    void allocateStorage(PixelFormat pixelFormat, PixelType pixelType);
-    bool isStorageAllocated() const;
-
-    QOpenGLTexture *createTextureView(Target target,
-                                      TextureFormat viewFormat,
-                                      int minimumMipmapLevel, int maximumMipmapLevel,
-                                      int minimumLayer, int maximumLayer) const;
-    bool isTextureView() const;
-
-    // Pixel transfer
-    // ### Qt 6: remove the non-const void * overloads
-#if QT_DEPRECATED_SINCE(5, 3)
-    QT_DEPRECATED void setData(int mipLevel, int layer, CubeMapFace cubeFace,
-                               PixelFormat sourceFormat, PixelType sourceType,
-                               void *data, const QOpenGLPixelTransferOptions * const options = nullptr);
-    QT_DEPRECATED void setData(int mipLevel, int layer,
-                               PixelFormat sourceFormat, PixelType sourceType,
-                               void *data, const QOpenGLPixelTransferOptions * const options = nullptr);
-    QT_DEPRECATED void setData(int mipLevel,
-                               PixelFormat sourceFormat, PixelType sourceType,
-                               void *data, const QOpenGLPixelTransferOptions * const options = nullptr);
-    QT_DEPRECATED void setData(PixelFormat sourceFormat, PixelType sourceType,
-                               void *data, const QOpenGLPixelTransferOptions * const options = nullptr);
-#endif // QT_DEPRECATED_SINCE(5, 3)
-
-    void setData(int mipLevel, int layer, CubeMapFace cubeFace,
-                 PixelFormat sourceFormat, PixelType sourceType,
-                 const void *data, const QOpenGLPixelTransferOptions * const options = nullptr);
-    void setData(int mipLevel, int layer, int layerCount, CubeMapFace cubeFace,
-                 PixelFormat sourceFormat, PixelType sourceType,
-                 const void *data, const QOpenGLPixelTransferOptions * const options = nullptr);
-    void setData(int mipLevel, int layer,
-                 PixelFormat sourceFormat, PixelType sourceType,
-                 const void *data, const QOpenGLPixelTransferOptions * const options = nullptr);
-    void setData(int mipLevel,
-                 PixelFormat sourceFormat, PixelType sourceType,
-                 const void *data, const QOpenGLPixelTransferOptions * const options = nullptr);
-    void setData(PixelFormat sourceFormat, PixelType sourceType,
-                 const void *data, const QOpenGLPixelTransferOptions * const options = nullptr);
-
-    void setData(int xOffset, int yOffset, int zOffset,
-                 int width, int height, int depth,
-                 PixelFormat sourceFormat, PixelType sourceType,
-                 const void *data, const QOpenGLPixelTransferOptions * const options = nullptr);
-    void setData(int xOffset, int yOffset, int zOffset,
-                 int width, int height, int depth, int mipLevel,
-                 PixelFormat sourceFormat, PixelType sourceType,
-                 const void *data, const QOpenGLPixelTransferOptions * const options = nullptr);
-    void setData(int xOffset, int yOffset, int zOffset,
-                 int width, int height, int depth,
-                 int mipLevel, int layer,
-                 PixelFormat sourceFormat, PixelType sourceType,
-                 const void *data, const QOpenGLPixelTransferOptions * const options = nullptr);
-    void setData(int xOffset, int yOffset, int zOffset,
-                 int width, int height, int depth,
-                 int mipLevel, int layer,
-                 CubeMapFace cubeFace,
-                 PixelFormat sourceFormat, PixelType sourceType,
-                 const void *data, const QOpenGLPixelTransferOptions * const options = nullptr);
-    void setData(int xOffset, int yOffset, int zOffset,
-                 int width, int height, int depth,
-                 int mipLevel, int layer,
-                 CubeMapFace cubeFace, int layerCount,
-                 PixelFormat sourceFormat, PixelType sourceType,
-                 const void *data, const QOpenGLPixelTransferOptions * const options = nullptr);
-
-    // Compressed data upload
-    // ### Qt 6: remove the non-const void * overloads
-#if QT_DEPRECATED_SINCE(5, 3)
-    QT_DEPRECATED void setCompressedData(int mipLevel, int layer, CubeMapFace cubeFace,
-                                         int dataSize, void *data,
-                                         const QOpenGLPixelTransferOptions * const options = nullptr);
-    QT_DEPRECATED void setCompressedData(int mipLevel, int layer,
-                                         int dataSize, void *data,
-                                         const QOpenGLPixelTransferOptions * const options = nullptr);
-    QT_DEPRECATED void setCompressedData(int mipLevel, int dataSize, void *data,
-                                         const QOpenGLPixelTransferOptions * const options = nullptr);
-    QT_DEPRECATED void setCompressedData(int dataSize, void *data,
-                                         const QOpenGLPixelTransferOptions * const options = nullptr);
-#endif // QT_DEPRECATED_SINCE(5, 3)
-
-    void setCompressedData(int mipLevel, int layer, CubeMapFace cubeFace,
-                           int dataSize, const void *data,
-                           const QOpenGLPixelTransferOptions * const options = nullptr);
-    void setCompressedData(int mipLevel, int layer, int layerCount, CubeMapFace cubeFace,
-                           int dataSize, const void *data,
-                           const QOpenGLPixelTransferOptions * const options = nullptr);
-    void setCompressedData(int mipLevel, int layer,
-                           int dataSize, const void *data,
-                           const QOpenGLPixelTransferOptions * const options = nullptr);
-    void setCompressedData(int mipLevel, int dataSize, const void *data,
-                           const QOpenGLPixelTransferOptions * const options = nullptr);
-    void setCompressedData(int dataSize, const void *data,
-                           const QOpenGLPixelTransferOptions * const options = nullptr);
-
-    // Helpful overloads for setData
-    void setData(const QImage& image, MipMapGeneration genMipMaps = GenerateMipMaps);
-
-    static bool hasFeature(Feature feature);
-
-    // Texture Parameters
-    void setMipBaseLevel(int baseLevel);
-    int mipBaseLevel() const;
-    void setMipMaxLevel(int maxLevel);
-    int mipMaxLevel() const;
-    void setMipLevelRange(int baseLevel, int maxLevel);
-    QPair<int, int> mipLevelRange() const;
-
-    void setAutoMipMapGenerationEnabled(bool enabled);
-    bool isAutoMipMapGenerationEnabled() const;
-
-    void generateMipMaps();
-    void generateMipMaps(int baseLevel, bool resetBaseLevel = true);
-
-    void setSwizzleMask(SwizzleComponent component, SwizzleValue value);
-    void setSwizzleMask(SwizzleValue r, SwizzleValue g,
-                        SwizzleValue b, SwizzleValue a);
-    SwizzleValue swizzleMask(SwizzleComponent component) const;
-
-    enum DepthStencilMode {
-        DepthMode   = 0x1902,   // GL_DEPTH_COMPONENT
-        StencilMode = 0x1901    // GL_STENCIL_INDEX
-    };
-    Q_ENUM(DepthStencilMode)
-
-    void setDepthStencilMode(DepthStencilMode mode);
-    DepthStencilMode depthStencilMode() const;
-
-    enum ComparisonFunction {
-        CompareLessEqual    = 0x0203,   // GL_LEQUAL
-        CompareGreaterEqual = 0x0206,   // GL_GEQUAL
-        CompareLess         = 0x0201,   // GL_LESS
-        CompareGreater      = 0x0204,   // GL_GREATER
-        CompareEqual        = 0x0202,   // GL_EQUAL
-        CommpareNotEqual    = 0x0205,   // GL_NOTEQUAL
-        CompareAlways       = 0x0207,   // GL_ALWAYS
-        CompareNever        = 0x0200    // GL_NEVER
-    };
-    Q_ENUM(ComparisonFunction)
-
-    void setComparisonFunction(ComparisonFunction function);
-    ComparisonFunction comparisonFunction() const;
-
-    enum ComparisonMode {
-        CompareRefToTexture = 0x884E,   // GL_COMPARE_REF_TO_TEXTURE
-        CompareNone         = 0x0000    // GL_NONE
-    };
-
-    void setComparisonMode(ComparisonMode mode);
-    ComparisonMode comparisonMode() const;
-
-    // Sampling Parameters
-    enum Filter {
-        Nearest                 = 0x2600,   // GL_NEAREST
-        Linear                  = 0x2601,   // GL_LINEAR
-        NearestMipMapNearest    = 0x2700,   // GL_NEAREST_MIPMAP_NEAREST
-        NearestMipMapLinear     = 0x2702,   // GL_NEAREST_MIPMAP_LINEAR
-        LinearMipMapNearest     = 0x2701,   // GL_LINEAR_MIPMAP_NEAREST
-        LinearMipMapLinear      = 0x2703    // GL_LINEAR_MIPMAP_LINEAR
-    };
-    Q_ENUM(Filter)
-
-    void setMinificationFilter(Filter filter);
-    Filter minificationFilter() const;
-    void setMagnificationFilter(Filter filter);
-    Filter magnificationFilter() const;
-    void setMinMagFilters(Filter minificationFilter,
-                          Filter magnificationFilter);
-    QPair<Filter, Filter> minMagFilters() const;
-    void setMaximumAnisotropy(float anisotropy);
-    float maximumAnisotropy() const;
-
-    void setWrapMode(WrapMode mode);
-    void setWrapMode(CoordinateDirection direction, WrapMode mode);
-    WrapMode wrapMode(CoordinateDirection direction) const;
-
-    void setBorderColor(const QColor &color);
-    void setBorderColor(float r, float g, float b, float a);
-    void setBorderColor(int r, int g, int b, int a);
-    void setBorderColor(uint r, uint g, uint b, uint a);
-
-    QColor borderColor() const;
-    void borderColor(float *border) const;
-    void borderColor(int *border) const;
-    void borderColor(unsigned int *border) const;
-
-    void setMinimumLevelOfDetail(float value);
-    float minimumLevelOfDetail() const;
-    void setMaximumLevelOfDetail(float value);
-    float maximumLevelOfDetail() const;
-    void setLevelOfDetailRange(float min, float max);
-    QPair<float, float> levelOfDetailRange() const;
-    void setLevelofDetailBias(float bias);
-    float levelofDetailBias() const;
-
-#ifndef QT_NO_DEBUG_STREAM
-    friend Q_GUI_EXPORT QDebug operator<<(QDebug dbg, const QOpenGLTexture *t);
-#endif
-
-private:
-    Q_DISABLE_COPY(QOpenGLTexture)
-    Q_DECLARE_PRIVATE(QOpenGLTexture)
-    QScopedPointer<QOpenGLTexturePrivate> d_ptr;
-};
-
-Q_DECLARE_OPERATORS_FOR_FLAGS(QOpenGLTexture::Features)
-
-#ifndef QT_NO_DEBUG_STREAM
-Q_GUI_EXPORT QDebug operator<<(QDebug debug, const QOpenGLTexture *t);
-#endif
-
-QT_END_NAMESPACE
-
-#endif // QT_NO_OPENGL
-
-#endif // QOPENGLABSTRACTTEXTURE_H
diff --git a/src/gui/opengl/qopengltexture_p.h b/src/gui/opengl/qopengltexture_p.h
deleted file mode 100644
index 9f3457ad0a..0000000000
--- a/src/gui/opengl/qopengltexture_p.h
+++ /dev/null
@@ -1,184 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB).
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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 QABSTRACTOPENGLTEXTURE_P_H
-#define QABSTRACTOPENGLTEXTURE_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.
-//
-
-#ifndef QT_NO_OPENGL
-
-#include <QtGui/private/qtguiglobal_p.h>
-#include "private/qobject_p.h"
-#include "qopengltexture.h"
-#include "qopengl.h"
-
-#include <cmath>
-
-namespace {
-inline double qLog2(const double x)
-{
-    return std::log(x) / std::log(2.0);
-}
-}
-
-QT_BEGIN_NAMESPACE
-
-class QOpenGLContext;
-class QOpenGLTextureHelper;
-class QOpenGLFunctions;
-
-class QOpenGLTexturePrivate
-{
-public:
-    QOpenGLTexturePrivate(QOpenGLTexture::Target textureTarget,
-                          QOpenGLTexture *qq);
-    ~QOpenGLTexturePrivate();
-
-    Q_DECLARE_PUBLIC(QOpenGLTexture)
-
-    void resetFuncs(QOpenGLTextureHelper *funcs);
-    void initializeOpenGLFunctions();
-
-    bool create();
-    void destroy();
-
-    void bind();
-    void bind(uint unit, QOpenGLTexture::TextureUnitReset reset = QOpenGLTexture::DontResetTextureUnit);
-    void release();
-    void release(uint unit, QOpenGLTexture::TextureUnitReset reset = QOpenGLTexture::DontResetTextureUnit);
-    bool isBound() const;
-    bool isBound(uint unit) const;
-
-    void allocateStorage(QOpenGLTexture::PixelFormat pixelFormat, QOpenGLTexture::PixelType pixelType);
-    void allocateMutableStorage(QOpenGLTexture::PixelFormat pixelFormat, QOpenGLTexture::PixelType pixelType);
-    void allocateImmutableStorage();
-    void setData(int mipLevel, int layer, int layerCount, QOpenGLTexture::CubeMapFace cubeFace,
-                 QOpenGLTexture::PixelFormat sourceFormat, QOpenGLTexture::PixelType sourceType,
-                 const void *data, const QOpenGLPixelTransferOptions * const options);
-    void setData(int xOffset, int yOffset, int zOffset, int width, int height, int depth,
-                 int mipLevel, int layer, int layerCount, QOpenGLTexture::CubeMapFace cubeFace,
-                 QOpenGLTexture::PixelFormat sourceFormat, QOpenGLTexture::PixelType sourceType,
-                 const void *data, const QOpenGLPixelTransferOptions * const options);
-    void setCompressedData(int mipLevel, int layer, int layerCount, QOpenGLTexture::CubeMapFace cubeFace,
-                           int dataSize, const void *data,
-                           const QOpenGLPixelTransferOptions * const options);
-
-
-    void setWrapMode(QOpenGLTexture::WrapMode mode);
-    void setWrapMode(QOpenGLTexture::CoordinateDirection direction, QOpenGLTexture::WrapMode mode);
-    QOpenGLTexture::WrapMode wrapMode(QOpenGLTexture::CoordinateDirection direction) const;
-
-    QOpenGLTexture *createTextureView(QOpenGLTexture::Target target, QOpenGLTexture::TextureFormat viewFormat,
-                                      int minimumMipmapLevel, int maximumMipmapLevel,
-                                      int minimumLayer, int maximumLayer) const;
-
-    int evaluateMipLevels() const;
-
-    inline int maximumMipLevelCount() const
-    {
-        return 1 + std::floor(qLog2(qMax(dimensions[0], qMax(dimensions[1], dimensions[2]))));
-    }
-
-    static inline int mipLevelSize(int mipLevel, int baseLevelSize)
-    {
-        return std::floor(double(qMax(1, baseLevelSize >> mipLevel)));
-    }
-
-    bool isUsingImmutableStorage() const;
-
-    QOpenGLTexture *q_ptr;
-    QOpenGLContext *context;
-    QOpenGLTexture::Target target;
-    QOpenGLTexture::BindingTarget bindingTarget;
-    GLuint textureId;
-    QOpenGLTexture::TextureFormat format;
-    QOpenGLTexture::TextureFormatClass formatClass;
-    int dimensions[3];
-    int requestedMipLevels;
-    int mipLevels;
-    int layers;
-    int faces;
-
-    int samples;
-    bool fixedSamplePositions;
-
-    int baseLevel;
-    int maxLevel;
-
-    QOpenGLTexture::SwizzleValue swizzleMask[4];
-    QOpenGLTexture::DepthStencilMode depthStencilMode;
-    QOpenGLTexture::ComparisonFunction comparisonFunction;
-    QOpenGLTexture::ComparisonMode comparisonMode;
-
-    QOpenGLTexture::Filter minFilter;
-    QOpenGLTexture::Filter magFilter;
-    float maxAnisotropy;
-    QOpenGLTexture::WrapMode wrapModes[3];
-    QVariantList borderColor;
-    float minLevelOfDetail;
-    float maxLevelOfDetail;
-    float levelOfDetailBias;
-
-    bool textureView;
-    bool autoGenerateMipMaps;
-    bool storageAllocated;
-
-    QOpenGLTextureHelper *texFuncs;
-    QOpenGLFunctions *functions;
-
-    QOpenGLTexture::Features features;
-};
-
-QT_END_NAMESPACE
-
-#undef Q_CALL_MEMBER_FUNCTION
-
-#endif // QT_NO_OPENGL
-
-#endif // QABSTRACTOPENGLTEXTURE_P_H
diff --git a/src/gui/opengl/qopengltextureblitter.cpp b/src/gui/opengl/qopengltextureblitter.cpp
deleted file mode 100644
index b709f2f639..0000000000
--- a/src/gui/opengl/qopengltextureblitter.cpp
+++ /dev/null
@@ -1,682 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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 "qopengltextureblitter.h"
-
-#include <QtGui/QOpenGLBuffer>
-#include <QtGui/QOpenGLShaderProgram>
-#include <QtGui/QOpenGLVertexArrayObject>
-#include <QtGui/QOpenGLContext>
-#include <QtGui/QOpenGLFunctions>
-
-#ifndef GL_TEXTURE_EXTERNAL_OES
-#define GL_TEXTURE_EXTERNAL_OES           0x8D65
-#endif
-
-QT_BEGIN_NAMESPACE
-
-/*!
-    \class QOpenGLTextureBlitter
-    \brief The QOpenGLTextureBlitter class provides a convenient way to draw textured quads via OpenGL.
-    \since 5.8
-    \ingroup painting-3D
-    \inmodule QtGui
-
-    Drawing textured quads, in order to get the contents of a texture
-    onto the screen, is a common operation when developing 2D user
-    interfaces. QOpenGLTextureBlitter provides a convenience class to
-    avoid repeating vertex data, shader sources, buffer and program
-    management and matrix calculations.
-
-    For example, a QOpenGLWidget subclass can do the following to draw
-    the contents rendered into a framebuffer at the pixel position \c{(x, y)}:
-
-    \code
-    void OpenGLWidget::initializeGL()
-    {
-        m_blitter.create();
-        m_fbo = new QOpenGLFramebufferObject(size);
-    }
-
-    void OpenGLWidget::paintGL()
-    {
-        m_fbo->bind();
-        // update offscreen content
-        m_fbo->release();
-
-        m_blitter.bind();
-        const QRect targetRect(QPoint(x, y), m_fbo->size());
-        const QMatrix4x4 target = QOpenGLTextureBlitter::targetTransform(targetRect, QRect(QPoint(0, 0), m_fbo->size()));
-        m_blitter.blit(m_fbo->texture(), target, QOpenGLTextureBlitter::OriginBottomLeft);
-        m_blitter.release();
-    }
-    \endcode
-
-    The blitter implements GLSL shaders both for GLSL 1.00 (suitable
-    for OpenGL (ES) 2.x and compatibility profiles of newer OpenGL
-    versions) and version 150 (suitable for core profile contexts with
-    OpenGL 3.2 and newer).
- */
-
-static const char vertex_shader150[] =
-    "#version 150 core\n"
-    "in vec3 vertexCoord;"
-    "in vec2 textureCoord;"
-    "out vec2 uv;"
-    "uniform mat4 vertexTransform;"
-    "uniform mat3 textureTransform;"
-    "void main() {"
-    "   uv = (textureTransform * vec3(textureCoord,1.0)).xy;"
-    "   gl_Position = vertexTransform * vec4(vertexCoord,1.0);"
-    "}";
-
-static const char fragment_shader150[] =
-    "#version 150 core\n"
-    "in vec2 uv;"
-    "out vec4 fragcolor;"
-    "uniform sampler2D textureSampler;"
-    "uniform bool swizzle;"
-    "uniform float opacity;"
-    "void main() {"
-    "   vec4 tmpFragColor = texture(textureSampler, uv);"
-    "   tmpFragColor.a *= opacity;"
-    "   fragcolor = swizzle ? tmpFragColor.bgra : tmpFragColor;"
-    "}";
-
-static const char vertex_shader[] =
-    "attribute highp vec3 vertexCoord;"
-    "attribute highp vec2 textureCoord;"
-    "varying highp vec2 uv;"
-    "uniform highp mat4 vertexTransform;"
-    "uniform highp mat3 textureTransform;"
-    "void main() {"
-    "   uv = (textureTransform * vec3(textureCoord,1.0)).xy;"
-    "   gl_Position = vertexTransform * vec4(vertexCoord,1.0);"
-    "}";
-
-static const char fragment_shader[] =
-    "varying highp vec2 uv;"
-    "uniform sampler2D textureSampler;"
-    "uniform bool swizzle;"
-    "uniform highp float opacity;"
-    "void main() {"
-    "   highp vec4 tmpFragColor = texture2D(textureSampler,uv);"
-    "   tmpFragColor.a *= opacity;"
-    "   gl_FragColor = swizzle ? tmpFragColor.bgra : tmpFragColor;"
-    "}";
-
-static const char fragment_shader_external_oes[] =
-    "#extension GL_OES_EGL_image_external : require\n"
-    "varying highp vec2 uv;"
-    "uniform samplerExternalOES textureSampler;\n"
-    "uniform bool swizzle;"
-    "uniform highp float opacity;"
-    "void main() {"
-    "   highp vec4 tmpFragColor = texture2D(textureSampler, uv);"
-    "   tmpFragColor.a *= opacity;"
-    "   gl_FragColor = swizzle ? tmpFragColor.bgra : tmpFragColor;"
-    "}";
-
-static const GLfloat vertex_buffer_data[] = {
-        -1,-1, 0,
-        -1, 1, 0,
-         1,-1, 0,
-        -1, 1, 0,
-         1,-1, 0,
-         1, 1, 0
-};
-
-static const GLfloat texture_buffer_data[] = {
-        0, 0,
-        0, 1,
-        1, 0,
-        0, 1,
-        1, 0,
-        1, 1
-};
-
-class TextureBinder
-{
-public:
-    TextureBinder(GLenum target, GLuint textureId) : m_target(target)
-    {
-        QOpenGLContext::currentContext()->functions()->glBindTexture(m_target, textureId);
-    }
-    ~TextureBinder()
-    {
-        QOpenGLContext::currentContext()->functions()->glBindTexture(m_target, 0);
-    }
-
-private:
-    GLenum m_target;
-};
-
-class QOpenGLTextureBlitterPrivate
-{
-public:
-    enum TextureMatrixUniform {
-        User,
-        Identity,
-        IdentityFlipped
-    };
-
-    enum ProgramIndex {
-        TEXTURE_2D,
-        TEXTURE_EXTERNAL_OES
-    };
-
-    QOpenGLTextureBlitterPrivate() :
-        swizzle(false),
-        opacity(1.0f),
-        vao(new QOpenGLVertexArrayObject),
-        currentTarget(TEXTURE_2D)
-    { }
-
-    bool buildProgram(ProgramIndex idx, const char *vs, const char *fs);
-
-    void blit(GLuint texture, const QMatrix4x4 &vertexTransform, const QMatrix3x3 &textureTransform);
-    void blit(GLuint texture, const QMatrix4x4 &vertexTransform, QOpenGLTextureBlitter::Origin origin);
-
-    void prepareProgram(const QMatrix4x4 &vertexTransform);
-
-    QOpenGLBuffer vertexBuffer;
-    QOpenGLBuffer textureBuffer;
-    struct Program {
-        Program() :
-            vertexCoordAttribPos(0),
-            vertexTransformUniformPos(0),
-            textureCoordAttribPos(0),
-            textureTransformUniformPos(0),
-            swizzleUniformPos(0),
-            opacityUniformPos(0),
-            swizzle(false),
-            opacity(0.0f),
-            textureMatrixUniformState(User)
-        { }
-        QScopedPointer<QOpenGLShaderProgram> glProgram;
-        GLuint vertexCoordAttribPos;
-        GLuint vertexTransformUniformPos;
-        GLuint textureCoordAttribPos;
-        GLuint textureTransformUniformPos;
-        GLuint swizzleUniformPos;
-        GLuint opacityUniformPos;
-        bool swizzle;
-        float opacity;
-        TextureMatrixUniform textureMatrixUniformState;
-    } programs[2];
-    bool swizzle;
-    float opacity;
-    QScopedPointer<QOpenGLVertexArrayObject> vao;
-    GLenum currentTarget;
-};
-
-static inline QOpenGLTextureBlitterPrivate::ProgramIndex targetToProgramIndex(GLenum target)
-{
-    switch (target) {
-    case GL_TEXTURE_2D:
-        return QOpenGLTextureBlitterPrivate::TEXTURE_2D;
-    case GL_TEXTURE_EXTERNAL_OES:
-        return QOpenGLTextureBlitterPrivate::TEXTURE_EXTERNAL_OES;
-    default:
-        qWarning("Unsupported texture target 0x%x", target);
-        return QOpenGLTextureBlitterPrivate::TEXTURE_2D;
-    }
-}
-
-void QOpenGLTextureBlitterPrivate::prepareProgram(const QMatrix4x4 &vertexTransform)
-{
-    Program *program = &programs[targetToProgramIndex(currentTarget)];
-
-    vertexBuffer.bind();
-    program->glProgram->setAttributeBuffer(program->vertexCoordAttribPos, GL_FLOAT, 0, 3, 0);
-    program->glProgram->enableAttributeArray(program->vertexCoordAttribPos);
-    vertexBuffer.release();
-
-    program->glProgram->setUniformValue(program->vertexTransformUniformPos, vertexTransform);
-
-    textureBuffer.bind();
-    program->glProgram->setAttributeBuffer(program->textureCoordAttribPos, GL_FLOAT, 0, 2, 0);
-    program->glProgram->enableAttributeArray(program->textureCoordAttribPos);
-    textureBuffer.release();
-
-    if (swizzle != program->swizzle) {
-        program->glProgram->setUniformValue(program->swizzleUniformPos, swizzle);
-        program->swizzle = swizzle;
-    }
-
-    if (opacity != program->opacity) {
-        program->glProgram->setUniformValue(program->opacityUniformPos, opacity);
-        program->opacity = opacity;
-    }
-}
-
-void QOpenGLTextureBlitterPrivate::blit(GLuint texture,
-                                        const QMatrix4x4 &vertexTransform,
-                                        const QMatrix3x3 &textureTransform)
-{
-    TextureBinder binder(currentTarget, texture);
-    prepareProgram(vertexTransform);
-
-    Program *program = &programs[targetToProgramIndex(currentTarget)];
-    program->glProgram->setUniformValue(program->textureTransformUniformPos, textureTransform);
-    program->textureMatrixUniformState = User;
-
-    QOpenGLContext::currentContext()->functions()->glDrawArrays(GL_TRIANGLES, 0, 6);
-}
-
-void QOpenGLTextureBlitterPrivate::blit(GLuint texture,
-                                        const QMatrix4x4 &vertexTransform,
-                                        QOpenGLTextureBlitter::Origin origin)
-{
-    TextureBinder binder(currentTarget, texture);
-    prepareProgram(vertexTransform);
-
-    Program *program = &programs[targetToProgramIndex(currentTarget)];
-    if (origin == QOpenGLTextureBlitter::OriginTopLeft) {
-        if (program->textureMatrixUniformState != IdentityFlipped) {
-            QMatrix3x3 flipped;
-            flipped(1,1) = -1;
-            flipped(1,2) = 1;
-            program->glProgram->setUniformValue(program->textureTransformUniformPos, flipped);
-            program->textureMatrixUniformState = IdentityFlipped;
-        }
-    } else if (program->textureMatrixUniformState != Identity) {
-        program->glProgram->setUniformValue(program->textureTransformUniformPos, QMatrix3x3());
-        program->textureMatrixUniformState = Identity;
-    }
-
-    QOpenGLContext::currentContext()->functions()->glDrawArrays(GL_TRIANGLES, 0, 6);
-}
-
-bool QOpenGLTextureBlitterPrivate::buildProgram(ProgramIndex idx, const char *vs, const char *fs)
-{
-    Program *p = &programs[idx];
-
-    p->glProgram.reset(new QOpenGLShaderProgram);
-
-    p->glProgram->addCacheableShaderFromSourceCode(QOpenGLShader::Vertex, vs);
-    p->glProgram->addCacheableShaderFromSourceCode(QOpenGLShader::Fragment, fs);
-    p->glProgram->link();
-    if (!p->glProgram->isLinked()) {
-        qWarning() << "Could not link shader program:\n" << p->glProgram->log();
-        return false;
-    }
-
-    p->glProgram->bind();
-
-    p->vertexCoordAttribPos = p->glProgram->attributeLocation("vertexCoord");
-    p->vertexTransformUniformPos = p->glProgram->uniformLocation("vertexTransform");
-    p->textureCoordAttribPos = p->glProgram->attributeLocation("textureCoord");
-    p->textureTransformUniformPos = p->glProgram->uniformLocation("textureTransform");
-    p->swizzleUniformPos = p->glProgram->uniformLocation("swizzle");
-    p->opacityUniformPos = p->glProgram->uniformLocation("opacity");
-
-    p->glProgram->setUniformValue(p->swizzleUniformPos, false);
-
-    // minmize state left set after a create()
-    p->glProgram->release();
-
-    return true;
-}
-
-/*!
-    Constructs a new QOpenGLTextureBlitter instance.
-
-    \note no graphics resources are initialized in the
-    constructor. This makes it safe to place plain
-    QOpenGLTextureBlitter members into classes because the actual
-    initialization that depends on the OpenGL context happens only in
-    create().
- */
-QOpenGLTextureBlitter::QOpenGLTextureBlitter()
-    : d_ptr(new QOpenGLTextureBlitterPrivate)
-{
-}
-
-/*!
-    Destructs the instance.
-
-    \note When the OpenGL context - or a context sharing resources
-    with it - that was current when calling create() is not current,
-    graphics resources will not be released. Therefore, it is
-    recommended to call destroy() manually instead of relying on the
-    destructor to perform OpenGL resource cleanup.
- */
-QOpenGLTextureBlitter::~QOpenGLTextureBlitter()
-{
-    destroy();
-}
-
-/*!
-    Initializes the graphics resources used by the blitter.
-
-    \return \c true if successful, \c false if there was a
-    failure. Failures can occur when there is no OpenGL context
-    current on the current thread, or when shader compilation fails
-    for some reason.
-
-    \sa isCreated(), destroy()
- */
-bool QOpenGLTextureBlitter::create()
-{
-    QOpenGLContext *currentContext = QOpenGLContext::currentContext();
-    if (!currentContext)
-        return false;
-
-    Q_D(QOpenGLTextureBlitter);
-
-    if (d->programs[QOpenGLTextureBlitterPrivate::TEXTURE_2D].glProgram)
-        return true;
-
-    QSurfaceFormat format = currentContext->format();
-    if (format.profile() == QSurfaceFormat::CoreProfile && format.version() >= qMakePair(3,2)) {
-        if (!d->buildProgram(QOpenGLTextureBlitterPrivate::TEXTURE_2D, vertex_shader150, fragment_shader150))
-            return false;
-    } else {
-        if (!d->buildProgram(QOpenGLTextureBlitterPrivate::TEXTURE_2D, vertex_shader, fragment_shader))
-            return false;
-        if (supportsExternalOESTarget())
-            if (!d->buildProgram(QOpenGLTextureBlitterPrivate::TEXTURE_EXTERNAL_OES, vertex_shader, fragment_shader_external_oes))
-                return false;
-    }
-
-    // Create and bind the VAO, if supported.
-    QOpenGLVertexArrayObject::Binder vaoBinder(d->vao.data());
-
-    d->vertexBuffer.create();
-    d->vertexBuffer.bind();
-    d->vertexBuffer.allocate(vertex_buffer_data, sizeof(vertex_buffer_data));
-    d->vertexBuffer.release();
-
-    d->textureBuffer.create();
-    d->textureBuffer.bind();
-    d->textureBuffer.allocate(texture_buffer_data, sizeof(texture_buffer_data));
-    d->textureBuffer.release();
-
-    return true;
-}
-
-/*!
-    \return \c true if create() was called and succeeded. \c false otherwise.
-
-    \sa create(), destroy()
- */
-bool QOpenGLTextureBlitter::isCreated() const
-{
-    Q_D(const QOpenGLTextureBlitter);
-    return d->programs[QOpenGLTextureBlitterPrivate::TEXTURE_2D].glProgram;
-}
-
-/*!
-    Frees all graphics resources held by the blitter. Assumes that
-    the OpenGL context, or another context sharing resources with it,
-    that was current on the thread when invoking create() is current.
-
-    The function has no effect when the blitter is not in created state.
-
-    \sa create()
- */
-void QOpenGLTextureBlitter::destroy()
-{
-    if (!isCreated())
-        return;
-    Q_D(QOpenGLTextureBlitter);
-    d->programs[QOpenGLTextureBlitterPrivate::TEXTURE_2D].glProgram.reset();
-    d->programs[QOpenGLTextureBlitterPrivate::TEXTURE_EXTERNAL_OES].glProgram.reset();
-    d->vertexBuffer.destroy();
-    d->textureBuffer.destroy();
-    d->vao.reset();
-}
-
-/*!
-    \return \c true when bind() accepts \c GL_TEXTURE_EXTERNAL_OES as
-    its target argument.
-
-    \sa bind(), blit()
- */
-bool QOpenGLTextureBlitter::supportsExternalOESTarget() const
-{
-    QOpenGLContext *ctx = QOpenGLContext::currentContext();
-    return ctx && ctx->isOpenGLES() && ctx->hasExtension("GL_OES_EGL_image_external");
-}
-
-/*!
-    Binds the graphics resources used by the blitter. This must be
-    called before calling blit(). Code modifying the OpenGL state
-    should be avoided between the call to bind() and blit() because
-    otherwise conflicts may arise.
-
-    \a target is the texture target for the source texture and must be
-    either \c GL_TEXTURE_2D or \c GL_OES_EGL_image_external.
-
-    \sa release(), blit()
- */
-void QOpenGLTextureBlitter::bind(GLenum target)
-{
-    Q_D(QOpenGLTextureBlitter);
-
-    if (d->vao->isCreated())
-        d->vao->bind();
-
-    d->currentTarget = target;
-    QOpenGLTextureBlitterPrivate::Program *p = &d->programs[targetToProgramIndex(target)];
-    p->glProgram->bind();
-
-    d->vertexBuffer.bind();
-    p->glProgram->setAttributeBuffer(p->vertexCoordAttribPos, GL_FLOAT, 0, 3, 0);
-    p->glProgram->enableAttributeArray(p->vertexCoordAttribPos);
-    d->vertexBuffer.release();
-
-    d->textureBuffer.bind();
-    p->glProgram->setAttributeBuffer(p->textureCoordAttribPos, GL_FLOAT, 0, 2, 0);
-    p->glProgram->enableAttributeArray(p->textureCoordAttribPos);
-    d->textureBuffer.release();
-}
-
-/*!
-    Unbinds the graphics resources used by the blitter.
-
-    \sa bind()
- */
-void QOpenGLTextureBlitter::release()
-{
-    Q_D(QOpenGLTextureBlitter);
-    d->programs[targetToProgramIndex(d->currentTarget)].glProgram->release();
-    if (d->vao->isCreated())
-        d->vao->release();
-}
-
-/*!
-    Sets whether swizzling is enabled for the red and blue color channels to
-    \a swizzle. An BGRA to RGBA conversion (occurring in the shader on
-    the GPU, instead of a slow CPU-side transformation) can be useful
-    when the source texture contains data from a QImage with a format
-    like QImage::Format_ARGB32 which maps to BGRA on little endian
-    systems.
-
-    By default the red-blue swizzle is disabled since this is what a
-    texture attached to an framebuffer object or a texture based on a
-    byte ordered QImage format (like QImage::Format_RGBA8888) needs.
- */
-void QOpenGLTextureBlitter::setRedBlueSwizzle(bool swizzle)
-{
-    Q_D(QOpenGLTextureBlitter);
-    d->swizzle = swizzle;
-}
-
-/*!
-    Changes the opacity to \a opacity. The default opacity is 1.0.
-
-    \note the blitter does not alter the blend state. It is up to the
-    caller of blit() to ensure the correct blend settings are active.
-
- */
-void QOpenGLTextureBlitter::setOpacity(float opacity)
-{
-    Q_D(QOpenGLTextureBlitter);
-    d->opacity = opacity;
-}
-
-/*!
-    \enum QOpenGLTextureBlitter::Origin
-
-    \value OriginBottomLeft Indicates that the data in the texture
-    follows the OpenGL convention of coordinate systems, meaning Y is
-    running from bottom to top.
-
-    \value OriginTopLeft Indicates that the data in the texture has Y
-    running from top to bottom, which is typical with regular,
-    unflipped image data.
-
-    \sa blit()
- */
-
-/*!
-    Performs the blit with the source texture \a texture.
-
-    \a targetTransform specifies the transformation applied. This is
-    usually generated by the targetTransform() helper function.
-
-    \a sourceOrigin specifies if the image data needs flipping. When
-    \a texture corresponds to a texture attached to an FBO pass
-    OriginBottomLeft. On the other hand, when \a texture is based on
-    unflipped image data, pass OriginTopLeft. This is more efficient
-    than using QImage::mirrored().
-
-    \sa targetTransform(), Origin, bind()
- */
-void QOpenGLTextureBlitter::blit(GLuint texture,
-                                 const QMatrix4x4 &targetTransform,
-                                 Origin sourceOrigin)
-{
-    Q_D(QOpenGLTextureBlitter);
-    d->blit(texture,targetTransform, sourceOrigin);
-}
-
-/*!
-    Performs the blit with the source texture \a texture.
-
-    \a targetTransform specifies the transformation applied. This is
-    usually generated by the targetTransform() helper function.
-
-    \a sourceTransform specifies the transformation applied to the
-    source. This allows using only a sub-rect of the source
-    texture. This is usually generated by the sourceTransform() helper
-    function.
-
-    \sa sourceTransform(), targetTransform(), Origin, bind()
- */
-void QOpenGLTextureBlitter::blit(GLuint texture,
-                                 const QMatrix4x4 &targetTransform,
-                                 const QMatrix3x3 &sourceTransform)
-{
-    Q_D(QOpenGLTextureBlitter);
-    d->blit(texture, targetTransform, sourceTransform);
-}
-
-/*!
-    Calculates a target transform suitable for blit().
-
-    \a target is the target rectangle in pixels. \a viewport describes
-    the source dimensions and will in most cases be set to (0, 0,
-    image width, image height).
-
-    For unscaled output the size of \a target and \a viewport should
-    match.
-
-    \sa blit()
- */
-QMatrix4x4 QOpenGLTextureBlitter::targetTransform(const QRectF &target,
-                                                  const QRect &viewport)
-{
-    qreal x_scale = target.width() / viewport.width();
-    qreal y_scale = target.height() / viewport.height();
-
-    const QPointF relative_to_viewport = target.topLeft() - viewport.topLeft();
-    qreal x_translate = x_scale - 1 + ((relative_to_viewport.x() / viewport.width()) * 2);
-    qreal y_translate = -y_scale + 1 - ((relative_to_viewport.y() / viewport.height()) * 2);
-
-    QMatrix4x4 matrix;
-    matrix(0,3) = x_translate;
-    matrix(1,3) = y_translate;
-
-    matrix(0,0) = x_scale;
-    matrix(1,1) = y_scale;
-
-    return matrix;
-}
-
-/*!
-    Calculates a 3x3 matrix suitable as the input to blit(). This is
-    used when only a part of the texture is to be used in the blit.
-
-    \a subTexture is the desired source rectangle in pixels, \a
-    textureSize is the full width and height of the texture data.  \a
-    origin specifies the orientation of the image data when it comes
-    to the Y axis.
-
-    \sa blit(), Origin
- */
-QMatrix3x3 QOpenGLTextureBlitter::sourceTransform(const QRectF &subTexture,
-                                                  const QSize &textureSize,
-                                                  Origin origin)
-{
-    qreal x_scale = subTexture.width() / textureSize.width();
-    qreal y_scale = subTexture.height() / textureSize.height();
-
-    const QPointF topLeft = subTexture.topLeft();
-    qreal x_translate = topLeft.x() / textureSize.width();
-    qreal y_translate = topLeft.y() / textureSize.height();
-
-    if (origin == OriginTopLeft) {
-        y_scale = -y_scale;
-        y_translate = 1 - y_translate;
-    }
-
-    QMatrix3x3 matrix;
-    matrix(0,2) = x_translate;
-    matrix(1,2) = y_translate;
-
-    matrix(0,0) = x_scale;
-    matrix(1,1) = y_scale;
-
-    return matrix;
-}
-
-QT_END_NAMESPACE
diff --git a/src/gui/opengl/qopengltextureblitter.h b/src/gui/opengl/qopengltextureblitter.h
deleted file mode 100644
index 2f7c6b1a0a..0000000000
--- a/src/gui/opengl/qopengltextureblitter.h
+++ /dev/null
@@ -1,94 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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 QOPENGLTEXTUREBLITTER_H
-#define QOPENGLTEXTUREBLITTER_H
-
-#include <QtGui/qtguiglobal.h>
-
-#ifndef QT_NO_OPENGL
-
-#include <QtGui/qopengl.h>
-#include <QtGui/QMatrix3x3>
-#include <QtGui/QMatrix4x4>
-
-QT_BEGIN_NAMESPACE
-
-class QOpenGLTextureBlitterPrivate;
-
-class Q_GUI_EXPORT QOpenGLTextureBlitter
-{
-public:
-    QOpenGLTextureBlitter();
-    ~QOpenGLTextureBlitter();
-
-    enum Origin {
-        OriginBottomLeft,
-        OriginTopLeft
-    };
-
-    bool create();
-    bool isCreated() const;
-    void destroy();
-
-    bool supportsExternalOESTarget() const;
-
-    void bind(GLenum target = GL_TEXTURE_2D);
-    void release();
-
-    void setRedBlueSwizzle(bool swizzle);
-    void setOpacity(float opacity);
-
-    void blit(GLuint texture, const QMatrix4x4 &targetTransform, Origin sourceOrigin);
-    void blit(GLuint texture, const QMatrix4x4 &targetTransform, const QMatrix3x3 &sourceTransform);
-
-    static QMatrix4x4 targetTransform(const QRectF &target, const QRect &viewport);
-    static QMatrix3x3 sourceTransform(const QRectF &subTexture, const QSize &textureSize, Origin origin);
-
-private:
-    Q_DISABLE_COPY(QOpenGLTextureBlitter)
-    Q_DECLARE_PRIVATE(QOpenGLTextureBlitter)
-    QScopedPointer<QOpenGLTextureBlitterPrivate> d_ptr;
-};
-
-QT_END_NAMESPACE
-
-#endif
-
-#endif //QOPENGLTEXTUREBLITTER_H
diff --git a/src/gui/opengl/qopengltexturecache.cpp b/src/gui/opengl/qopengltexturecache.cpp
deleted file mode 100644
index ef07dbe109..0000000000
--- a/src/gui/opengl/qopengltexturecache.cpp
+++ /dev/null
@@ -1,198 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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 "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/gui/opengl/qopengltexturecache_p.h b/src/gui/opengl/qopengltexturecache_p.h
deleted file mode 100644
index 88ef06e744..0000000000
--- a/src/gui/opengl/qopengltexturecache_p.h
+++ /dev/null
@@ -1,108 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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 <QtGui/private/qtguiglobal_p.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_GUI_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/gui/opengl/qopengltextureglyphcache.cpp b/src/gui/opengl/qopengltextureglyphcache.cpp
deleted file mode 100644
index 41027d26e0..0000000000
--- a/src/gui/opengl/qopengltextureglyphcache.cpp
+++ /dev/null
@@ -1,485 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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 "qopenglpaintengine_p.h"
-#include "private/qopenglengineshadersource_p.h"
-#include "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/gui/opengl/qopengltextureglyphcache_p.h b/src/gui/opengl/qopengltextureglyphcache_p.h
deleted file mode 100644
index 4bea4a463a..0000000000
--- a/src/gui/opengl/qopengltextureglyphcache_p.h
+++ /dev/null
@@ -1,181 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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 <QtGui/private/qtguiglobal_p.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_GUI_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/gui/opengl/qopengltexturehelper.cpp b/src/gui/opengl/qopengltexturehelper.cpp
deleted file mode 100644
index 6709edc4e2..0000000000
--- a/src/gui/opengl/qopengltexturehelper.cpp
+++ /dev/null
@@ -1,589 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB).
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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 "qopengltexturehelper_p.h"
-
-#include <QOpenGLContext>
-#include <private/qopenglextensions_p.h>
-
-QT_BEGIN_NAMESPACE
-
-QOpenGLTextureHelper::QOpenGLTextureHelper(QOpenGLContext *context)
-{
-    functions = context->functions();
-    // Resolve EXT_direct_state_access entry points if present.
-
-    // However, disable it on some systems where DSA is known to be unreliable.
-    bool allowDSA = true;
-    const char *renderer = reinterpret_cast<const char *>(context->functions()->glGetString(GL_RENDERER));
-    // QTBUG-40653, QTBUG-44988
-    if (renderer && strstr(renderer, "AMD Radeon HD"))
-        allowDSA = false;
-
-    if (allowDSA && !context->isOpenGLES()
-        && context->hasExtension(QByteArrayLiteral("GL_EXT_direct_state_access"))) {
-        TextureParameteriEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLenum , GLint )>(context->getProcAddress("glTextureParameteriEXT"));
-        TextureParameterivEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLenum , const GLint *)>(context->getProcAddress("glTextureParameterivEXT"));
-        TextureParameterfEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLenum , GLfloat )>(context->getProcAddress("glTextureParameterfEXT"));
-        TextureParameterfvEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLenum , const GLfloat *)>(context->getProcAddress("glTextureParameterfvEXT"));
-        GenerateTextureMipmapEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum )>(context->getProcAddress("glGenerateTextureMipmapEXT"));
-        TextureStorage3DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLsizei , GLenum , GLsizei , GLsizei , GLsizei )>(context->getProcAddress("glTextureStorage3DEXT"));
-        TextureStorage2DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLsizei , GLenum , GLsizei , GLsizei )>(context->getProcAddress("glTextureStorage2DEXT"));
-        TextureStorage1DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLsizei , GLenum , GLsizei )>(context->getProcAddress("glTextureStorage1DEXT"));
-        TextureStorage3DMultisampleEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLsizei , GLenum , GLsizei , GLsizei , GLsizei , GLboolean )>(context->getProcAddress("glTextureStorage3DMultisampleEXT"));
-        TextureStorage2DMultisampleEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLsizei , GLenum , GLsizei , GLsizei , GLboolean )>(context->getProcAddress("glTextureStorage2DMultisampleEXT"));
-        TextureImage3DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , GLenum , GLsizei , GLsizei , GLsizei , GLint , GLenum , GLenum , const GLvoid *)>(context->getProcAddress("glTextureImage3DEXT"));
-        TextureImage2DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , GLenum , GLsizei , GLsizei , GLint , GLenum , GLenum , const GLvoid *)>(context->getProcAddress("glTextureImage2DEXT"));
-        TextureImage1DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , GLenum , GLsizei , GLint , GLenum , GLenum , const GLvoid *)>(context->getProcAddress("glTextureImage1DEXT"));
-        TextureSubImage3DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , GLint , GLint , GLint , GLsizei , GLsizei , GLsizei , GLenum , GLenum , const GLvoid *)>(context->getProcAddress("glTextureSubImage3DEXT"));
-        TextureSubImage2DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , GLint , GLint , GLsizei , GLsizei , GLenum , GLenum , const GLvoid *)>(context->getProcAddress("glTextureSubImage2DEXT"));
-        TextureSubImage1DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , GLint , GLsizei , GLenum , GLenum , const GLvoid *)>(context->getProcAddress("glTextureSubImage1DEXT"));
-        CompressedTextureSubImage1DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , GLint , GLsizei , GLenum , GLsizei , const GLvoid *)>(context->getProcAddress("glCompressedTextureSubImage1DEXT"));
-        CompressedTextureSubImage2DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , GLint , GLint , GLsizei , GLsizei , GLenum , GLsizei , const GLvoid *)>(context->getProcAddress("glCompressedTextureSubImage2DEXT"));
-        CompressedTextureSubImage3DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , GLint , GLint , GLint , GLsizei , GLsizei , GLsizei , GLenum , GLsizei , const GLvoid *)>(context->getProcAddress("glCompressedTextureSubImage3DEXT"));
-        CompressedTextureImage1DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , GLenum , GLsizei , GLint , GLsizei , const GLvoid *)>(context->getProcAddress("glCompressedTextureImage1DEXT"));
-        CompressedTextureImage2DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , GLenum , GLsizei , GLsizei , GLint , GLsizei , const GLvoid *)>(context->getProcAddress("glCompressedTextureImage2DEXT"));
-        CompressedTextureImage3DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , GLenum , GLsizei , GLsizei , GLsizei , GLint , GLsizei , const GLvoid *)>(context->getProcAddress("glCompressedTextureImage3DEXT"));
-
-        // Use the real DSA functions
-        TextureParameteri = &QOpenGLTextureHelper::dsa_TextureParameteri;
-        TextureParameteriv = &QOpenGLTextureHelper::dsa_TextureParameteriv;
-        TextureParameterf = &QOpenGLTextureHelper::dsa_TextureParameterf;
-        TextureParameterfv = &QOpenGLTextureHelper::dsa_TextureParameterfv;
-        GenerateTextureMipmap = &QOpenGLTextureHelper::dsa_GenerateTextureMipmap;
-        TextureStorage3D = &QOpenGLTextureHelper::dsa_TextureStorage3D;
-        TextureStorage2D = &QOpenGLTextureHelper::dsa_TextureStorage2D;
-        TextureStorage1D = &QOpenGLTextureHelper::dsa_TextureStorage1D;
-        TextureStorage3DMultisample = &QOpenGLTextureHelper::dsa_TextureStorage3DMultisample;
-        TextureStorage2DMultisample = &QOpenGLTextureHelper::dsa_TextureStorage2DMultisample;
-        TextureImage3D = &QOpenGLTextureHelper::dsa_TextureImage3D;
-        TextureImage2D = &QOpenGLTextureHelper::dsa_TextureImage2D;
-        TextureImage1D = &QOpenGLTextureHelper::dsa_TextureImage1D;
-        TextureSubImage3D = &QOpenGLTextureHelper::dsa_TextureSubImage3D;
-        TextureSubImage2D = &QOpenGLTextureHelper::dsa_TextureSubImage2D;
-        TextureSubImage1D = &QOpenGLTextureHelper::dsa_TextureSubImage1D;
-        CompressedTextureSubImage1D = &QOpenGLTextureHelper::dsa_CompressedTextureSubImage1D;
-        CompressedTextureSubImage2D = &QOpenGLTextureHelper::dsa_CompressedTextureSubImage2D;
-        CompressedTextureSubImage3D = &QOpenGLTextureHelper::dsa_CompressedTextureSubImage3D;
-        CompressedTextureImage1D = &QOpenGLTextureHelper::dsa_CompressedTextureImage1D;
-        CompressedTextureImage2D = &QOpenGLTextureHelper::dsa_CompressedTextureImage2D;
-        CompressedTextureImage3D = &QOpenGLTextureHelper::dsa_CompressedTextureImage3D;
-    } else {
-        // Use our own DSA emulation
-        TextureParameteri = &QOpenGLTextureHelper::qt_TextureParameteri;
-        TextureParameteriv = &QOpenGLTextureHelper::qt_TextureParameteriv;
-        TextureParameterf = &QOpenGLTextureHelper::qt_TextureParameterf;
-        TextureParameterfv = &QOpenGLTextureHelper::qt_TextureParameterfv;
-        GenerateTextureMipmap = &QOpenGLTextureHelper::qt_GenerateTextureMipmap;
-        TextureStorage3D = &QOpenGLTextureHelper::qt_TextureStorage3D;
-        TextureStorage2D = &QOpenGLTextureHelper::qt_TextureStorage2D;
-        TextureStorage1D = &QOpenGLTextureHelper::qt_TextureStorage1D;
-        TextureStorage3DMultisample = &QOpenGLTextureHelper::qt_TextureStorage3DMultisample;
-        TextureStorage2DMultisample = &QOpenGLTextureHelper::qt_TextureStorage2DMultisample;
-        TextureImage3D = &QOpenGLTextureHelper::qt_TextureImage3D;
-        TextureImage2D = &QOpenGLTextureHelper::qt_TextureImage2D;
-        TextureImage1D = &QOpenGLTextureHelper::qt_TextureImage1D;
-        TextureSubImage3D = &QOpenGLTextureHelper::qt_TextureSubImage3D;
-        TextureSubImage2D = &QOpenGLTextureHelper::qt_TextureSubImage2D;
-        TextureSubImage1D = &QOpenGLTextureHelper::qt_TextureSubImage1D;
-        CompressedTextureSubImage1D = &QOpenGLTextureHelper::qt_CompressedTextureSubImage1D;
-        CompressedTextureSubImage2D = &QOpenGLTextureHelper::qt_CompressedTextureSubImage2D;
-        CompressedTextureSubImage3D = &QOpenGLTextureHelper::qt_CompressedTextureSubImage3D;
-        CompressedTextureImage1D = &QOpenGLTextureHelper::qt_CompressedTextureImage1D;
-        CompressedTextureImage2D = &QOpenGLTextureHelper::qt_CompressedTextureImage2D;
-        CompressedTextureImage3D = &QOpenGLTextureHelper::qt_CompressedTextureImage3D;
-    }
-
-    // Some DSA functions are part of NV_texture_multisample instead
-    if (!context->isOpenGLES()
-        && context->hasExtension(QByteArrayLiteral("GL_NV_texture_multisample"))) {
-        TextureImage3DMultisampleNV = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLsizei , GLint , GLsizei , GLsizei , GLsizei , GLboolean )>(context->getProcAddress("glTextureImage3DMultisampleNV"));
-        TextureImage2DMultisampleNV = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLsizei , GLint , GLsizei , GLsizei , GLboolean )>(context->getProcAddress("glTextureImage2DMultisampleNV"));
-
-        TextureImage3DMultisample = &QOpenGLTextureHelper::dsa_TextureImage3DMultisample;
-        TextureImage2DMultisample = &QOpenGLTextureHelper::dsa_TextureImage2DMultisample;
-    } else {
-        TextureImage3DMultisample = &QOpenGLTextureHelper::qt_TextureImage3DMultisample;
-        TextureImage2DMultisample = &QOpenGLTextureHelper::qt_TextureImage2DMultisample;
-    }
-
-#if defined(QT_OPENGL_ES_2)
-    // Here we are targeting OpenGL ES 2.0+ only. This is likely using EGL, where,
-    // similarly to WGL, non-extension functions (i.e. any function that is part of the
-    // GLES spec) *may* not be queried via eglGetProcAddress.
-
-    // OpenGL 1.0
-    TexImage1D = 0;
-
-    // OpenGL 1.1
-    TexSubImage1D = 0;
-
-    // OpenGL 1.3
-    GetCompressedTexImage = 0;
-    CompressedTexSubImage1D = 0;
-    CompressedTexSubImage2D = ::glCompressedTexSubImage2D;
-    CompressedTexImage1D = 0;
-    CompressedTexImage2D = ::glCompressedTexImage2D;
-    ActiveTexture = ::glActiveTexture;
-
-    // OpenGL 3.0
-    GenerateMipmap = ::glGenerateMipmap;
-
-    // OpenGL 3.2
-    TexImage3DMultisample = 0;
-    TexImage2DMultisample = 0;
-
-    // OpenGL 4.2
-    QOpenGLContext *ctx = QOpenGLContext::currentContext();
-    if (ctx->format().majorVersion() >= 3) {
-        // OpenGL ES 3.0+ has immutable storage for 2D and 3D at least.
-        QOpenGLExtraFunctionsPrivate *extra = static_cast<QOpenGLExtensions *>(context->extraFunctions())->d();
-        TexStorage3D = extra->f.TexStorage3D;
-        TexStorage2D = extra->f.TexStorage2D;
-    } else {
-        TexStorage3D = 0;
-        TexStorage2D = 0;
-    }
-    TexStorage1D = 0;
-
-    // OpenGL 4.3
-    TexStorage3DMultisample = 0;
-    TexStorage2DMultisample = 0;
-    TexBufferRange = 0;
-    TextureView = 0;
-
-    // OpenGL ES 3.1+ has TexStorage2DMultisample
-    if (ctx->format().version() >= qMakePair(3, 1)) {
-        QOpenGLExtraFunctionsPrivate *extra = static_cast<QOpenGLExtensions *>(context->extraFunctions())->d();
-        TexStorage2DMultisample = extra->f.TexStorage2DMultisample;
-    }
-
-#endif
-
-    if (context->isOpenGLES() && context->hasExtension(QByteArrayLiteral("GL_OES_texture_3D"))) {
-        TexImage3D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid*)>(context->getProcAddress("glTexImage3DOES"));
-        TexSubImage3D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid*)>(context->getProcAddress("glTexSubImage3DOES"));
-        CompressedTexImage3D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, const GLvoid*)>(context->getProcAddress("glCompressedTexImage3DOES"));
-        CompressedTexSubImage3D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid*)>(context->getProcAddress("glCompressedTexSubImage3DOES"));
-    } else {
-        QOpenGLContext *ctx = QOpenGLContext::currentContext();
-        if (ctx->isOpenGLES() && ctx->format().majorVersion() >= 3) {
-            // OpenGL ES 3.0+ has glTexImage3D.
-            QOpenGLExtraFunctionsPrivate *extra = static_cast<QOpenGLExtensions *>(context->extraFunctions())->d();
-            TexImage3D = extra->f.TexImage3D;
-            TexSubImage3D = extra->f.TexSubImage3D;
-            CompressedTexImage3D = extra->f.CompressedTexImage3D;
-            CompressedTexSubImage3D = extra->f.CompressedTexSubImage3D;
-        } else {
-            // OpenGL 1.2
-            TexImage3D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLsizei , GLsizei , GLsizei , GLint , GLenum , GLenum , const GLvoid *)>(context->getProcAddress("glTexImage3D"));
-            TexSubImage3D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLint , GLint , GLsizei , GLsizei , GLsizei , GLenum , GLenum , const GLvoid *)>(context->getProcAddress("glTexSubImage3D"));
-
-            // OpenGL 1.3
-            CompressedTexImage3D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLenum , GLsizei , GLsizei , GLsizei , GLint , GLsizei , const GLvoid *)>(context->getProcAddress("glCompressedTexImage3D"));
-            CompressedTexSubImage3D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLint , GLint , GLsizei , GLsizei , GLsizei , GLenum , GLsizei , const GLvoid *)>(context->getProcAddress("glCompressedTexSubImage3D"));
-        }
-    }
-
-#ifndef QT_OPENGL_ES_2
-    // OpenGL 1.0 and 1.1
-    TexImage1D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLsizei , GLint , GLenum , GLenum , const GLvoid *)>(context->getProcAddress("glTexImage1D"));
-    TexSubImage1D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLsizei , GLenum , GLenum , const GLvoid *)>(context->getProcAddress("glTexSubImage1D"));\
-
-    // OpenGL 1.3
-    GetCompressedTexImage = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLvoid *)>(context->getProcAddress("glGetCompressedTexImage"));
-    CompressedTexSubImage1D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLsizei , GLenum , GLsizei , const GLvoid *)>(context->getProcAddress("glCompressedTexSubImage1D"));
-    CompressedTexSubImage2D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLint , GLsizei , GLsizei , GLenum , GLsizei , const GLvoid *)>(context->getProcAddress("glCompressedTexSubImage2D"));
-    CompressedTexImage1D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLenum , GLsizei , GLint , GLsizei , const GLvoid *)>(context->getProcAddress("glCompressedTexImage1D"));
-    CompressedTexImage2D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLenum , GLsizei , GLsizei , GLint , GLsizei , const GLvoid *)>(context->getProcAddress("glCompressedTexImage2D"));
-    ActiveTexture = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum )>(context->getProcAddress("glActiveTexture"));
-
-    // OpenGL 3.0
-    GenerateMipmap = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum )>(context->getProcAddress("glGenerateMipmap"));
-
-    // OpenGL 3.2
-    TexImage3DMultisample = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLint , GLsizei , GLsizei , GLsizei , GLboolean )>(context->getProcAddress("glTexImage3DMultisample"));
-    TexImage2DMultisample = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLint , GLsizei , GLsizei , GLboolean )>(context->getProcAddress("glTexImage2DMultisample"));
-
-    // OpenGL 4.2
-    TexStorage3D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLenum , GLsizei , GLsizei , GLsizei )>(context->getProcAddress("glTexStorage3D"));
-    TexStorage2D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLenum , GLsizei , GLsizei )>(context->getProcAddress("glTexStorage2D"));
-    TexStorage1D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLenum , GLsizei )>(context->getProcAddress("glTexStorage1D"));
-
-    // OpenGL 4.3
-    TexStorage3DMultisample = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLenum , GLsizei , GLsizei , GLsizei , GLboolean )>(context->getProcAddress("glTexStorage3DMultisample"));
-    TexStorage2DMultisample = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLenum , GLsizei , GLsizei , GLboolean )>(context->getProcAddress("glTexStorage2DMultisample"));
-    TexBufferRange = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLuint , GLintptr , GLsizeiptr )>(context->getProcAddress("glTexBufferRange"));
-    TextureView = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLuint , GLenum , GLuint , GLuint , GLuint , GLuint )>(context->getProcAddress("glTextureView"));
-#endif
-}
-
-void QOpenGLTextureHelper::dsa_TextureParameteri(GLuint texture, GLenum target, GLenum bindingTarget, GLenum pname, GLint param)
-{
-    Q_UNUSED(bindingTarget);
-    TextureParameteriEXT(texture, target, pname, param);
-}
-
-void QOpenGLTextureHelper::dsa_TextureParameteriv(GLuint texture, GLenum target, GLenum bindingTarget, GLenum pname, const GLint *params)
-{
-    Q_UNUSED(bindingTarget);
-    TextureParameterivEXT(texture, target, pname, params);
-}
-
-void QOpenGLTextureHelper::dsa_TextureParameterf(GLuint texture, GLenum target, GLenum bindingTarget, GLenum pname, GLfloat param)
-{
-    Q_UNUSED(bindingTarget);
-    TextureParameterfEXT(texture, target, pname, param);
-}
-
-void QOpenGLTextureHelper::dsa_TextureParameterfv(GLuint texture, GLenum target, GLenum bindingTarget, GLenum pname, const GLfloat *params)
-{
-    Q_UNUSED(bindingTarget);
-    TextureParameterfvEXT(texture, target, pname, params);
-}
-
-void QOpenGLTextureHelper::dsa_GenerateTextureMipmap(GLuint texture, GLenum target, GLenum bindingTarget)
-{
-    Q_UNUSED(bindingTarget);
-    GenerateTextureMipmapEXT(texture, target);
-}
-
-void QOpenGLTextureHelper::dsa_TextureStorage3D(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth)
-{
-    Q_UNUSED(bindingTarget);
-    TextureStorage3DEXT(texture, target, levels, internalFormat, width, height, depth);
-}
-
-void QOpenGLTextureHelper::dsa_TextureStorage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height)
-{
-    Q_UNUSED(bindingTarget);
-    TextureStorage2DEXT(texture, target, levels, internalFormat, width, height);
-}
-
-void QOpenGLTextureHelper::dsa_TextureStorage1D(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei levels, GLenum internalFormat, GLsizei width)
-{
-    Q_UNUSED(bindingTarget);
-    TextureStorage1DEXT(texture, target, levels, internalFormat, width);
-}
-
-void QOpenGLTextureHelper::dsa_TextureStorage3DMultisample(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations)
-{
-    Q_UNUSED(bindingTarget);
-    TextureStorage3DMultisampleEXT(texture, target, samples, internalFormat, width, height, depth, fixedSampleLocations);
-}
-
-void QOpenGLTextureHelper::dsa_TextureStorage2DMultisample(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations)
-{
-    Q_UNUSED(bindingTarget);
-    TextureStorage2DMultisampleEXT(texture, target, samples, internalFormat, width, height, fixedSampleLocations);
-}
-
-void QOpenGLTextureHelper::dsa_TextureImage3D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    Q_UNUSED(bindingTarget);
-    TextureImage3DEXT(texture, target, level, internalFormat, width, height, depth, border, format, type, pixels);
-}
-
-void QOpenGLTextureHelper::dsa_TextureImage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    Q_UNUSED(bindingTarget);
-    TextureImage2DEXT(texture, target, level, internalFormat, width, height, border, format, type, pixels);
-}
-
-void QOpenGLTextureHelper::dsa_TextureImage1D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    Q_UNUSED(bindingTarget);
-    TextureImage1DEXT(texture, target, level, internalFormat, width, border, format, type, pixels);
-}
-
-void QOpenGLTextureHelper::dsa_TextureSubImage3D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    Q_UNUSED(bindingTarget);
-    TextureSubImage3DEXT(texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
-}
-
-void QOpenGLTextureHelper::dsa_TextureSubImage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    Q_UNUSED(bindingTarget);
-    TextureSubImage2DEXT(texture, target, level, xoffset, yoffset, width, height, format, type, pixels);
-}
-
-void QOpenGLTextureHelper::dsa_TextureSubImage1D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    Q_UNUSED(bindingTarget);
-    TextureSubImage1DEXT(texture, target, level, xoffset, width, format, type, pixels);
-}
-
-void QOpenGLTextureHelper::dsa_TextureImage3DMultisample(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations)
-{
-    Q_UNUSED(bindingTarget);
-    TextureImage3DMultisampleNV(texture, target, samples, internalFormat, width, height, depth, fixedSampleLocations);
-}
-
-void QOpenGLTextureHelper::dsa_TextureImage2DMultisample(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations)
-{
-    Q_UNUSED(bindingTarget);
-    TextureImage2DMultisampleNV(texture, target, samples, internalFormat, width, height, fixedSampleLocations);
-}
-
-void QOpenGLTextureHelper::dsa_CompressedTextureSubImage1D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *bits)
-{
-    Q_UNUSED(bindingTarget);
-    CompressedTextureSubImage1DEXT(texture, target, level, xoffset, width, format, imageSize, bits);
-}
-
-void QOpenGLTextureHelper::dsa_CompressedTextureSubImage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *bits)
-{
-    Q_UNUSED(bindingTarget);
-    CompressedTextureSubImage2DEXT(texture, target, level, xoffset, yoffset, width, height, format, imageSize, bits);
-}
-
-void QOpenGLTextureHelper::dsa_CompressedTextureSubImage3D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *bits)
-{
-    Q_UNUSED(bindingTarget);
-    CompressedTextureSubImage3DEXT(texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits);
-}
-
-void QOpenGLTextureHelper::dsa_CompressedTextureImage1D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *bits)
-{
-    Q_UNUSED(bindingTarget);
-    CompressedTextureImage1DEXT(texture, target, level, internalFormat, width, border, imageSize, bits);
-}
-
-void QOpenGLTextureHelper::dsa_CompressedTextureImage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *bits)
-{
-    Q_UNUSED(bindingTarget);
-    CompressedTextureImage2DEXT(texture, target, level, internalFormat, width, height, border, imageSize, bits);
-}
-
-void QOpenGLTextureHelper::dsa_CompressedTextureImage3D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *bits)
-{
-    Q_UNUSED(bindingTarget);
-    CompressedTextureImage3DEXT(texture, target, level, internalFormat, width, height, depth, border, imageSize, bits);
-}
-
-namespace {
-
-class TextureBinder
-{
-public:
-    TextureBinder(QOpenGLFunctions *functions, GLuint texture, GLenum target, GLenum bindingTarget)
-    : m_functions(functions)
-    {
-        // For cubemaps we can't use the standard DSA emulation as it is illegal to
-        // try to bind a texture to one of the cubemap face targets. So we force the
-        // target and binding target to the cubemap values in this case.
-        switch (target) {
-        case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
-        case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
-        case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
-        case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
-        case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
-        case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
-            bindingTarget = GL_TEXTURE_BINDING_CUBE_MAP;
-            m_target = GL_TEXTURE_CUBE_MAP;
-            break;
-
-        default:
-            m_target = target;
-            break;
-        }
-
-        m_functions->glGetIntegerv(bindingTarget, &m_oldTexture);
-        m_functions->glBindTexture(m_target, texture);
-    }
-
-    ~TextureBinder()
-    {
-        m_functions->glBindTexture(m_target, m_oldTexture);
-    }
-
-private:
-    QOpenGLFunctions *m_functions;
-    GLenum m_target;
-    GLint m_oldTexture;
-};
-
-} // namespace
-
-void QOpenGLTextureHelper::qt_TextureParameteri(GLuint texture, GLenum target, GLenum bindingTarget, GLenum pname, GLint param)
-{
-    TextureBinder binder(functions, texture, target, bindingTarget);
-    functions->glTexParameteri(target, pname, param);
-}
-
-void QOpenGLTextureHelper::qt_TextureParameteriv(GLuint texture, GLenum target, GLenum bindingTarget, GLenum pname, const GLint *params)
-{
-    TextureBinder binder(functions, texture, target, bindingTarget);
-    functions->glTexParameteriv(target, pname, params);
-}
-
-void QOpenGLTextureHelper::qt_TextureParameterf(GLuint texture, GLenum target, GLenum bindingTarget, GLenum pname, GLfloat param)
-{
-    TextureBinder binder(functions, texture, target, bindingTarget);
-    functions->glTexParameterf(target, pname, param);
-}
-
-void QOpenGLTextureHelper::qt_TextureParameterfv(GLuint texture, GLenum target, GLenum bindingTarget, GLenum pname, const GLfloat *params)
-{
-    TextureBinder binder(functions, texture, target, bindingTarget);
-    functions->glTexParameterfv(target, pname, params);
-}
-
-void QOpenGLTextureHelper::qt_GenerateTextureMipmap(GLuint texture, GLenum target, GLenum bindingTarget)
-{
-    TextureBinder binder(functions, texture, target, bindingTarget);
-    functions->glGenerateMipmap(target);
-}
-
-void QOpenGLTextureHelper::qt_TextureStorage3D(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth)
-{
-    TextureBinder binder(functions, texture, target, bindingTarget);
-    glTexStorage3D(target, levels, internalFormat, width, height, depth);
-}
-
-void QOpenGLTextureHelper::qt_TextureStorage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height)
-{
-    TextureBinder binder(functions, texture, target, bindingTarget);
-    glTexStorage2D(target, levels, internalFormat, width, height);
-}
-
-void QOpenGLTextureHelper::qt_TextureStorage1D(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei levels, GLenum internalFormat, GLsizei width)
-{
-    TextureBinder binder(functions, texture, target, bindingTarget);
-    glTexStorage1D(target, levels, internalFormat, width);
-}
-
-void QOpenGLTextureHelper::qt_TextureStorage3DMultisample(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations)
-{
-    TextureBinder binder(functions, texture, target, bindingTarget);
-    glTexStorage3DMultisample(target, samples, internalFormat, width, height, depth, fixedSampleLocations);
-}
-
-void QOpenGLTextureHelper::qt_TextureStorage2DMultisample(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations)
-{
-    TextureBinder binder(functions, texture, target, bindingTarget);
-    glTexStorage2DMultisample(target, samples, internalFormat, width, height, fixedSampleLocations);
-}
-
-void QOpenGLTextureHelper::qt_TextureImage3D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    TextureBinder binder(functions, texture, target, bindingTarget);
-    glTexImage3D(target, level, internalFormat, width, height, depth, border, format, type, pixels);
-}
-
-void QOpenGLTextureHelper::qt_TextureImage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    TextureBinder binder(functions, texture, target, bindingTarget);
-    functions->glTexImage2D(target, level, internalFormat, width, height, border, format, type, pixels);
-}
-
-void QOpenGLTextureHelper::qt_TextureImage1D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    TextureBinder binder(functions, texture, target, bindingTarget);
-    glTexImage1D(target, level, internalFormat, width, border, format, type, pixels);
-}
-
-void QOpenGLTextureHelper::qt_TextureSubImage3D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    TextureBinder binder(functions, texture, target, bindingTarget);
-    glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
-}
-
-void QOpenGLTextureHelper::qt_TextureSubImage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    TextureBinder binder(functions, texture, target, bindingTarget);
-    functions->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
-}
-
-void QOpenGLTextureHelper::qt_TextureSubImage1D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
-{
-    TextureBinder binder(functions, texture, target, bindingTarget);
-    glTexSubImage1D(target, level, xoffset, width, format, type, pixels);
-}
-
-void QOpenGLTextureHelper::qt_TextureImage3DMultisample(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations)
-{
-    TextureBinder binder(functions, texture, target, bindingTarget);
-    glTexImage3DMultisample(target, samples, internalFormat, width, height, depth, fixedSampleLocations);
-}
-
-void QOpenGLTextureHelper::qt_TextureImage2DMultisample(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations)
-{
-    TextureBinder binder(functions, texture, target, bindingTarget);
-    glTexImage2DMultisample(target, samples, internalFormat, width, height, fixedSampleLocations);
-}
-
-void QOpenGLTextureHelper::qt_CompressedTextureSubImage1D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *bits)
-{
-    TextureBinder binder(functions, texture, target, bindingTarget);
-    glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, bits);
-}
-
-void QOpenGLTextureHelper::qt_CompressedTextureSubImage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *bits)
-{
-    TextureBinder binder(functions, texture, target, bindingTarget);
-    glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, bits);
-}
-
-void QOpenGLTextureHelper::qt_CompressedTextureSubImage3D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *bits)
-{
-    TextureBinder binder(functions, texture, target, bindingTarget);
-    glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits);
-}
-
-void QOpenGLTextureHelper::qt_CompressedTextureImage1D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *bits)
-{
-    TextureBinder binder(functions, texture, target, bindingTarget);
-    glCompressedTexImage1D(target, level, internalFormat, width, border, imageSize, bits);
-}
-
-void QOpenGLTextureHelper::qt_CompressedTextureImage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *bits)
-{
-    TextureBinder binder(functions, texture, target, bindingTarget);
-    glCompressedTexImage2D(target, level, internalFormat, width, height, border, imageSize, bits);
-}
-
-void QOpenGLTextureHelper::qt_CompressedTextureImage3D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *bits)
-{
-    TextureBinder binder(functions, texture, target, bindingTarget);
-    glCompressedTexImage3D(target, level, internalFormat, width, height, depth, border, imageSize, bits);
-}
-
-QT_END_NAMESPACE
diff --git a/src/gui/opengl/qopengltexturehelper_p.h b/src/gui/opengl/qopengltexturehelper_p.h
deleted file mode 100644
index 62d0125daf..0000000000
--- a/src/gui/opengl/qopengltexturehelper_p.h
+++ /dev/null
@@ -1,797 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB).
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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 QOPENGLTEXTUREHELPER_P_H
-#define QOPENGLTEXTUREHELPER_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 <QtGui/private/qtguiglobal_p.h>
-
-#ifndef QT_NO_OPENGL
-
-#include "qopengl.h"
-#include "qopenglpixeltransferoptions.h"
-#include "qopengltexture.h"
-#include "qopenglfunctions.h"
-
-QT_BEGIN_NAMESPACE
-
-// Constants for OpenGL and OpenGL ES 3.0+ which are not available with OpenGL ES 2.0.
-#ifndef GL_TEXTURE_BASE_LEVEL
-#define GL_TEXTURE_BASE_LEVEL 0x813C
-#endif
-#ifndef GL_TEXTURE_MAX_LEVEL
-#define GL_TEXTURE_MAX_LEVEL 0x813D
-#endif
-#ifndef GL_TEXTURE_COMPARE_MODE
-#define GL_TEXTURE_COMPARE_MODE 0x884C
-#endif
-#ifndef GL_TEXTURE_COMPARE_FUNC
-#define GL_TEXTURE_COMPARE_FUNC 0x884D
-#endif
-
-// use GL_APICALL only on Android + __clang__
-#if !defined(Q_OS_ANDROID) || !defined(__clang__)
-# undef GL_APICALL
-# define GL_APICALL
-#elif !defined(GL_APICALL)
-# define GL_APICALL
-#endif
-
-class QOpenGLContext;
-
-class QOpenGLTextureHelper
-{
-public:
-    QOpenGLTextureHelper(QOpenGLContext *context);
-
-    // DSA-like API. Will either use real DSA or our emulation
-    inline void glTextureParameteri(GLuint texture, GLenum target, GLenum bindingTarget, GLenum pname, GLint param)
-    {
-        (this->*TextureParameteri)(texture, target, bindingTarget, pname, param);
-    }
-
-    inline void glTextureParameteriv(GLuint texture, GLenum target, GLenum bindingTarget, GLenum pname, const GLint *params)
-    {
-        (this->*TextureParameteriv)(texture, target, bindingTarget, pname, params);
-    }
-
-    inline void glTextureParameterf(GLuint texture, GLenum target, GLenum bindingTarget, GLenum pname, GLfloat param)
-    {
-        (this->*TextureParameterf)(texture, target, bindingTarget, pname, param);
-    }
-
-    inline void glTextureParameterfv(GLuint texture, GLenum target, GLenum bindingTarget, GLenum pname, const GLfloat *params)
-    {
-        (this->*TextureParameterfv)(texture, target, bindingTarget, pname, params);
-    }
-
-    inline void glGenerateTextureMipmap(GLuint texture, GLenum target, GLenum bindingTarget)
-    {
-        (this->*GenerateTextureMipmap)(texture, target, bindingTarget);
-    }
-
-    inline void glTextureStorage3D(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei levels, GLenum internalFormat,
-                                   GLsizei width, GLsizei height, GLsizei depth)
-    {
-        (this->*TextureStorage3D)(texture, target, bindingTarget, levels, internalFormat, width, height, depth);
-    }
-
-    inline void glTextureStorage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei levels, GLenum internalFormat,
-                                   GLsizei width, GLsizei height)
-    {
-        (this->*TextureStorage2D)(texture, target, bindingTarget, levels, internalFormat, width, height);
-    }
-
-    inline void glTextureStorage1D(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei levels, GLenum internalFormat,
-                                   GLsizei width)
-    {
-        (this->*TextureStorage1D)(texture, target, bindingTarget, levels, internalFormat, width);
-    }
-
-    inline void glTextureStorage3DMultisample(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei samples, GLenum internalFormat,
-                                              GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations)
-    {
-        (this->*TextureStorage3DMultisample)(texture, target, bindingTarget, samples, internalFormat, width, height, depth, fixedSampleLocations);
-    }
-
-    inline void glTextureStorage2DMultisample(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei samples, GLenum internalFormat,
-                                              GLsizei width, GLsizei height, GLboolean fixedSampleLocations)
-    {
-        (this->*TextureStorage2DMultisample)(texture, target, bindingTarget, samples, internalFormat, width, height, fixedSampleLocations);
-    }
-
-    inline void glTextureImage3D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat,
-                                 GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-    {
-        (this->*TextureImage3D)(texture, target, bindingTarget, level, internalFormat, width, height, depth, border, format, type, pixels);
-    }
-
-    inline void glTextureImage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat,
-                                 GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-    {
-        (this->*TextureImage2D)(texture, target, bindingTarget, level, internalFormat, width, height, border, format, type, pixels);
-    }
-
-    inline void glTextureImage1D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat,
-                                 GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-    {
-        (this->*TextureImage1D)(texture, target, bindingTarget, level, internalFormat, width, border, format, type, pixels);
-    }
-
-    inline void glTextureSubImage3D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLint xoffset, GLint yoffset, GLint zoffset,
-                                    GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type,
-                                    const GLvoid *pixels, const QOpenGLPixelTransferOptions * const options = nullptr)
-    {
-        if (options) {
-            QOpenGLPixelTransferOptions oldOptions = savePixelUploadOptions();
-            setPixelUploadOptions(*options);
-            (this->*TextureSubImage3D)(texture, target, bindingTarget, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
-            setPixelUploadOptions(oldOptions);
-        } else {
-            (this->*TextureSubImage3D)(texture, target, bindingTarget, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
-        }
-    }
-
-    inline void glTextureSubImage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLint xoffset, GLint yoffset,
-                                    GLsizei width, GLsizei height, GLenum format, GLenum type,
-                                    const GLvoid *pixels, const QOpenGLPixelTransferOptions * const options = nullptr)
-    {
-        if (options) {
-            QOpenGLPixelTransferOptions oldOptions = savePixelUploadOptions();
-            setPixelUploadOptions(*options);
-            (this->*TextureSubImage2D)(texture, target, bindingTarget, level, xoffset, yoffset, width, height, format, type, pixels);
-            setPixelUploadOptions(oldOptions);
-        } else {
-            (this->*TextureSubImage2D)(texture, target, bindingTarget, level, xoffset, yoffset, width, height, format, type, pixels);
-        }
-    }
-
-    inline void glTextureSubImage1D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLint xoffset,
-                                    GLsizei width, GLenum format, GLenum type,
-                                    const GLvoid *pixels, const QOpenGLPixelTransferOptions * const options = nullptr)
-    {
-        if (options) {
-            QOpenGLPixelTransferOptions oldOptions = savePixelUploadOptions();
-            setPixelUploadOptions(*options);
-            (this->*TextureSubImage1D)(texture, target, bindingTarget, level, xoffset, width, format, type, pixels);
-            setPixelUploadOptions(oldOptions);
-        } else {
-            (this->*TextureSubImage1D)(texture, target, bindingTarget, level, xoffset, width, format, type, pixels);
-        }
-    }
-
-    inline void glTextureImage3DMultisample(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei samples, GLint internalFormat,
-                                            GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations)
-    {
-        (this->*TextureImage3DMultisample)(texture, target, bindingTarget, samples, internalFormat, width, height, depth, fixedSampleLocations);
-    }
-
-    inline void glTextureImage2DMultisample(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei samples, GLint internalFormat,
-                                            GLsizei width, GLsizei height, GLboolean fixedSampleLocations)
-    {
-        (this->*TextureImage2DMultisample)(texture, target, bindingTarget, samples, internalFormat, width, height, fixedSampleLocations);
-    }
-
-    inline void glCompressedTextureSubImage1D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level,
-                                              GLint xoffset, GLsizei width,
-                                              GLenum format, GLsizei imageSize, const GLvoid *bits,
-                                              const QOpenGLPixelTransferOptions * const options = nullptr)
-    {
-        if (options) {
-            QOpenGLPixelTransferOptions oldOptions = savePixelUploadOptions();
-            setPixelUploadOptions(*options);
-            (this->*CompressedTextureSubImage1D)(texture, target, bindingTarget, level, xoffset, width, format, imageSize, bits);
-            setPixelUploadOptions(oldOptions);
-        } else {
-            (this->*CompressedTextureSubImage1D)(texture, target, bindingTarget, level, xoffset, width, format, imageSize, bits);
-        }
-    }
-
-    inline void glCompressedTextureSubImage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level,
-                                              GLint xoffset, GLint yoffset,
-                                              GLsizei width, GLsizei height,
-                                              GLenum format, GLsizei imageSize, const GLvoid *bits,
-                                              const QOpenGLPixelTransferOptions * const options = nullptr)
-    {
-        if (options) {
-            QOpenGLPixelTransferOptions oldOptions = savePixelUploadOptions();
-            setPixelUploadOptions(*options);
-            (this->*CompressedTextureSubImage2D)(texture, target, bindingTarget, level, xoffset, yoffset, width, height, format, imageSize, bits);
-            setPixelUploadOptions(oldOptions);
-        } else {
-            (this->*CompressedTextureSubImage2D)(texture, target, bindingTarget, level, xoffset, yoffset, width, height, format, imageSize, bits);
-        }
-    }
-
-    inline void glCompressedTextureSubImage3D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level,
-                                              GLint xoffset, GLint yoffset, GLint zoffset,
-                                              GLsizei width, GLsizei height, GLsizei depth,
-                                              GLenum format, GLsizei imageSize, const GLvoid *bits,
-                                              const QOpenGLPixelTransferOptions * const options = nullptr)
-    {
-        if (options) {
-            QOpenGLPixelTransferOptions oldOptions = savePixelUploadOptions();
-            setPixelUploadOptions(*options);
-            (this->*CompressedTextureSubImage3D)(texture, target, bindingTarget, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits);
-            setPixelUploadOptions(oldOptions);
-        } else {
-            (this->*CompressedTextureSubImage3D)(texture, target, bindingTarget, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits);
-        }
-    }
-
-    inline void glCompressedTextureImage1D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level,
-                                           GLenum internalFormat, GLsizei width,
-                                           GLint border, GLsizei imageSize, const GLvoid *bits,
-                                           const QOpenGLPixelTransferOptions * const options = nullptr)
-    {
-        if (options) {
-            QOpenGLPixelTransferOptions oldOptions = savePixelUploadOptions();
-            setPixelUploadOptions(*options);
-            (this->*CompressedTextureImage1D)(texture, target, bindingTarget, level, internalFormat, width, border, imageSize, bits);
-            setPixelUploadOptions(oldOptions);
-        } else {
-            (this->*CompressedTextureImage1D)(texture, target, bindingTarget, level, internalFormat, width, border, imageSize, bits);
-        }
-    }
-
-    inline void glCompressedTextureImage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level,
-                                           GLenum internalFormat, GLsizei width, GLsizei height,
-                                           GLint border, GLsizei imageSize, const GLvoid *bits,
-                                           const QOpenGLPixelTransferOptions * const options = nullptr)
-
-    {
-        if (options) {
-            QOpenGLPixelTransferOptions oldOptions = savePixelUploadOptions();
-            setPixelUploadOptions(*options);
-            (this->*CompressedTextureImage2D)(texture, target, bindingTarget, level, internalFormat, width, height, border, imageSize, bits);
-            setPixelUploadOptions(oldOptions);
-        } else {
-            (this->*CompressedTextureImage2D)(texture, target, bindingTarget, level, internalFormat, width, height, border, imageSize, bits);
-        }
-    }
-
-    inline void glCompressedTextureImage3D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level,
-                                           GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth,
-                                           GLint border, GLsizei imageSize, const GLvoid *bits,
-                                           const QOpenGLPixelTransferOptions * const options = nullptr)
-    {
-        if (options) {
-            QOpenGLPixelTransferOptions oldOptions = savePixelUploadOptions();
-            setPixelUploadOptions(*options);
-            (this->*CompressedTextureImage3D)(texture, target, bindingTarget, level, internalFormat, width, height, depth, border, imageSize, bits);
-            setPixelUploadOptions(oldOptions);
-        } else {
-            (this->*CompressedTextureImage3D)(texture, target, bindingTarget, level, internalFormat, width, height, depth, border, imageSize, bits);
-        }
-    }
-
-private:
-    // DSA wrapper (so we can use pointer to member function as switch)
-    void dsa_TextureParameteri(GLuint texture, GLenum target, GLenum bindingTarget, GLenum pname, GLint param);
-
-    void dsa_TextureParameteriv(GLuint texture, GLenum target, GLenum bindingTarget, GLenum pname, const GLint *params);
-
-    void dsa_TextureParameterf(GLuint texture, GLenum target, GLenum bindingTarget, GLenum pname, GLfloat param);
-
-    void dsa_TextureParameterfv(GLuint texture, GLenum target, GLenum bindingTarget, GLenum pname, const GLfloat *params);
-
-    void dsa_GenerateTextureMipmap(GLuint texture, GLenum target, GLenum bindingTarget);
-
-    void dsa_TextureStorage3D(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei levels, GLenum internalFormat,
-                              GLsizei width, GLsizei height, GLsizei depth);
-
-    void dsa_TextureStorage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei levels, GLenum internalFormat,
-                              GLsizei width, GLsizei height);
-
-    void dsa_TextureStorage1D(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei levels, GLenum internalFormat,
-                              GLsizei width);
-
-    void dsa_TextureStorage3DMultisample(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei samples, GLenum internalFormat,
-                                         GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations);
-
-    void dsa_TextureStorage2DMultisample(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei samples, GLenum internalFormat,
-                                         GLsizei width, GLsizei height, GLboolean fixedSampleLocations);
-
-    void dsa_TextureImage3D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat,
-                            GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-
-    void dsa_TextureImage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat,
-                            GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-
-    void dsa_TextureImage1D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat,
-                            GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-
-    void dsa_TextureSubImage3D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLint xoffset, GLint yoffset, GLint zoffset,
-                               GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
-
-    void dsa_TextureSubImage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLint xoffset, GLint yoffset,
-                               GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
-
-    void dsa_TextureSubImage1D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLint xoffset,
-                               GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
-
-    void dsa_TextureImage3DMultisample(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei samples, GLint internalFormat,
-                                       GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations);
-
-    void dsa_TextureImage2DMultisample(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei samples, GLint internalFormat,
-                                       GLsizei width, GLsizei height, GLboolean fixedSampleLocations);
-
-    void dsa_CompressedTextureSubImage1D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level,
-                                         GLint xoffset, GLsizei width,
-                                         GLenum format, GLsizei imageSize, const GLvoid *bits);
-
-    void dsa_CompressedTextureSubImage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level,
-                                         GLint xoffset, GLint yoffset,
-                                         GLsizei width, GLsizei height,
-                                         GLenum format, GLsizei imageSize, const GLvoid *bits);
-
-    void dsa_CompressedTextureSubImage3D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level,
-                                         GLint xoffset, GLint yoffset, GLint zoffset,
-                                         GLsizei width, GLsizei height, GLsizei depth,
-                                         GLenum format, GLsizei imageSize, const GLvoid *bits);
-
-    void dsa_CompressedTextureImage1D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level,
-                                      GLenum internalFormat, GLsizei width,
-                                      GLint border, GLsizei imageSize, const GLvoid *bits);
-
-    void dsa_CompressedTextureImage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level,
-                                      GLenum internalFormat, GLsizei width, GLsizei height,
-                                      GLint border, GLsizei imageSize, const GLvoid *bits);
-
-    void dsa_CompressedTextureImage3D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level,
-                                      GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth,
-                                      GLint border, GLsizei imageSize, const GLvoid *bits);
-
-    // DSA emulation API
-    void qt_TextureParameteri(GLuint texture, GLenum target, GLenum bindingTarget, GLenum pname, GLint param);
-
-    void qt_TextureParameteriv(GLuint texture, GLenum target, GLenum bindingTarget, GLenum pname, const GLint *params);
-
-    void qt_TextureParameterf(GLuint texture, GLenum target, GLenum bindingTarget, GLenum pname, GLfloat param);
-
-    void qt_TextureParameterfv(GLuint texture, GLenum target, GLenum bindingTarget, GLenum pname, const GLfloat *params);
-
-    void qt_GenerateTextureMipmap(GLuint texture, GLenum target, GLenum bindingTarget);
-
-    void qt_TextureStorage3D(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei levels,
-                             GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth);
-
-    void qt_TextureStorage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei levels,
-                             GLenum internalFormat, GLsizei width, GLsizei height);
-
-    void qt_TextureStorage1D(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei levels,
-                             GLenum internalFormat, GLsizei width);
-
-    void qt_TextureStorage3DMultisample(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei samples,
-                                        GLenum internalFormat, GLsizei width, GLsizei height,
-                                        GLsizei depth, GLboolean fixedSampleLocations);
-
-    void qt_TextureStorage2DMultisample(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei samples,
-                                        GLenum internalFormat, GLsizei width, GLsizei height,
-                                        GLboolean fixedSampleLocations);
-
-    void qt_TextureImage3D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat,
-                           GLsizei width, GLsizei height, GLsizei depth,
-                           GLint border, GLenum format, GLenum type,
-                           const GLvoid *pixels);
-
-    void qt_TextureImage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat,
-                           GLsizei width, GLsizei height,
-                           GLint border, GLenum format, GLenum type,
-                           const GLvoid *pixels);
-
-    void qt_TextureImage1D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat,
-                           GLsizei width, GLint border, GLenum format, GLenum type,
-                           const GLvoid *pixels);
-
-    void qt_TextureSubImage3D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level,
-                              GLint xoffset, GLint yoffset, GLint zoffset,
-                              GLsizei width, GLsizei height, GLsizei depth,
-                              GLenum format, GLenum type, const GLvoid *pixels);
-
-    void qt_TextureSubImage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level,
-                              GLint xoffset, GLint yoffset,
-                              GLsizei width, GLsizei height,
-                              GLenum format, GLenum type, const GLvoid *pixels);
-
-    void qt_TextureSubImage1D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level,
-                              GLint xoffset, GLsizei width,
-                              GLenum format, GLenum type, const GLvoid *pixels);
-
-    void qt_TextureImage3DMultisample(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei samples,
-                                      GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth,
-                                      GLboolean fixedSampleLocations);
-
-    void qt_TextureImage2DMultisample(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei samples,
-                                      GLint internalFormat, GLsizei width, GLsizei height,
-                                      GLboolean fixedSampleLocations);
-
-    void qt_CompressedTextureSubImage1D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level,
-                                        GLint xoffset, GLsizei width, GLenum format,
-                                        GLsizei imageSize, const GLvoid *bits);
-
-    void qt_CompressedTextureSubImage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level,
-                                        GLint xoffset, GLint yoffset,
-                                        GLsizei width, GLsizei height,
-                                        GLenum format, GLsizei imageSize, const GLvoid *bits);
-
-    void qt_CompressedTextureSubImage3D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level,
-                                        GLint xoffset, GLint yoffset, GLint zoffset,
-                                        GLsizei width, GLsizei height, GLsizei depth,
-                                        GLenum format, GLsizei imageSize, const GLvoid *bits);
-
-    void qt_CompressedTextureImage1D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat,
-                                     GLsizei width, GLint border,
-                                     GLsizei imageSize, const GLvoid *bits);
-
-    void qt_CompressedTextureImage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat,
-                                     GLsizei width, GLsizei height, GLint border,
-                                     GLsizei imageSize, const GLvoid *bits);
-
-    void qt_CompressedTextureImage3D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat,
-                                     GLsizei width, GLsizei height, GLsizei depth, GLint border,
-                                     GLsizei imageSize, const GLvoid *bits);
-
-public:
-    // Raw OpenGL functions, resolved and used by our DSA-like static functions if no EXT_direct_state_access is available
-
-    // OpenGL 1.0
-    inline void glTexImage1D(GLenum target, GLint level, GLint internalFormat,
-                             GLsizei width, GLint border,
-                             GLenum format, GLenum type, const GLvoid *pixels)
-    {
-        TexImage1D(target, level, internalFormat, width, border, format, type, pixels);
-    }
-
-    // OpenGL 1.1
-    inline void glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width,
-                                GLenum format, GLenum type, const GLvoid *pixels)
-    {
-        TexSubImage1D(target, level, xoffset, width, format, type, pixels);
-    }
-
-    // OpenGL 1.2
-    inline void glTexImage3D(GLenum target, GLint level, GLint internalFormat,
-                             GLsizei width, GLsizei height, GLsizei depth, GLint border,
-                             GLenum format, GLenum type, const GLvoid *pixels)
-    {
-        TexImage3D(target, level, internalFormat, width, height, depth, border, format, type, pixels);
-    }
-
-    inline void glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset,
-                                GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
-    {
-        TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
-    }
-
-    // OpenGL 1.3
-    inline void glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img)
-    {
-        GetCompressedTexImage(target, level, img);
-    }
-
-    inline void glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width,
-                                          GLenum format, GLsizei imageSize, const GLvoid *data)
-    {
-        CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
-    }
-
-    inline void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
-                                          GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
-    {
-        CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
-    }
-
-    inline void glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset,
-                                          GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
-    {
-        CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
-    }
-
-    inline void glCompressedTexImage1D(GLenum target, GLint level, GLenum internalFormat, GLsizei width,
-                                       GLint border, GLsizei imageSize, const GLvoid *data)
-    {
-        CompressedTexImage1D(target, level, internalFormat, width, border, imageSize, data);
-    }
-
-    inline void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height,
-                                       GLint border, GLsizei imageSize, const GLvoid *data)
-    {
-        CompressedTexImage2D(target, level, internalFormat, width, height, border, imageSize, data);
-    }
-
-    inline void glCompressedTexImage3D(GLenum target, GLint level, GLenum internalFormat,
-                                       GLsizei width, GLsizei height, GLsizei depth,
-                                       GLint border, GLsizei imageSize, const GLvoid *data)
-    {
-        CompressedTexImage3D(target, level, internalFormat, width, height, depth, border, imageSize, data);
-    }
-
-    inline void glActiveTexture(GLenum texture)
-    {
-        ActiveTexture(texture);
-    }
-
-    // OpenGL 3.0
-    inline void glGenerateMipmap(GLenum target)
-    {
-        GenerateMipmap(target);
-    }
-
-    // OpenGL 3.2
-    inline void glTexImage3DMultisample(GLenum target, GLsizei samples, GLint internalFormat,
-                                        GLsizei width, GLsizei height, GLsizei depth,
-                                        GLboolean fixedSampleLocations)
-    {
-        TexImage3DMultisample(target, samples, internalFormat, width, height, depth, fixedSampleLocations);
-    }
-
-    inline void glTexImage2DMultisample(GLenum target, GLsizei samples, GLint internalFormat,
-                                        GLsizei width, GLsizei height,
-                                        GLboolean fixedSampleLocations)
-    {
-        TexImage2DMultisample(target, samples, internalFormat, width, height, fixedSampleLocations);
-    }
-
-    // OpenGL 4.2
-    inline void glTexStorage3D(GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth)
-    {
-        TexStorage3D(target, levels, internalFormat, width, height, depth);
-    }
-
-    inline void glTexStorage2D(GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height)
-    {
-        TexStorage2D(target, levels, internalFormat, width, height);
-    }
-
-    inline void glTexStorage1D(GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width)
-    {
-        TexStorage1D(target, levels, internalFormat, width);
-    }
-
-    // OpenGL 4.3
-    inline void glTexStorage3DMultisample(GLenum target, GLsizei samples, GLenum internalFormat,
-                                          GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations)
-    {
-        TexStorage3DMultisample(target, samples, internalFormat, width, height, depth, fixedSampleLocations);
-    }
-
-    inline void glTexStorage2DMultisample(GLenum target, GLsizei samples, GLenum internalFormat,
-                                          GLsizei width, GLsizei height, GLboolean fixedSampleLocations)
-    {
-        TexStorage2DMultisample(target, samples, internalFormat, width, height, fixedSampleLocations);
-    }
-
-    inline void glTexBufferRange(GLenum target, GLenum internalFormat, GLuint buffer,
-                                 GLintptr offset, GLsizeiptr size)
-    {
-        TexBufferRange(target, internalFormat, buffer, offset, size);
-    }
-
-    inline void glTextureView(GLuint texture, GLenum target, GLuint origTexture, GLenum internalFormat,
-                              GLuint minLevel, GLuint numLevels, GLuint minLayer, GLuint numLayers)
-    {
-        TextureView(texture, target, origTexture, internalFormat, minLevel, numLevels, minLayer, numLayers);
-    }
-
-    // Helper functions
-    inline QOpenGLPixelTransferOptions savePixelUploadOptions()
-    {
-        QOpenGLPixelTransferOptions options;
-        int val = 0;
-        functions->glGetIntegerv(GL_UNPACK_ALIGNMENT, &val);
-        options.setAlignment(val);
-#if !defined(QT_OPENGL_ES_2)
-        functions->glGetIntegerv(GL_UNPACK_SKIP_IMAGES, &val);
-        options.setSkipImages(val);
-        functions->glGetIntegerv(GL_UNPACK_SKIP_ROWS, &val);
-        options.setSkipRows(val);
-        functions->glGetIntegerv(GL_UNPACK_SKIP_PIXELS, &val);
-        options.setSkipPixels(val);
-        functions->glGetIntegerv(GL_UNPACK_IMAGE_HEIGHT, &val);
-        options.setImageHeight(val);
-        functions->glGetIntegerv(GL_UNPACK_ROW_LENGTH, &val);
-        options.setRowLength(val);
-        GLboolean b = GL_FALSE;
-        functions->glGetBooleanv(GL_UNPACK_LSB_FIRST, &b);
-        options.setLeastSignificantByteFirst(b);
-        functions->glGetBooleanv(GL_UNPACK_SWAP_BYTES, &b);
-        options.setSwapBytesEnabled(b);
-#endif
-        return options;
-    }
-
-    inline void setPixelUploadOptions(const QOpenGLPixelTransferOptions &options)
-    {
-        functions->glPixelStorei(GL_UNPACK_ALIGNMENT, options.alignment());
-#if !defined(QT_OPENGL_ES_2)
-        functions->glPixelStorei(GL_UNPACK_SKIP_IMAGES, options.skipImages());
-        functions->glPixelStorei(GL_UNPACK_SKIP_ROWS, options.skipRows());
-        functions->glPixelStorei(GL_UNPACK_SKIP_PIXELS, options.skipPixels());
-        functions->glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, options.imageHeight());
-        functions->glPixelStorei(GL_UNPACK_ROW_LENGTH, options.rowLength());
-        functions->glPixelStorei(GL_UNPACK_LSB_FIRST, options.isLeastSignificantBitFirst());
-        functions->glPixelStorei(GL_UNPACK_SWAP_BYTES, options.isSwapBytesEnabled());
-#endif
-    }
-
-    QOpenGLFunctions *functions;
-private:
-    // Typedefs and pointers to member functions used to switch between EXT_direct_state_access and our own emulated DSA.
-    // The argument match the corresponding GL function, but there's an extra "GLenum bindingTarget" which gets used with
-    // the DSA emulation -- it contains the right GL_BINDING_TEXTURE_X to use.
-    typedef void (QOpenGLTextureHelper::*TextureParameteriMemberFunc)(GLuint texture, GLenum target, GLenum bindingTarget, GLenum pname, GLint param);
-    typedef void (QOpenGLTextureHelper::*TextureParameterivMemberFunc)(GLuint texture, GLenum target, GLenum bindingTarget, GLenum pname, const GLint *params);
-    typedef void (QOpenGLTextureHelper::*TextureParameterfMemberFunc)(GLuint texture, GLenum target, GLenum bindingTarget, GLenum pname, GLfloat param);
-    typedef void (QOpenGLTextureHelper::*TextureParameterfvMemberFunc)(GLuint texture, GLenum target, GLenum bindingTarget, GLenum pname, const GLfloat *params);
-    typedef void (QOpenGLTextureHelper::*GenerateTextureMipmapMemberFunc)(GLuint texture, GLenum target, GLenum bindingTarget);
-    typedef void (QOpenGLTextureHelper::*TextureStorage3DMemberFunc)(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth);
-    typedef void (QOpenGLTextureHelper::*TextureStorage2DMemberFunc)(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height);
-    typedef void (QOpenGLTextureHelper::*TextureStorage1DMemberFunc)(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei levels, GLenum internalFormat, GLsizei width);
-    typedef void (QOpenGLTextureHelper::*TextureStorage3DMultisampleMemberFunc)(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations);
-    typedef void (QOpenGLTextureHelper::*TextureStorage2DMultisampleMemberFunc)(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations);
-    typedef void (QOpenGLTextureHelper::*TextureImage3DMemberFunc)(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    typedef void (QOpenGLTextureHelper::*TextureImage2DMemberFunc)(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    typedef void (QOpenGLTextureHelper::*TextureImage1DMemberFunc)(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    typedef void (QOpenGLTextureHelper::*TextureSubImage3DMemberFunc)(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
-    typedef void (QOpenGLTextureHelper::*TextureSubImage2DMemberFunc)(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
-    typedef void (QOpenGLTextureHelper::*TextureSubImage1DMemberFunc)(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
-    typedef void (QOpenGLTextureHelper::*TextureImage3DMultisampleMemberFunc)(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations);
-    typedef void (QOpenGLTextureHelper::*TextureImage2DMultisampleMemberFunc)(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations);
-    typedef void (QOpenGLTextureHelper::*CompressedTextureSubImage1DMemberFunc)(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *bits);
-    typedef void (QOpenGLTextureHelper::*CompressedTextureSubImage2DMemberFunc)(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *bits);
-    typedef void (QOpenGLTextureHelper::*CompressedTextureSubImage3DMemberFunc)(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *bits);
-    typedef void (QOpenGLTextureHelper::*CompressedTextureImage1DMemberFunc)(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *bits);
-    typedef void (QOpenGLTextureHelper::*CompressedTextureImage2DMemberFunc)(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *bits);
-    typedef void (QOpenGLTextureHelper::*CompressedTextureImage3DMemberFunc)(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *bits);
-
-
-    TextureParameteriMemberFunc TextureParameteri;
-    TextureParameterivMemberFunc TextureParameteriv;
-    TextureParameterfMemberFunc TextureParameterf;
-    TextureParameterfvMemberFunc TextureParameterfv;
-    GenerateTextureMipmapMemberFunc GenerateTextureMipmap;
-    TextureStorage3DMemberFunc TextureStorage3D;
-    TextureStorage2DMemberFunc TextureStorage2D;
-    TextureStorage1DMemberFunc TextureStorage1D;
-    TextureStorage3DMultisampleMemberFunc TextureStorage3DMultisample;
-    TextureStorage2DMultisampleMemberFunc TextureStorage2DMultisample;
-    TextureImage3DMemberFunc TextureImage3D;
-    TextureImage2DMemberFunc TextureImage2D;
-    TextureImage1DMemberFunc TextureImage1D;
-    TextureSubImage3DMemberFunc TextureSubImage3D;
-    TextureSubImage2DMemberFunc TextureSubImage2D;
-    TextureSubImage1DMemberFunc TextureSubImage1D;
-    TextureImage3DMultisampleMemberFunc TextureImage3DMultisample;
-    TextureImage2DMultisampleMemberFunc TextureImage2DMultisample;
-    CompressedTextureSubImage1DMemberFunc CompressedTextureSubImage1D;
-    CompressedTextureSubImage2DMemberFunc CompressedTextureSubImage2D;
-    CompressedTextureSubImage3DMemberFunc CompressedTextureSubImage3D;
-    CompressedTextureImage1DMemberFunc CompressedTextureImage1D;
-    CompressedTextureImage2DMemberFunc CompressedTextureImage2D;
-    CompressedTextureImage3DMemberFunc CompressedTextureImage3D;
-
-    // Raw function pointers for core and DSA functions
-
-    // EXT_direct_state_access used when DSA is available
-    void (QOPENGLF_APIENTRYP TextureParameteriEXT)(GLuint texture, GLenum target, GLenum pname, GLint param);
-    void (QOPENGLF_APIENTRYP TextureParameterivEXT)(GLuint texture, GLenum target, GLenum pname, const GLint *params);
-    void (QOPENGLF_APIENTRYP TextureParameterfEXT)(GLuint texture, GLenum target, GLenum pname, GLfloat param);
-    void (QOPENGLF_APIENTRYP TextureParameterfvEXT)(GLuint texture, GLenum target, GLenum pname, const GLfloat *params);
-    void (QOPENGLF_APIENTRYP GenerateTextureMipmapEXT)(GLuint texture, GLenum target);
-    void (QOPENGLF_APIENTRYP TextureStorage3DEXT)(GLuint texture, GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth);
-    void (QOPENGLF_APIENTRYP TextureStorage2DEXT)(GLuint texture, GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height);
-    void (QOPENGLF_APIENTRYP TextureStorage1DEXT)(GLuint texture, GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width);
-    void (QOPENGLF_APIENTRYP TextureStorage3DMultisampleEXT)(GLuint texture, GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations);
-    void (QOPENGLF_APIENTRYP TextureStorage2DMultisampleEXT)(GLuint texture, GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations);
-    void (QOPENGLF_APIENTRYP TextureImage3DEXT)(GLuint texture, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void (QOPENGLF_APIENTRYP TextureImage2DEXT)(GLuint texture, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void (QOPENGLF_APIENTRYP TextureImage1DEXT)(GLuint texture, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void (QOPENGLF_APIENTRYP TextureSubImage3DEXT)(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
-    void (QOPENGLF_APIENTRYP TextureSubImage2DEXT)(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
-    void (QOPENGLF_APIENTRYP TextureSubImage1DEXT)(GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
-    void (QOPENGLF_APIENTRYP CompressedTextureSubImage1DEXT)(GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *bits);
-    void (QOPENGLF_APIENTRYP CompressedTextureSubImage2DEXT)(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *bits);
-    void (QOPENGLF_APIENTRYP CompressedTextureSubImage3DEXT)(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *bits);
-    void (QOPENGLF_APIENTRYP CompressedTextureImage1DEXT)(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *bits);
-    void (QOPENGLF_APIENTRYP CompressedTextureImage2DEXT)(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *bits);
-    void (QOPENGLF_APIENTRYP CompressedTextureImage3DEXT)(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *bits);
-
-
-    // Plus some missing ones that are in the NV_texture_multisample extension instead
-    void (QOPENGLF_APIENTRYP TextureImage3DMultisampleNV)(GLuint texture, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations);
-    void (QOPENGLF_APIENTRYP TextureImage2DMultisampleNV)(GLuint texture, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations);
-
-    // OpenGL 1.0
-    void (QOPENGLF_APIENTRYP TexImage1D)(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-
-    // OpenGL 1.1
-    void (QOPENGLF_APIENTRYP TexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
-
-    // OpenGL 1.2
-    void (QOPENGLF_APIENTRYP TexImage3D)(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void (QOPENGLF_APIENTRYP TexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
-
-    // OpenGL 1.3
-    void (QOPENGLF_APIENTRYP GetCompressedTexImage)(GLenum target, GLint level, GLvoid *img);
-    void (QOPENGLF_APIENTRYP CompressedTexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data);
-    GL_APICALL void (QOPENGLF_APIENTRYP CompressedTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void (QOPENGLF_APIENTRYP CompressedTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void (QOPENGLF_APIENTRYP CompressedTexImage1D)(GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data);
-    GL_APICALL void (QOPENGLF_APIENTRYP CompressedTexImage2D)(GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data);
-    void (QOPENGLF_APIENTRYP CompressedTexImage3D)(GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data);
-    GL_APICALL void (QOPENGLF_APIENTRYP ActiveTexture)(GLenum texture);
-
-    // OpenGL 3.0
-    GL_APICALL void (QOPENGLF_APIENTRYP GenerateMipmap)(GLenum target);
-
-    // OpenGL 3.2
-    void (QOPENGLF_APIENTRYP TexImage3DMultisample)(GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations);
-    void (QOPENGLF_APIENTRYP TexImage2DMultisample)(GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations);
-
-    // OpenGL 4.2
-    void (QOPENGLF_APIENTRYP TexStorage3D)(GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth);
-    void (QOPENGLF_APIENTRYP TexStorage2D)(GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height);
-    void (QOPENGLF_APIENTRYP TexStorage1D)(GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width);
-
-    // OpenGL 4.3
-    void (QOPENGLF_APIENTRYP TexStorage3DMultisample)(GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations);
-    void (QOPENGLF_APIENTRYP TexStorage2DMultisample)(GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations);
-    void (QOPENGLF_APIENTRYP TexBufferRange)(GLenum target, GLenum internalFormat, GLuint buffer, GLintptr offset, GLsizeiptr size);
-    void (QOPENGLF_APIENTRYP TextureView)(GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers);
-};
-
-QT_END_NAMESPACE
-
-#undef Q_CALL_MEMBER_FUNCTION
-
-#endif // QT_NO_OPENGL
-
-#endif // QOPENGLTEXTUREHELPER_P_H
diff --git a/src/gui/opengl/qopengltextureuploader.cpp b/src/gui/opengl/qopengltextureuploader.cpp
deleted file mode 100644
index 9e393bc47a..0000000000
--- a/src/gui/opengl/qopengltextureuploader.cpp
+++ /dev/null
@@ -1,381 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2018 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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/gui/opengl/qopengltextureuploader_p.h b/src/gui/opengl/qopengltextureuploader_p.h
deleted file mode 100644
index 0dcf709d7e..0000000000
--- a/src/gui/opengl/qopengltextureuploader_p.h
+++ /dev/null
@@ -1,84 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2018 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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 <QtGui/private/qtguiglobal_p.h>
-#include <QtGui/private/qopenglcontext_p.h>
-
-QT_BEGIN_NAMESPACE
-
-class QImage;
-
-class Q_GUI_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/gui/opengl/qopenglversionfunctions.cpp b/src/gui/opengl/qopenglversionfunctions.cpp
deleted file mode 100644
index 5a108335a9..0000000000
--- a/src/gui/opengl/qopenglversionfunctions.cpp
+++ /dev/null
@@ -1,353 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#include "qopenglversionfunctions.h"
-#include "qopenglcontext.h"
-#include "qdebug.h"
-
-QT_BEGIN_NAMESPACE
-
-#define QT_OPENGL_COUNT_FUNCTIONS(ret, name, args) +1
-#define QT_OPENGL_FUNCTION_NAMES(ret, name, args) \
-    "gl"#name"\0"
-#define QT_OPENGL_IMPLEMENT(CLASS, FUNCTIONS) \
-void CLASS::init() \
-{ \
-    const char *names = FUNCTIONS(QT_OPENGL_FUNCTION_NAMES); \
-    const char *name = names; \
-    for (int i = 0; i < FUNCTIONS(QT_OPENGL_COUNT_FUNCTIONS); ++i) { \
-        functions[i] = context->getProcAddress(name); \
-        name += strlen(name) + 1; \
-    } \
-}
-
-QOpenGLVersionFunctionsStorage::QOpenGLVersionFunctionsStorage()
-    : backends(nullptr)
-{
-}
-
-QOpenGLVersionFunctionsStorage::~QOpenGLVersionFunctionsStorage()
-{
-#ifndef QT_OPENGL_ES
-    if (backends) {
-
-        int i = 0;
-
-#define DELETE_BACKEND(X) \
-        if (backends[i] && !--backends[i]->refs) \
-            delete static_cast<QOpenGLFunctions_##X##Backend*>(backends[i]); \
-        ++i;
-
-        QT_OPENGL_VERSIONS(DELETE_BACKEND)
-#undef DELETE_BACKEND
-        delete[] backends;
-    }
-#endif
-}
-
-QOpenGLVersionFunctionsBackend *QOpenGLVersionFunctionsStorage::backend(QOpenGLContext *context, QOpenGLVersionFunctionsBackend::Version v)
-{
-#ifdef QT_OPENGL_ES
-    Q_UNUSED(context);
-    Q_UNUSED(v);
-    return 0;
-#else
-    if (!backends) {
-        backends = new QOpenGLVersionFunctionsBackend *[QOpenGLVersionFunctionsBackend::OpenGLVersionBackendCount];
-        memset(backends, 0, sizeof(QOpenGLVersionFunctionsBackend *)*QOpenGLVersionFunctionsBackend::OpenGLVersionBackendCount);
-    }
-    if (backends[v])
-        return backends[v];
-
-    switch(v) {
-#define VERSION_ENUM(X) QOpenGLVersionFunctionsBackend::OpenGL_##X
-#define CREATE_BACKEND(X) \
-    case VERSION_ENUM(X): \
-        backends[VERSION_ENUM(X)] = new QOpenGLFunctions_##X##Backend(context); \
-        break;
-    QT_OPENGL_VERSIONS(CREATE_BACKEND)
-    case QOpenGLVersionFunctionsBackend::OpenGLVersionBackendCount:
-        Q_UNREACHABLE();
-    }
-    // the storage keeps one ref
-    ++backends[v]->refs;
-    return backends[v];
-#endif
-}
-
-QOpenGLVersionFunctionsBackend *QAbstractOpenGLFunctionsPrivate::functionsBackend(QOpenGLContext *context, QOpenGLVersionFunctionsBackend::Version v)
-{
-    Q_ASSERT(context);
-    QOpenGLVersionFunctionsStorage *storage = context->functionsBackendStorage();
-    return storage->backend(context, v);
-}
-
-void QAbstractOpenGLFunctionsPrivate::insertExternalFunctions(QOpenGLContext *context, QAbstractOpenGLFunctions *f)
-{
-    Q_ASSERT(context);
-    context->insertExternalFunctions(f);
-}
-
-void QAbstractOpenGLFunctionsPrivate::removeExternalFunctions(QOpenGLContext *context, QAbstractOpenGLFunctions *f)
-{
-    Q_ASSERT(context);
-    context->removeExternalFunctions(f);
-}
-
-/*!
-    \class QAbstractOpenGLFunctions
-    \inmodule QtGui
-    \since 5.1
-    \brief The QAbstractOpenGLFunctions class is the base class of a family of
-           classes that expose all functions for each OpenGL version and
-           profile.
-
-    OpenGL implementations on different platforms are able to link to a variable
-    number of OpenGL functions depending upon the OpenGL ABI on that platform.
-    For example, on Microsoft Windows only functions up to those in OpenGL 1.1
-    can be linked to at build time. All other functions must be resolved at
-    runtime. The traditional solution to this has been to use either
-    QOpenGLContext::getProcAddress() or QOpenGLFunctions. The former is tedious
-    and error prone and means dealing directly with function pointers. The
-    latter only exposes those functions common to OpenGL ES 2 and desktop
-    OpenGL. There is however much new OpenGL functionality that is useful when
-    writing real world OpenGL applications.
-
-    Qt now provides a family of classes which all inherit from
-    QAbstractOpenGLFunctions which expose every core OpenGL function by way of a
-    corresponding member function. There is a class for every valid combination
-    of OpenGL version and profile. Each class follows the naming convention:
-    \badcode
-    QOpenGLFunctions_<MAJOR VERSION>_<MINOR VERSION>[_PROFILE]
-    \endcode
-
-    For OpenGL versions 1.0 through to 3.0 there are no profiles, leading to the
-    classes:
-
-    \list
-        \li QOpenGLFunctions_1_0
-        \li QOpenGLFunctions_1_1
-        \li QOpenGLFunctions_1_2
-        \li QOpenGLFunctions_1_3
-        \li QOpenGLFunctions_1_4
-        \li QOpenGLFunctions_1_5
-        \li QOpenGLFunctions_2_0
-        \li QOpenGLFunctions_2_1
-        \li QOpenGLFunctions_3_0
-    \endlist
-
-    where each class inherits from QAbstractOpenGLFunctions.
-
-    OpenGL version 3.1 removed many deprecated functions leading to a much
-    simpler and generic API.
-
-    With OpenGL 3.2 the concept of profiles was introduced. Two profiles are
-    currently defined for OpenGL: Core and Compatibility.
-
-    The Core profile does not include any of the functions that were removed
-    in OpenGL 3.1. The Compatibility profile contains all functions in the
-    Core profile of the same version plus all of the functions that were
-    removed in OpenGL 3.1. In this way the Compatibility profile classes allow
-    use of newer OpenGL functionality but also allows you to keep using your
-    legacy OpenGL code. For new OpenGL code the Core profile should be
-    preferred.
-
-    Please note that some vendors, notably Apple, do not implement the
-    Compatibility profile. Therefore if you wish to target new OpenGL features
-    on \macos then you should ensure that you request a Core profile context via
-    QSurfaceFormat::setProfile().
-
-    Qt provides classes for all version and Core and Compatibility profile
-    combinations. The classes for OpenGL versions 3.1 through to 4.3 are:
-
-    \list
-        \li QOpenGLFunctions_3_1
-        \li QOpenGLFunctions_3_2_Core
-        \li QOpenGLFunctions_3_2_Compatibility
-        \li QOpenGLFunctions_3_3_Core
-        \li QOpenGLFunctions_3_3_Compatibility
-        \li QOpenGLFunctions_4_0_Core
-        \li QOpenGLFunctions_4_0_Compatibility
-        \li QOpenGLFunctions_4_1_Core
-        \li QOpenGLFunctions_4_1_Compatibility
-        \li QOpenGLFunctions_4_2_Core
-        \li QOpenGLFunctions_4_2_Compatibility
-        \li QOpenGLFunctions_4_3_Core
-        \li QOpenGLFunctions_4_3_Compatibility
-    \endlist
-
-    where each class inherits from QAbstractOpenGLFunctions.
-
-    A pointer to an object of the class corresponding to the version and
-    profile of OpenGL in use can be obtained from
-    QOpenGLContext::versionFunctions(). If obtained in this way, note that
-    the QOpenGLContext retains ownership of the object. This is so that only
-    one instance need be created.
-
-    Before calling any of the exposed OpenGL functions you must ensure that the
-    object has resolved the function pointers to the OpenGL functions. This
-    only needs to be done once per instance with initializeOpenGLFunctions().
-    Once initialized, the object can be used to call any OpenGL function for
-    the corresponding version and profile. Note that initializeOpenGLFunctions()
-    can fail in some circumstances so check the return value. Situations in
-    which initialization can fail are if you have a functions object for a version
-    or profile that contains functions that are not part of the context being
-    used to resolve the function pointers.
-
-    If you exclusively use function objects then you will get compile time
-    errors if you attempt to use a function not included in that version and
-    profile. This is obviously a lot easier to debug than undefined behavior
-    at run time.
-
-    \sa QOpenGLContext::versionFunctions()
-*/
-/*!
-   Constructs a QAbstractOpenGLFunctions object.
-*/
-QAbstractOpenGLFunctions::QAbstractOpenGLFunctions()
-    : d_ptr(new QAbstractOpenGLFunctionsPrivate)
-{
-}
-
-/*!
-   Destroys a QAbstractOpenGLFunctions object.
-*/
-QAbstractOpenGLFunctions::~QAbstractOpenGLFunctions()
-{
-    Q_D(QAbstractOpenGLFunctions);
-    if (d->owningContext)
-        d->removeExternalFunctions(d->owningContext, this);
-    delete d_ptr;
-}
-
-/*! \internal
- */
-bool QAbstractOpenGLFunctions::initializeOpenGLFunctions()
-{
-    Q_D(QAbstractOpenGLFunctions);
-    d->initialized = true;
-
-    // For a subclass whose instance is not created via
-    // QOpenGLContext::versionFunctions() owningContext is not set. Set it now
-    // and register such instances to the context as external ones. These are
-    // not owned by the context but still need certain cleanup when the context
-    // is destroyed.
-    if (!d->owningContext) {
-        d->owningContext = QOpenGLContext::currentContext();
-        if (d->owningContext)
-            d->insertExternalFunctions(d->owningContext, this);
-    }
-
-    return true;
-}
-
-/*! \internal
- */
-bool QAbstractOpenGLFunctions::isInitialized() const
-{
-    Q_D(const QAbstractOpenGLFunctions);
-    return d->initialized;
-}
-
-/*! \internal
- */
-void QAbstractOpenGLFunctions::setOwningContext(const QOpenGLContext *context)
-{
-    Q_D(QAbstractOpenGLFunctions);
-    d->owningContext = const_cast<QOpenGLContext*>(context);
-}
-
-/*! \internal
- */
-QOpenGLContext *QAbstractOpenGLFunctions::owningContext() const
-{
-    Q_D(const QAbstractOpenGLFunctions);
-    return d->owningContext;
-}
-
-#if !defined(QT_OPENGL_ES_2)
-
-QT_OPENGL_IMPLEMENT(QOpenGLFunctions_1_0_CoreBackend, QT_OPENGL_1_0_FUNCTIONS)
-QT_OPENGL_IMPLEMENT(QOpenGLFunctions_1_1_CoreBackend, QT_OPENGL_1_1_FUNCTIONS)
-
-QT_OPENGL_IMPLEMENT(QOpenGLFunctions_1_2_CoreBackend, QT_OPENGL_1_2_FUNCTIONS)
-QT_OPENGL_IMPLEMENT(QOpenGLFunctions_1_3_CoreBackend, QT_OPENGL_1_3_FUNCTIONS)
-QT_OPENGL_IMPLEMENT(QOpenGLFunctions_1_4_CoreBackend, QT_OPENGL_1_4_FUNCTIONS)
-QT_OPENGL_IMPLEMENT(QOpenGLFunctions_1_5_CoreBackend, QT_OPENGL_1_5_FUNCTIONS)
-QT_OPENGL_IMPLEMENT(QOpenGLFunctions_2_0_CoreBackend, QT_OPENGL_2_0_FUNCTIONS)
-QT_OPENGL_IMPLEMENT(QOpenGLFunctions_2_1_CoreBackend, QT_OPENGL_2_1_FUNCTIONS)
-QT_OPENGL_IMPLEMENT(QOpenGLFunctions_3_0_CoreBackend, QT_OPENGL_3_0_FUNCTIONS)
-QT_OPENGL_IMPLEMENT(QOpenGLFunctions_3_1_CoreBackend, QT_OPENGL_3_1_FUNCTIONS)
-QT_OPENGL_IMPLEMENT(QOpenGLFunctions_3_2_CoreBackend, QT_OPENGL_3_2_FUNCTIONS)
-QT_OPENGL_IMPLEMENT(QOpenGLFunctions_3_3_CoreBackend, QT_OPENGL_3_3_FUNCTIONS)
-QT_OPENGL_IMPLEMENT(QOpenGLFunctions_4_0_CoreBackend, QT_OPENGL_4_0_FUNCTIONS)
-QT_OPENGL_IMPLEMENT(QOpenGLFunctions_4_1_CoreBackend, QT_OPENGL_4_1_FUNCTIONS)
-QT_OPENGL_IMPLEMENT(QOpenGLFunctions_4_2_CoreBackend, QT_OPENGL_4_2_FUNCTIONS)
-QT_OPENGL_IMPLEMENT(QOpenGLFunctions_4_3_CoreBackend, QT_OPENGL_4_3_FUNCTIONS)
-QT_OPENGL_IMPLEMENT(QOpenGLFunctions_4_4_CoreBackend, QT_OPENGL_4_4_FUNCTIONS)
-QT_OPENGL_IMPLEMENT(QOpenGLFunctions_4_5_CoreBackend, QT_OPENGL_4_5_FUNCTIONS)
-
-QT_OPENGL_IMPLEMENT(QOpenGLFunctions_1_0_DeprecatedBackend, QT_OPENGL_1_0_DEPRECATED_FUNCTIONS)
-QT_OPENGL_IMPLEMENT(QOpenGLFunctions_1_1_DeprecatedBackend, QT_OPENGL_1_1_DEPRECATED_FUNCTIONS)
-
-QT_OPENGL_IMPLEMENT(QOpenGLFunctions_1_2_DeprecatedBackend, QT_OPENGL_1_2_DEPRECATED_FUNCTIONS)
-QT_OPENGL_IMPLEMENT(QOpenGLFunctions_1_3_DeprecatedBackend, QT_OPENGL_1_3_DEPRECATED_FUNCTIONS)
-QT_OPENGL_IMPLEMENT(QOpenGLFunctions_1_4_DeprecatedBackend, QT_OPENGL_1_4_DEPRECATED_FUNCTIONS)
-QT_OPENGL_IMPLEMENT(QOpenGLFunctions_2_0_DeprecatedBackend, QT_OPENGL_2_0_DEPRECATED_FUNCTIONS)
-QT_OPENGL_IMPLEMENT(QOpenGLFunctions_3_0_DeprecatedBackend, QT_OPENGL_3_0_DEPRECATED_FUNCTIONS)
-QT_OPENGL_IMPLEMENT(QOpenGLFunctions_3_3_DeprecatedBackend, QT_OPENGL_3_3_DEPRECATED_FUNCTIONS)
-QT_OPENGL_IMPLEMENT(QOpenGLFunctions_4_5_DeprecatedBackend, QT_OPENGL_4_5_DEPRECATED_FUNCTIONS)
-
-#else
-
-// No backends for OpenGL ES 2
-
-#endif // !QT_OPENGL_ES_2
-
-QT_END_NAMESPACE
diff --git a/src/gui/opengl/qopenglversionfunctions.h b/src/gui/opengl/qopenglversionfunctions.h
deleted file mode 100644
index 4835ea4871..0000000000
--- a/src/gui/opengl/qopenglversionfunctions.h
+++ /dev/null
@@ -1,1912 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#ifndef QOPENGLVERSIONFUNCTIONS_H
-#define QOPENGLVERSIONFUNCTIONS_H
-
-#include <QtGui/qtguiglobal.h>
-
-#ifndef QT_NO_OPENGL
-
-#if QT_DEPRECATED_SINCE(5, 6)
-#include <QtCore/qhash.h>
-#endif
-#include <QtCore/qhashfunctions.h>
-#include <QtCore/qpair.h>
-#include <QtGui/qopengl.h>
-
-// MemoryBarrier is a macro on some architectures on Windows
-#ifdef Q_OS_WIN
-#pragma push_macro("MemoryBarrier")
-#undef MemoryBarrier
-#endif
-
-QT_BEGIN_NAMESPACE
-
-class QOpenGLContext;
-
-#if 0
-// silence syncqt warnings
-#pragma qt_class(QOpenGLVersionFunctions)
-#pragma qt_sync_stop_processing
-#endif
-
-#define QOPENGL_DEPRECATEDFUNCTION \
-    qFatal("This function was erroneously included in previous versions of Qt and is here only for binary compatibility. " \
-           "If you need to use this function, please use a legacy OpenGL version or a Compatibility profile.")
-
-struct QOpenGLVersionStatus
-{
-    enum OpenGLStatus {
-        CoreStatus,
-        DeprecatedStatus,
-        InvalidStatus
-    };
-
-    Q_DECL_CONSTEXPR QOpenGLVersionStatus()
-        : version(0, 0),
-          status(InvalidStatus)
-    {}
-
-    Q_DECL_CONSTEXPR QOpenGLVersionStatus(int majorVersion, int minorVersion, QOpenGLVersionStatus::OpenGLStatus functionStatus)
-        : version(majorVersion, minorVersion),
-          status(functionStatus)
-    {}
-
-    QPair<int, int> version;
-    OpenGLStatus status;
-};
-
-inline uint qHash(const QOpenGLVersionStatus &v, uint seed = 0) noexcept
-{
-    return qHash(static_cast<int>(v.status * 1000)
-               + v.version.first * 100 + v.version.second * 10, seed);
-}
-
-Q_DECL_CONSTEXPR inline bool operator==(const QOpenGLVersionStatus &lhs, const QOpenGLVersionStatus &rhs)
-{
-    return lhs.status == rhs.status && lhs.version == rhs.version;
-}
-
-Q_DECL_CONSTEXPR inline bool operator!=(const QOpenGLVersionStatus &lhs, const QOpenGLVersionStatus &rhs)
-{
-    return !operator==(lhs, rhs);
-}
-
-#define QT_OPENGL_DECLARE_FUNCTIONS(ret, name, args) \
-    ret (QOPENGLF_APIENTRYP name)args;
-#define QT_OPENGL_COUNT_FUNCTIONS(ret, name, args) +1
-
-#define QT_OPENGL_DECLARE(FUNCTIONS) \
-public: \
-    struct Functions { \
-        FUNCTIONS(QT_OPENGL_DECLARE_FUNCTIONS) \
-    }; \
-    union { \
-        QFunctionPointer functions[FUNCTIONS(QT_OPENGL_COUNT_FUNCTIONS)]; \
-        Functions f; \
-    }; \
-private: \
-    void init()
-
-class QOpenGLVersionFunctionsBackend
-{
-public:
-#define QT_OPENGL_VERSIONS(F) \
-        F(1_0_Core) \
-        F(1_1_Core) \
-        F(1_2_Core) \
-        F(1_3_Core) \
-        F(1_4_Core) \
-        F(1_5_Core) \
-        F(2_0_Core) \
-        F(2_1_Core) \
-        F(3_0_Core) \
-        F(3_1_Core) \
-        F(3_2_Core) \
-        F(3_3_Core) \
-        F(4_0_Core) \
-        F(4_1_Core) \
-        F(4_2_Core) \
-        F(4_3_Core) \
-        F(4_4_Core) \
-        F(4_5_Core) \
-        F(1_0_Deprecated) \
-        F(1_1_Deprecated) \
-        F(1_2_Deprecated) \
-        F(1_3_Deprecated) \
-        F(1_4_Deprecated) \
-        F(2_0_Deprecated) \
-        F(3_0_Deprecated) \
-        F(3_3_Deprecated) \
-        F(4_5_Deprecated) \
-
-#define VERSION_ENUM(X) OpenGL_##X,
-    enum Version {
-        QT_OPENGL_VERSIONS(VERSION_ENUM)
-        OpenGLVersionBackendCount
-    };
-#undef VERSION_ENUM
-
-    QOpenGLVersionFunctionsBackend(QOpenGLContext *ctx)
-        : context(ctx)
-    {}
-
-    QOpenGLContext *context;
-    QAtomicInt refs;
-};
-
-class QOpenGLVersionFunctionsStorage
-{
-public:
-    QOpenGLVersionFunctionsStorage();
-    ~QOpenGLVersionFunctionsStorage();
-
-    QOpenGLVersionFunctionsBackend *backend(QOpenGLContext *context, QOpenGLVersionFunctionsBackend::Version v);
-
-    QOpenGLVersionFunctionsBackend **backends;
-};
-
-class QAbstractOpenGLFunctions;
-
-class QAbstractOpenGLFunctionsPrivate
-{
-public:
-    QAbstractOpenGLFunctionsPrivate()
-        : owningContext(nullptr),
-          initialized(false)
-    {}
-
-    static QOpenGLVersionFunctionsBackend *functionsBackend(QOpenGLContext *context, QOpenGLVersionFunctionsBackend::Version v);
-    static void insertExternalFunctions(QOpenGLContext *context, QAbstractOpenGLFunctions *f);
-    static void removeExternalFunctions(QOpenGLContext *context, QAbstractOpenGLFunctions *f);
-
-    static QAbstractOpenGLFunctionsPrivate *get(QAbstractOpenGLFunctions *q);
-
-    QOpenGLContext *owningContext;
-    bool initialized;
-};
-
-class Q_GUI_EXPORT QAbstractOpenGLFunctions
-{
-public:
-    virtual ~QAbstractOpenGLFunctions();
-
-    virtual bool initializeOpenGLFunctions();
-
-    Q_DISABLE_COPY(QAbstractOpenGLFunctions)
-    Q_DECLARE_PRIVATE(QAbstractOpenGLFunctions)
-
-protected:
-    QAbstractOpenGLFunctions();
-    QAbstractOpenGLFunctionsPrivate *d_ptr;
-
-    bool isInitialized() const;
-
-    void setOwningContext(const QOpenGLContext *context);
-    QOpenGLContext *owningContext() const;
-
-    friend class QOpenGLContext;
-};
-
-inline QAbstractOpenGLFunctionsPrivate *QAbstractOpenGLFunctionsPrivate::get(QAbstractOpenGLFunctions *q)
-{
-    return q->d_func();
-}
-
-#if !defined(QT_OPENGL_ES_2)
-
-class QOpenGLFunctions_1_0_CoreBackend : public QOpenGLVersionFunctionsBackend
-{
-public:
-    QOpenGLFunctions_1_0_CoreBackend(QOpenGLContext *c)
-        : QOpenGLVersionFunctionsBackend(c)
-    {
-        init();
-    }
-
-    Q_DECL_CONSTEXPR static Version versionStatus()
-    { return OpenGL_1_0_Core; }
-
-    // OpenGL 1.0 core functions
-#define QT_OPENGL_1_0_FUNCTIONS(F) \
-    F(void, Viewport, (GLint x, GLint y, GLsizei width, GLsizei height)) \
-    F(void, DepthRange, (GLdouble nearVal, GLdouble farVal)) \
-    F(GLboolean, IsEnabled, (GLenum cap)) \
-    F(void, GetTexLevelParameteriv, (GLenum target, GLint level, GLenum pname, GLint *params)) \
-    F(void, GetTexLevelParameterfv, (GLenum target, GLint level, GLenum pname, GLfloat *params)) \
-    F(void, GetTexParameteriv, (GLenum target, GLenum pname, GLint *params)) \
-    F(void, GetTexParameterfv, (GLenum target, GLenum pname, GLfloat *params)) \
-    F(void, GetTexImage, (GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)) \
-    F(const GLubyte *, GetString, (GLenum name)) \
-    F(void, GetIntegerv, (GLenum pname, GLint *data)) \
-    F(void, GetFloatv, (GLenum pname, GLfloat *data)) \
-    F(GLenum, GetError, ()) \
-    F(void, GetDoublev, (GLenum pname, GLdouble *data)) \
-    F(void, GetBooleanv, (GLenum pname, GLboolean *data)) \
-    F(void, ReadPixels, (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)) \
-    F(void, ReadBuffer, (GLenum src)) \
-    F(void, PixelStorei, (GLenum pname, GLint param)) \
-    F(void, PixelStoref, (GLenum pname, GLfloat param)) \
-    F(void, DepthFunc, (GLenum func)) \
-    F(void, StencilOp, (GLenum fail, GLenum zfail, GLenum zpass)) \
-    F(void, StencilFunc, (GLenum func, GLint ref, GLuint mask)) \
-    F(void, LogicOp, (GLenum opcode)) \
-    F(void, BlendFunc, (GLenum sfactor, GLenum dfactor)) \
-    F(void, Flush, ()) \
-    F(void, Finish, ()) \
-    F(void, Enable, (GLenum cap)) \
-    F(void, Disable, (GLenum cap)) \
-    F(void, DepthMask, (GLboolean flag)) \
-    F(void, ColorMask, (GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)) \
-    F(void, StencilMask, (GLuint mask)) \
-    F(void, ClearDepth, (GLdouble depth)) \
-    F(void, ClearStencil, (GLint s)) \
-    F(void, ClearColor, (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)) \
-    F(void, Clear, (GLbitfield mask)) \
-    F(void, DrawBuffer, (GLenum buf)) \
-    F(void, TexImage2D, (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)) \
-    F(void, TexImage1D, (GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)) \
-    F(void, TexParameteriv, (GLenum target, GLenum pname, const GLint *params)) \
-    F(void, TexParameteri, (GLenum target, GLenum pname, GLint param)) \
-    F(void, TexParameterfv, (GLenum target, GLenum pname, const GLfloat *params)) \
-    F(void, TexParameterf, (GLenum target, GLenum pname, GLfloat param)) \
-    F(void, Scissor, (GLint x, GLint y, GLsizei width, GLsizei height)) \
-    F(void, PolygonMode, (GLenum face, GLenum mode)) \
-    F(void, PointSize, (GLfloat size)) \
-    F(void, LineWidth, (GLfloat width)) \
-    F(void, Hint, (GLenum target, GLenum mode)) \
-    F(void, FrontFace, (GLenum mode)) \
-    F(void, CullFace, (GLenum mode)) \
-
-    QT_OPENGL_DECLARE(QT_OPENGL_1_0_FUNCTIONS);
-};
-
-class QOpenGLFunctions_1_1_CoreBackend : public QOpenGLVersionFunctionsBackend
-{
-public:
-    QOpenGLFunctions_1_1_CoreBackend(QOpenGLContext *c)
-        : QOpenGLVersionFunctionsBackend(c)
-    {
-        init();
-    }
-
-    Q_DECL_CONSTEXPR static Version versionStatus()
-    { return OpenGL_1_1_Core; }
-
-    // OpenGL 1.1 core functions
-#define QT_OPENGL_1_1_FUNCTIONS(F) \
-    F(void, Indexubv, (const GLubyte *c)) \
-    F(void, Indexub, (GLubyte c)) \
-    F(GLboolean, IsTexture, (GLuint texture)) \
-    F(void, GenTextures, (GLsizei n, GLuint *textures)) \
-    F(void, DeleteTextures, (GLsizei n, const GLuint *textures)) \
-    F(void, BindTexture, (GLenum target, GLuint texture)) \
-    F(void, TexSubImage2D, (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)) \
-    F(void, TexSubImage1D, (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)) \
-    F(void, CopyTexSubImage2D, (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)) \
-    F(void, CopyTexSubImage1D, (GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)) \
-    F(void, CopyTexImage2D, (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)) \
-    F(void, CopyTexImage1D, (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)) \
-    F(void, PolygonOffset, (GLfloat factor, GLfloat units)) \
-    F(void, GetPointerv, (GLenum pname, GLvoid* *params)) \
-    F(void, DrawElements, (GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)) \
-    F(void, DrawArrays, (GLenum mode, GLint first, GLsizei count)) \
-
-    QT_OPENGL_DECLARE(QT_OPENGL_1_1_FUNCTIONS);
-};
-
-class QOpenGLFunctions_1_2_CoreBackend : public QOpenGLVersionFunctionsBackend
-{
-public:
-    QOpenGLFunctions_1_2_CoreBackend(QOpenGLContext *c)
-        : QOpenGLVersionFunctionsBackend(c)
-    {
-        init();
-    }
-
-    Q_DECL_CONSTEXPR static Version versionStatus()
-    { return OpenGL_1_2_Core; }
-
-    // OpenGL 1.2 core functions
-#define QT_OPENGL_1_2_FUNCTIONS(F) \
-    F(void, CopyTexSubImage3D, (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)) \
-    F(void, TexSubImage3D, (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)) \
-    F(void, TexImage3D, (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)) \
-    F(void, DrawRangeElements, (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)) \
-    F(void, BlendEquation, (GLenum mode)) \
-    F(void, BlendColor, (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)) \
-
-    QT_OPENGL_DECLARE(QT_OPENGL_1_2_FUNCTIONS);
-};
-
-class QOpenGLFunctions_1_3_CoreBackend : public QOpenGLVersionFunctionsBackend
-{
-public:
-    QOpenGLFunctions_1_3_CoreBackend(QOpenGLContext *c)
-        : QOpenGLVersionFunctionsBackend(c)
-    {
-        init();
-    }
-
-    Q_DECL_CONSTEXPR static Version versionStatus()
-    { return OpenGL_1_3_Core; }
-
-    // OpenGL 1.3 core functions
-#define QT_OPENGL_1_3_FUNCTIONS(F) \
-    F(void, GetCompressedTexImage, (GLenum target, GLint level, GLvoid *img)) \
-    F(void, CompressedTexSubImage1D, (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)) \
-    F(void, CompressedTexSubImage2D, (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)) \
-    F(void, CompressedTexSubImage3D, (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)) \
-    F(void, CompressedTexImage1D, (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data)) \
-    F(void, CompressedTexImage2D, (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)) \
-    F(void, CompressedTexImage3D, (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)) \
-    F(void, SampleCoverage, (GLfloat value, GLboolean invert)) \
-    F(void, ActiveTexture, (GLenum texture)) \
-
-    QT_OPENGL_DECLARE(QT_OPENGL_1_3_FUNCTIONS);
-};
-
-class QOpenGLFunctions_1_4_CoreBackend : public QOpenGLVersionFunctionsBackend
-{
-public:
-    QOpenGLFunctions_1_4_CoreBackend(QOpenGLContext *c)
-        : QOpenGLVersionFunctionsBackend(c)
-    {
-        init();
-    }
-
-    Q_DECL_CONSTEXPR static Version versionStatus()
-    { return OpenGL_1_4_Core; }
-
-    // OpenGL 1.4 core functions
-#define QT_OPENGL_1_4_FUNCTIONS(F) \
-    F(void, PointParameteriv, (GLenum pname, const GLint *params)) \
-    F(void, PointParameteri, (GLenum pname, GLint param)) \
-    F(void, PointParameterfv, (GLenum pname, const GLfloat *params)) \
-    F(void, PointParameterf, (GLenum pname, GLfloat param)) \
-    F(void, MultiDrawElements, (GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount)) \
-    F(void, MultiDrawArrays, (GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)) \
-    F(void, BlendFuncSeparate, (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)) \
-
-    QT_OPENGL_DECLARE(QT_OPENGL_1_4_FUNCTIONS);
-};
-
-class QOpenGLFunctions_1_5_CoreBackend : public QOpenGLVersionFunctionsBackend
-{
-public:
-    QOpenGLFunctions_1_5_CoreBackend(QOpenGLContext *c)
-        : QOpenGLVersionFunctionsBackend(c)
-    {
-        init();
-    }
-
-    Q_DECL_CONSTEXPR static Version versionStatus()
-    { return OpenGL_1_5_Core; }
-
-    // OpenGL 1.5 core functions
-#define QT_OPENGL_1_5_FUNCTIONS(F) \
-    F(void, GetBufferPointerv, (GLenum target, GLenum pname, GLvoid* *params)) \
-    F(void, GetBufferParameteriv, (GLenum target, GLenum pname, GLint *params)) \
-    F(GLboolean, UnmapBuffer, (GLenum target)) \
-    F(GLvoid*, MapBuffer, (GLenum target, GLenum access)) \
-    F(void, GetBufferSubData, (GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data)) \
-    F(void, BufferSubData, (GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data)) \
-    F(void, BufferData, (GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)) \
-    F(GLboolean, IsBuffer, (GLuint buffer)) \
-    F(void, GenBuffers, (GLsizei n, GLuint *buffers)) \
-    F(void, DeleteBuffers, (GLsizei n, const GLuint *buffers)) \
-    F(void, BindBuffer, (GLenum target, GLuint buffer)) \
-    F(void, GetQueryObjectuiv, (GLuint id, GLenum pname, GLuint *params)) \
-    F(void, GetQueryObjectiv, (GLuint id, GLenum pname, GLint *params)) \
-    F(void, GetQueryiv, (GLenum target, GLenum pname, GLint *params)) \
-    F(void, EndQuery, (GLenum target)) \
-    F(void, BeginQuery, (GLenum target, GLuint id)) \
-    F(GLboolean, IsQuery, (GLuint id)) \
-    F(void, DeleteQueries, (GLsizei n, const GLuint *ids)) \
-    F(void, GenQueries, (GLsizei n, GLuint *ids)) \
-
-    QT_OPENGL_DECLARE(QT_OPENGL_1_5_FUNCTIONS);
-};
-
-class QOpenGLFunctions_2_0_CoreBackend : public QOpenGLVersionFunctionsBackend
-{
-public:
-    QOpenGLFunctions_2_0_CoreBackend(QOpenGLContext *c)
-        : QOpenGLVersionFunctionsBackend(c)
-    {
-        init();
-    }
-
-    Q_DECL_CONSTEXPR static Version versionStatus()
-    { return OpenGL_2_0_Core; }
-
-    // OpenGL 2.0 core functions
-#define QT_OPENGL_2_0_FUNCTIONS(F) \
-    F(void, VertexAttribPointer, (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer)) \
-    F(void, ValidateProgram, (GLuint program)) \
-    F(void, UniformMatrix4fv, (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) \
-    F(void, UniformMatrix3fv, (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) \
-    F(void, UniformMatrix2fv, (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) \
-    F(void, Uniform4iv, (GLint location, GLsizei count, const GLint *value)) \
-    F(void, Uniform3iv, (GLint location, GLsizei count, const GLint *value)) \
-    F(void, Uniform2iv, (GLint location, GLsizei count, const GLint *value)) \
-    F(void, Uniform1iv, (GLint location, GLsizei count, const GLint *value)) \
-    F(void, Uniform4fv, (GLint location, GLsizei count, const GLfloat *value)) \
-    F(void, Uniform3fv, (GLint location, GLsizei count, const GLfloat *value)) \
-    F(void, Uniform2fv, (GLint location, GLsizei count, const GLfloat *value)) \
-    F(void, Uniform1fv, (GLint location, GLsizei count, const GLfloat *value)) \
-    F(void, Uniform4i, (GLint location, GLint v0, GLint v1, GLint v2, GLint v3)) \
-    F(void, Uniform3i, (GLint location, GLint v0, GLint v1, GLint v2)) \
-    F(void, Uniform2i, (GLint location, GLint v0, GLint v1)) \
-    F(void, Uniform1i, (GLint location, GLint v0)) \
-    F(void, Uniform4f, (GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)) \
-    F(void, Uniform3f, (GLint location, GLfloat v0, GLfloat v1, GLfloat v2)) \
-    F(void, Uniform2f, (GLint location, GLfloat v0, GLfloat v1)) \
-    F(void, Uniform1f, (GLint location, GLfloat v0)) \
-    F(void, UseProgram, (GLuint program)) \
-    F(void, ShaderSource, (GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length)) \
-    F(void, LinkProgram, (GLuint program)) \
-    F(GLboolean, IsShader, (GLuint shader)) \
-    F(GLboolean, IsProgram, (GLuint program)) \
-    F(void, GetVertexAttribPointerv, (GLuint index, GLenum pname, GLvoid* *pointer)) \
-    F(void, GetVertexAttribiv, (GLuint index, GLenum pname, GLint *params)) \
-    F(void, GetVertexAttribfv, (GLuint index, GLenum pname, GLfloat *params)) \
-    F(void, GetVertexAttribdv, (GLuint index, GLenum pname, GLdouble *params)) \
-    F(void, GetUniformiv, (GLuint program, GLint location, GLint *params)) \
-    F(void, GetUniformfv, (GLuint program, GLint location, GLfloat *params)) \
-    F(GLint, GetUniformLocation, (GLuint program, const GLchar *name)) \
-    F(void, GetShaderSource, (GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)) \
-    F(void, GetShaderInfoLog, (GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)) \
-    F(void, GetShaderiv, (GLuint shader, GLenum pname, GLint *params)) \
-    F(void, GetProgramInfoLog, (GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)) \
-    F(void, GetProgramiv, (GLuint program, GLenum pname, GLint *params)) \
-    F(GLint, GetAttribLocation, (GLuint program, const GLchar *name)) \
-    F(void, GetAttachedShaders, (GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders)) \
-    F(void, GetActiveUniform, (GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)) \
-    F(void, GetActiveAttrib, (GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)) \
-    F(void, EnableVertexAttribArray, (GLuint index)) \
-    F(void, DisableVertexAttribArray, (GLuint index)) \
-    F(void, DetachShader, (GLuint program, GLuint shader)) \
-    F(void, DeleteShader, (GLuint shader)) \
-    F(void, DeleteProgram, (GLuint program)) \
-    F(GLuint, CreateShader, (GLenum type)) \
-    F(GLuint, CreateProgram, ()) \
-    F(void, CompileShader, (GLuint shader)) \
-    F(void, BindAttribLocation, (GLuint program, GLuint index, const GLchar *name)) \
-    F(void, AttachShader, (GLuint program, GLuint shader)) \
-    F(void, StencilMaskSeparate, (GLenum face, GLuint mask)) \
-    F(void, StencilFuncSeparate, (GLenum face, GLenum func, GLint ref, GLuint mask)) \
-    F(void, StencilOpSeparate, (GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)) \
-    F(void, DrawBuffers, (GLsizei n, const GLenum *bufs)) \
-    F(void, BlendEquationSeparate, (GLenum modeRGB, GLenum modeAlpha)) \
-    F(void, VertexAttrib4usv, (GLuint index, const GLushort *v)) \
-    F(void, VertexAttrib4uiv, (GLuint index, const GLuint *v)) \
-    F(void, VertexAttrib4ubv, (GLuint index, const GLubyte *v)) \
-    F(void, VertexAttrib4sv, (GLuint index, const GLshort *v)) \
-    F(void, VertexAttrib4s, (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)) \
-    F(void, VertexAttrib4iv, (GLuint index, const GLint *v)) \
-    F(void, VertexAttrib4fv, (GLuint index, const GLfloat *v)) \
-    F(void, VertexAttrib4f, (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)) \
-    F(void, VertexAttrib4dv, (GLuint index, const GLdouble *v)) \
-    F(void, VertexAttrib4d, (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)) \
-    F(void, VertexAttrib4bv, (GLuint index, const GLbyte *v)) \
-    F(void, VertexAttrib4Nusv, (GLuint index, const GLushort *v)) \
-    F(void, VertexAttrib4Nuiv, (GLuint index, const GLuint *v)) \
-    F(void, VertexAttrib4Nubv, (GLuint index, const GLubyte *v)) \
-    F(void, VertexAttrib4Nub, (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)) \
-    F(void, VertexAttrib4Nsv, (GLuint index, const GLshort *v)) \
-    F(void, VertexAttrib4Niv, (GLuint index, const GLint *v)) \
-    F(void, VertexAttrib4Nbv, (GLuint index, const GLbyte *v)) \
-    F(void, VertexAttrib3sv, (GLuint index, const GLshort *v)) \
-    F(void, VertexAttrib3s, (GLuint index, GLshort x, GLshort y, GLshort z)) \
-    F(void, VertexAttrib3fv, (GLuint index, const GLfloat *v)) \
-    F(void, VertexAttrib3f, (GLuint index, GLfloat x, GLfloat y, GLfloat z)) \
-    F(void, VertexAttrib3dv, (GLuint index, const GLdouble *v)) \
-    F(void, VertexAttrib3d, (GLuint index, GLdouble x, GLdouble y, GLdouble z)) \
-    F(void, VertexAttrib2sv, (GLuint index, const GLshort *v)) \
-    F(void, VertexAttrib2s, (GLuint index, GLshort x, GLshort y)) \
-    F(void, VertexAttrib2fv, (GLuint index, const GLfloat *v)) \
-    F(void, VertexAttrib2f, (GLuint index, GLfloat x, GLfloat y)) \
-    F(void, VertexAttrib2dv, (GLuint index, const GLdouble *v)) \
-    F(void, VertexAttrib2d, (GLuint index, GLdouble x, GLdouble y)) \
-    F(void, VertexAttrib1sv, (GLuint index, const GLshort *v)) \
-    F(void, VertexAttrib1s, (GLuint index, GLshort x)) \
-    F(void, VertexAttrib1fv, (GLuint index, const GLfloat *v)) \
-    F(void, VertexAttrib1f, (GLuint index, GLfloat x)) \
-    F(void, VertexAttrib1dv, (GLuint index, const GLdouble *v)) \
-    F(void, VertexAttrib1d, (GLuint index, GLdouble x)) \
-
-    QT_OPENGL_DECLARE(QT_OPENGL_2_0_FUNCTIONS);
-};
-
-class QOpenGLFunctions_2_1_CoreBackend : public QOpenGLVersionFunctionsBackend
-{
-public:
-    QOpenGLFunctions_2_1_CoreBackend(QOpenGLContext *c)
-        : QOpenGLVersionFunctionsBackend(c)
-    {
-        init();
-    }
-
-    Q_DECL_CONSTEXPR static Version versionStatus()
-    { return OpenGL_2_1_Core; }
-
-    // OpenGL 2.1 core functions
-#define QT_OPENGL_2_1_FUNCTIONS(F) \
-    F(void, UniformMatrix4x3fv, (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) \
-    F(void, UniformMatrix3x4fv, (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) \
-    F(void, UniformMatrix4x2fv, (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) \
-    F(void, UniformMatrix2x4fv, (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) \
-    F(void, UniformMatrix3x2fv, (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) \
-    F(void, UniformMatrix2x3fv, (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) \
-
-    QT_OPENGL_DECLARE(QT_OPENGL_2_1_FUNCTIONS);
-};
-
-class QOpenGLFunctions_3_0_CoreBackend : public QOpenGLVersionFunctionsBackend
-{
-public:
-    QOpenGLFunctions_3_0_CoreBackend(QOpenGLContext *c)
-        : QOpenGLVersionFunctionsBackend(c)
-    {
-        init();
-    }
-
-    Q_DECL_CONSTEXPR static Version versionStatus()
-    { return OpenGL_3_0_Core; }
-
-    // OpenGL 3.0 core functions
-#define QT_OPENGL_3_0_FUNCTIONS(F) \
-    F(GLboolean, IsVertexArray, (GLuint array)) \
-    F(void, GenVertexArrays, (GLsizei n, GLuint *arrays)) \
-    F(void, DeleteVertexArrays, (GLsizei n, const GLuint *arrays)) \
-    F(void, BindVertexArray, (GLuint array)) \
-    F(void, FlushMappedBufferRange, (GLenum target, GLintptr offset, GLsizeiptr length)) \
-    F(GLvoid *, MapBufferRange, (GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)) \
-    F(void, FramebufferTextureLayer, (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)) \
-    F(void, RenderbufferStorageMultisample, (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)) \
-    F(void, BlitFramebuffer, (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)) \
-    F(void, GenerateMipmap, (GLenum target)) \
-    F(void, GetFramebufferAttachmentParameteriv, (GLenum target, GLenum attachment, GLenum pname, GLint *params)) \
-    F(void, FramebufferRenderbuffer, (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)) \
-    F(void, FramebufferTexture3D, (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)) \
-    F(void, FramebufferTexture2D, (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)) \
-    F(void, FramebufferTexture1D, (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)) \
-    F(GLenum, CheckFramebufferStatus, (GLenum target)) \
-    F(void, GenFramebuffers, (GLsizei n, GLuint *framebuffers)) \
-    F(void, DeleteFramebuffers, (GLsizei n, const GLuint *framebuffers)) \
-    F(void, BindFramebuffer, (GLenum target, GLuint framebuffer)) \
-    F(GLboolean, IsFramebuffer, (GLuint framebuffer)) \
-    F(void, GetRenderbufferParameteriv, (GLenum target, GLenum pname, GLint *params)) \
-    F(void, RenderbufferStorage, (GLenum target, GLenum internalformat, GLsizei width, GLsizei height)) \
-    F(void, GenRenderbuffers, (GLsizei n, GLuint *renderbuffers)) \
-    F(void, DeleteRenderbuffers, (GLsizei n, const GLuint *renderbuffers)) \
-    F(void, BindRenderbuffer, (GLenum target, GLuint renderbuffer)) \
-    F(GLboolean, IsRenderbuffer, (GLuint renderbuffer)) \
-    F(const GLubyte *, GetStringi, (GLenum name, GLuint index)) \
-    F(void, ClearBufferfi, (GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)) \
-    F(void, ClearBufferfv, (GLenum buffer, GLint drawbuffer, const GLfloat *value)) \
-    F(void, ClearBufferuiv, (GLenum buffer, GLint drawbuffer, const GLuint *value)) \
-    F(void, ClearBufferiv, (GLenum buffer, GLint drawbuffer, const GLint *value)) \
-    F(void, GetTexParameterIuiv, (GLenum target, GLenum pname, GLuint *params)) \
-    F(void, GetTexParameterIiv, (GLenum target, GLenum pname, GLint *params)) \
-    F(void, TexParameterIuiv, (GLenum target, GLenum pname, const GLuint *params)) \
-    F(void, TexParameterIiv, (GLenum target, GLenum pname, const GLint *params)) \
-    F(void, Uniform4uiv, (GLint location, GLsizei count, const GLuint *value)) \
-    F(void, Uniform3uiv, (GLint location, GLsizei count, const GLuint *value)) \
-    F(void, Uniform2uiv, (GLint location, GLsizei count, const GLuint *value)) \
-    F(void, Uniform1uiv, (GLint location, GLsizei count, const GLuint *value)) \
-    F(void, Uniform4ui, (GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)) \
-    F(void, Uniform3ui, (GLint location, GLuint v0, GLuint v1, GLuint v2)) \
-    F(void, Uniform2ui, (GLint location, GLuint v0, GLuint v1)) \
-    F(void, Uniform1ui, (GLint location, GLuint v0)) \
-    F(GLint, GetFragDataLocation, (GLuint program, const GLchar *name)) \
-    F(void, BindFragDataLocation, (GLuint program, GLuint color, const GLchar *name)) \
-    F(void, GetUniformuiv, (GLuint program, GLint location, GLuint *params)) \
-    F(void, GetVertexAttribIuiv, (GLuint index, GLenum pname, GLuint *params)) \
-    F(void, GetVertexAttribIiv, (GLuint index, GLenum pname, GLint *params)) \
-    F(void, VertexAttribIPointer, (GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)) \
-    F(void, EndConditionalRender, ()) \
-    F(void, BeginConditionalRender, (GLuint id, GLenum mode)) \
-    F(void, ClampColor, (GLenum target, GLenum clamp)) \
-    F(void, GetTransformFeedbackVarying, (GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)) \
-    F(void, TransformFeedbackVaryings, (GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode)) \
-    F(void, BindBufferBase, (GLenum target, GLuint index, GLuint buffer)) \
-    F(void, BindBufferRange, (GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)) \
-    F(void, EndTransformFeedback, ()) \
-    F(void, BeginTransformFeedback, (GLenum primitiveMode)) \
-    F(GLboolean, IsEnabledi, (GLenum target, GLuint index)) \
-    F(void, Disablei, (GLenum target, GLuint index)) \
-    F(void, Enablei, (GLenum target, GLuint index)) \
-    F(void, GetIntegeri_v,(GLenum target, GLuint index, GLint *data)) \
-    F(void, GetBooleani_v,(GLenum target, GLuint index, GLboolean *data)) \
-    F(void, ColorMaski, (GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)) \
-    F(void, VertexAttribI4usv, (GLuint index, const GLushort *v)) \
-    F(void, VertexAttribI4ubv, (GLuint index, const GLubyte *v)) \
-    F(void, VertexAttribI4sv, (GLuint index, const GLshort *v)) \
-    F(void, VertexAttribI4bv, (GLuint index, const GLbyte *v)) \
-    F(void, VertexAttribI4uiv, (GLuint index, const GLuint *v)) \
-    F(void, VertexAttribI3uiv, (GLuint index, const GLuint *v)) \
-    F(void, VertexAttribI2uiv, (GLuint index, const GLuint *v)) \
-    F(void, VertexAttribI1uiv, (GLuint index, const GLuint *v)) \
-    F(void, VertexAttribI4iv, (GLuint index, const GLint *v)) \
-    F(void, VertexAttribI3iv, (GLuint index, const GLint *v)) \
-    F(void, VertexAttribI2iv, (GLuint index, const GLint *v)) \
-    F(void, VertexAttribI1iv, (GLuint index, const GLint *v)) \
-    F(void, VertexAttribI4ui, (GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)) \
-    F(void, VertexAttribI3ui, (GLuint index, GLuint x, GLuint y, GLuint z)) \
-    F(void, VertexAttribI2ui, (GLuint index, GLuint x, GLuint y)) \
-    F(void, VertexAttribI1ui, (GLuint index, GLuint x)) \
-    F(void, VertexAttribI4i, (GLuint index, GLint x, GLint y, GLint z, GLint w)) \
-    F(void, VertexAttribI3i, (GLuint index, GLint x, GLint y, GLint z)) \
-    F(void, VertexAttribI2i, (GLuint index, GLint x, GLint y)) \
-    F(void, VertexAttribI1i, (GLuint index, GLint x)) \
-
-    QT_OPENGL_DECLARE(QT_OPENGL_3_0_FUNCTIONS);
-};
-
-class QOpenGLFunctions_3_1_CoreBackend : public QOpenGLVersionFunctionsBackend
-{
-public:
-    QOpenGLFunctions_3_1_CoreBackend(QOpenGLContext *c)
-        : QOpenGLVersionFunctionsBackend(c)
-    {
-        init();
-    }
-
-    Q_DECL_CONSTEXPR static Version versionStatus()
-    { return OpenGL_3_1_Core; }
-
-    // OpenGL 3.1 core functions
-#define QT_OPENGL_3_1_FUNCTIONS(F) \
-    F(void, CopyBufferSubData, (GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)) \
-    F(void, UniformBlockBinding, (GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)) \
-    F(void, GetActiveUniformBlockName, (GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)) \
-    F(void, GetActiveUniformBlockiv, (GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params)) \
-    F(GLuint, GetUniformBlockIndex, (GLuint program, const GLchar *uniformBlockName)) \
-    F(void, GetActiveUniformName, (GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName)) \
-    F(void, GetActiveUniformsiv, (GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params)) \
-    F(void, GetUniformIndices, (GLuint program, GLsizei uniformCount, const GLchar* const *uniformNames, GLuint *uniformIndices)) \
-    F(void, PrimitiveRestartIndex, (GLuint index)) \
-    F(void, TexBuffer, (GLenum target, GLenum internalformat, GLuint buffer)) \
-    F(void, DrawElementsInstanced, (GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount)) \
-    F(void, DrawArraysInstanced, (GLenum mode, GLint first, GLsizei count, GLsizei instancecount)) \
-
-    QT_OPENGL_DECLARE(QT_OPENGL_3_1_FUNCTIONS);
-};
-
-class QOpenGLFunctions_3_2_CoreBackend : public QOpenGLVersionFunctionsBackend
-{
-public:
-    QOpenGLFunctions_3_2_CoreBackend(QOpenGLContext *c)
-        : QOpenGLVersionFunctionsBackend(c)
-    {
-        init();
-    }
-
-    Q_DECL_CONSTEXPR static Version versionStatus()
-    { return OpenGL_3_2_Core; }
-
-    // OpenGL 3.2 core functions
-#define QT_OPENGL_3_2_FUNCTIONS(F) \
-    F(void, SampleMaski, (GLuint maskNumber, GLbitfield mask)) \
-    F(void, GetMultisamplefv, (GLenum pname, GLuint index, GLfloat *val)) \
-    F(void, TexImage3DMultisample, (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)) \
-    F(void, TexImage2DMultisample, (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)) \
-    F(void, GetSynciv, (GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values)) \
-    F(void, GetInteger64v, (GLenum pname, GLint64 *data)) \
-    F(void, WaitSync, (GLsync sync, GLbitfield flags, GLuint64 timeout)) \
-    F(GLenum, ClientWaitSync, (GLsync sync, GLbitfield flags, GLuint64 timeout)) \
-    F(void, DeleteSync, (GLsync sync)) \
-    F(GLboolean, IsSync, (GLsync sync)) \
-    F(GLsync, FenceSync, (GLenum condition, GLbitfield flags)) \
-    F(void, ProvokingVertex, (GLenum mode)) \
-    F(void, MultiDrawElementsBaseVertex, (GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount, const GLint *basevertex)) \
-    F(void, DrawElementsInstancedBaseVertex, (GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount, GLint basevertex)) \
-    F(void, DrawRangeElementsBaseVertex, (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)) \
-    F(void, DrawElementsBaseVertex, (GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)) \
-    F(void, FramebufferTexture, (GLenum target, GLenum attachment, GLuint texture, GLint level)) \
-    F(void, GetBufferParameteri64v, (GLenum target, GLenum pname, GLint64 *params)) \
-    F(void, GetInteger64i_v,(GLenum target, GLuint index, GLint64 *data))
-
-    QT_OPENGL_DECLARE(QT_OPENGL_3_2_FUNCTIONS);
-};
-
-class QOpenGLFunctions_3_3_CoreBackend : public QOpenGLVersionFunctionsBackend
-{
-public:
-    QOpenGLFunctions_3_3_CoreBackend(QOpenGLContext *c)
-        : QOpenGLVersionFunctionsBackend(c)
-    {
-        init();
-    }
-
-    Q_DECL_CONSTEXPR static Version versionStatus()
-    { return OpenGL_3_3_Core; }
-
-    // OpenGL 3.3 core functions
-#define QT_OPENGL_3_3_FUNCTIONS(F) \
-    F(void, VertexAttribP4uiv, (GLuint index, GLenum type, GLboolean normalized, const GLuint *value)) \
-    F(void, VertexAttribP4ui, (GLuint index, GLenum type, GLboolean normalized, GLuint value)) \
-    F(void, VertexAttribP3uiv, (GLuint index, GLenum type, GLboolean normalized, const GLuint *value)) \
-    F(void, VertexAttribP3ui, (GLuint index, GLenum type, GLboolean normalized, GLuint value)) \
-    F(void, VertexAttribP2uiv, (GLuint index, GLenum type, GLboolean normalized, const GLuint *value)) \
-    F(void, VertexAttribP2ui, (GLuint index, GLenum type, GLboolean normalized, GLuint value)) \
-    F(void, VertexAttribP1uiv, (GLuint index, GLenum type, GLboolean normalized, const GLuint *value)) \
-    F(void, VertexAttribP1ui, (GLuint index, GLenum type, GLboolean normalized, GLuint value)) \
-    F(void, SecondaryColorP3uiv, (GLenum type, const GLuint *color)) \
-    F(void, SecondaryColorP3ui, (GLenum type, GLuint color)) \
-    F(void, ColorP4uiv, (GLenum type, const GLuint *color)) \
-    F(void, ColorP4ui, (GLenum type, GLuint color)) \
-    F(void, ColorP3uiv, (GLenum type, const GLuint *color)) \
-    F(void, ColorP3ui, (GLenum type, GLuint color)) \
-    F(void, NormalP3uiv, (GLenum type, const GLuint *coords)) \
-    F(void, NormalP3ui, (GLenum type, GLuint coords)) \
-    F(void, MultiTexCoordP4uiv, (GLenum texture, GLenum type, const GLuint *coords)) \
-    F(void, MultiTexCoordP4ui, (GLenum texture, GLenum type, GLuint coords)) \
-    F(void, MultiTexCoordP3uiv, (GLenum texture, GLenum type, const GLuint *coords)) \
-    F(void, MultiTexCoordP3ui, (GLenum texture, GLenum type, GLuint coords)) \
-    F(void, MultiTexCoordP2uiv, (GLenum texture, GLenum type, const GLuint *coords)) \
-    F(void, MultiTexCoordP2ui, (GLenum texture, GLenum type, GLuint coords)) \
-    F(void, MultiTexCoordP1uiv, (GLenum texture, GLenum type, const GLuint *coords)) \
-    F(void, MultiTexCoordP1ui, (GLenum texture, GLenum type, GLuint coords)) \
-    F(void, TexCoordP4uiv, (GLenum type, const GLuint *coords)) \
-    F(void, TexCoordP4ui, (GLenum type, GLuint coords)) \
-    F(void, TexCoordP3uiv, (GLenum type, const GLuint *coords)) \
-    F(void, TexCoordP3ui, (GLenum type, GLuint coords)) \
-    F(void, TexCoordP2uiv, (GLenum type, const GLuint *coords)) \
-    F(void, TexCoordP2ui, (GLenum type, GLuint coords)) \
-    F(void, TexCoordP1uiv, (GLenum type, const GLuint *coords)) \
-    F(void, TexCoordP1ui, (GLenum type, GLuint coords)) \
-    F(void, VertexP4uiv, (GLenum type, const GLuint *value)) \
-    F(void, VertexP4ui, (GLenum type, GLuint value)) \
-    F(void, VertexP3uiv, (GLenum type, const GLuint *value)) \
-    F(void, VertexP3ui, (GLenum type, GLuint value)) \
-    F(void, VertexP2uiv, (GLenum type, const GLuint *value)) \
-    F(void, VertexP2ui, (GLenum type, GLuint value)) \
-    F(void, GetQueryObjectui64v, (GLuint id, GLenum pname, GLuint64 *params)) \
-    F(void, GetQueryObjecti64v, (GLuint id, GLenum pname, GLint64 *params)) \
-    F(void, QueryCounter, (GLuint id, GLenum target)) \
-    F(void, GetSamplerParameterIuiv, (GLuint sampler, GLenum pname, GLuint *params)) \
-    F(void, GetSamplerParameterfv, (GLuint sampler, GLenum pname, GLfloat *params)) \
-    F(void, GetSamplerParameterIiv, (GLuint sampler, GLenum pname, GLint *params)) \
-    F(void, GetSamplerParameteriv, (GLuint sampler, GLenum pname, GLint *params)) \
-    F(void, SamplerParameterIuiv, (GLuint sampler, GLenum pname, const GLuint *param)) \
-    F(void, SamplerParameterIiv, (GLuint sampler, GLenum pname, const GLint *param)) \
-    F(void, SamplerParameterfv, (GLuint sampler, GLenum pname, const GLfloat *param)) \
-    F(void, SamplerParameterf, (GLuint sampler, GLenum pname, GLfloat param)) \
-    F(void, SamplerParameteriv, (GLuint sampler, GLenum pname, const GLint *param)) \
-    F(void, SamplerParameteri, (GLuint sampler, GLenum pname, GLint param)) \
-    F(void, BindSampler, (GLuint unit, GLuint sampler)) \
-    F(GLboolean, IsSampler, (GLuint sampler)) \
-    F(void, DeleteSamplers, (GLsizei count, const GLuint *samplers)) \
-    F(void, GenSamplers, (GLsizei count, GLuint *samplers)) \
-    F(GLint, GetFragDataIndex, (GLuint program, const GLchar *name)) \
-    F(void, BindFragDataLocationIndexed, (GLuint program, GLuint colorNumber, GLuint index, const GLchar *name)) \
-    F(void, VertexAttribDivisor, (GLuint index, GLuint divisor)) \
-
-    QT_OPENGL_DECLARE(QT_OPENGL_3_3_FUNCTIONS);
-};
-
-class QOpenGLFunctions_4_0_CoreBackend : public QOpenGLVersionFunctionsBackend
-{
-public:
-    QOpenGLFunctions_4_0_CoreBackend(QOpenGLContext *c)
-        : QOpenGLVersionFunctionsBackend(c)
-    {
-        init();
-    }
-
-    Q_DECL_CONSTEXPR static Version versionStatus()
-    { return OpenGL_4_0_Core; }
-
-    // OpenGL 4.0 core functions
-#define QT_OPENGL_4_0_FUNCTIONS(F) \
-    F(void, GetQueryIndexediv, (GLenum target, GLuint index, GLenum pname, GLint *params)) \
-    F(void, EndQueryIndexed, (GLenum target, GLuint index)) \
-    F(void, BeginQueryIndexed, (GLenum target, GLuint index, GLuint id)) \
-    F(void, DrawTransformFeedbackStream, (GLenum mode, GLuint id, GLuint stream)) \
-    F(void, DrawTransformFeedback, (GLenum mode, GLuint id)) \
-    F(void, ResumeTransformFeedback, ()) \
-    F(void, PauseTransformFeedback, ()) \
-    F(GLboolean, IsTransformFeedback, (GLuint id)) \
-    F(void, GenTransformFeedbacks, (GLsizei n, GLuint *ids)) \
-    F(void, DeleteTransformFeedbacks, (GLsizei n, const GLuint *ids)) \
-    F(void, BindTransformFeedback, (GLenum target, GLuint id)) \
-    F(void, PatchParameterfv, (GLenum pname, const GLfloat *values)) \
-    F(void, PatchParameteri, (GLenum pname, GLint value)) \
-    F(void, GetProgramStageiv, (GLuint program, GLenum shadertype, GLenum pname, GLint *values)) \
-    F(void, GetUniformSubroutineuiv, (GLenum shadertype, GLint location, GLuint *params)) \
-    F(void, UniformSubroutinesuiv, (GLenum shadertype, GLsizei count, const GLuint *indices)) \
-    F(void, GetActiveSubroutineName, (GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)) \
-    F(void, GetActiveSubroutineUniformName, (GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)) \
-    F(void, GetActiveSubroutineUniformiv, (GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values)) \
-    F(GLuint, GetSubroutineIndex, (GLuint program, GLenum shadertype, const GLchar *name)) \
-    F(GLint, GetSubroutineUniformLocation, (GLuint program, GLenum shadertype, const GLchar *name)) \
-    F(void, GetUniformdv, (GLuint program, GLint location, GLdouble *params)) \
-    F(void, UniformMatrix4x3dv, (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)) \
-    F(void, UniformMatrix4x2dv, (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)) \
-    F(void, UniformMatrix3x4dv, (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)) \
-    F(void, UniformMatrix3x2dv, (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)) \
-    F(void, UniformMatrix2x4dv, (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)) \
-    F(void, UniformMatrix2x3dv, (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)) \
-    F(void, UniformMatrix4dv, (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)) \
-    F(void, UniformMatrix3dv, (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)) \
-    F(void, UniformMatrix2dv, (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)) \
-    F(void, Uniform4dv, (GLint location, GLsizei count, const GLdouble *value)) \
-    F(void, Uniform3dv, (GLint location, GLsizei count, const GLdouble *value)) \
-    F(void, Uniform2dv, (GLint location, GLsizei count, const GLdouble *value)) \
-    F(void, Uniform1dv, (GLint location, GLsizei count, const GLdouble *value)) \
-    F(void, Uniform4d, (GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w)) \
-    F(void, Uniform3d, (GLint location, GLdouble x, GLdouble y, GLdouble z)) \
-    F(void, Uniform2d, (GLint location, GLdouble x, GLdouble y)) \
-    F(void, Uniform1d, (GLint location, GLdouble x)) \
-    F(void, DrawElementsIndirect, (GLenum mode, GLenum type, const GLvoid *indirect)) \
-    F(void, DrawArraysIndirect, (GLenum mode, const GLvoid *indirect)) \
-    F(void, BlendFuncSeparatei, (GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)) \
-    F(void, BlendFunci, (GLuint buf, GLenum src, GLenum dst)) \
-    F(void, BlendEquationSeparatei, (GLuint buf, GLenum modeRGB, GLenum modeAlpha)) \
-    F(void, BlendEquationi, (GLuint buf, GLenum mode)) \
-    F(void, MinSampleShading, (GLfloat value)) \
-
-    QT_OPENGL_DECLARE(QT_OPENGL_4_0_FUNCTIONS);
-};
-
-class QOpenGLFunctions_4_1_CoreBackend : public QOpenGLVersionFunctionsBackend
-{
-public:
-    QOpenGLFunctions_4_1_CoreBackend(QOpenGLContext *c)
-        : QOpenGLVersionFunctionsBackend(c)
-    {
-        init();
-    }
-
-    Q_DECL_CONSTEXPR static Version versionStatus()
-    { return OpenGL_4_1_Core; }
-
-    // OpenGL 4.1 core functions
-#define QT_OPENGL_4_1_FUNCTIONS(F) \
-    F(void, GetDoublei_v, (GLenum target, GLuint index, GLdouble *data)) \
-    F(void, GetFloati_v,(GLenum target, GLuint index, GLfloat *data)) \
-    F(void, DepthRangeIndexed, (GLuint index, GLdouble n, GLdouble f)) \
-    F(void, DepthRangeArrayv, (GLuint first, GLsizei count, const GLdouble *v)) \
-    F(void, ScissorIndexedv, (GLuint index, const GLint *v)) \
-    F(void, ScissorIndexed, (GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height)) \
-    F(void, ScissorArrayv, (GLuint first, GLsizei count, const GLint *v)) \
-    F(void, ViewportIndexedfv, (GLuint index, const GLfloat *v)) \
-    F(void, ViewportIndexedf, (GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h)) \
-    F(void, ViewportArrayv, (GLuint first, GLsizei count, const GLfloat *v)) \
-    F(void, GetVertexAttribLdv, (GLuint index, GLenum pname, GLdouble *params)) \
-    F(void, VertexAttribLPointer, (GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)) \
-    F(void, VertexAttribL4dv, (GLuint index, const GLdouble *v)) \
-    F(void, VertexAttribL3dv, (GLuint index, const GLdouble *v)) \
-    F(void, VertexAttribL2dv, (GLuint index, const GLdouble *v)) \
-    F(void, VertexAttribL1dv, (GLuint index, const GLdouble *v)) \
-    F(void, VertexAttribL4d, (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)) \
-    F(void, VertexAttribL3d, (GLuint index, GLdouble x, GLdouble y, GLdouble z)) \
-    F(void, VertexAttribL2d, (GLuint index, GLdouble x, GLdouble y)) \
-    F(void, VertexAttribL1d, (GLuint index, GLdouble x)) \
-    F(void, GetProgramPipelineInfoLog, (GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog)) \
-    F(void, ValidateProgramPipeline, (GLuint pipeline)) \
-    F(void, ProgramUniformMatrix4x3dv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)) \
-    F(void, ProgramUniformMatrix3x4dv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)) \
-    F(void, ProgramUniformMatrix4x2dv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)) \
-    F(void, ProgramUniformMatrix2x4dv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)) \
-    F(void, ProgramUniformMatrix3x2dv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)) \
-    F(void, ProgramUniformMatrix2x3dv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)) \
-    F(void, ProgramUniformMatrix4x3fv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) \
-    F(void, ProgramUniformMatrix3x4fv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) \
-    F(void, ProgramUniformMatrix4x2fv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) \
-    F(void, ProgramUniformMatrix2x4fv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) \
-    F(void, ProgramUniformMatrix3x2fv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) \
-    F(void, ProgramUniformMatrix2x3fv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) \
-    F(void, ProgramUniformMatrix4dv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)) \
-    F(void, ProgramUniformMatrix3dv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)) \
-    F(void, ProgramUniformMatrix2dv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)) \
-    F(void, ProgramUniformMatrix4fv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) \
-    F(void, ProgramUniformMatrix3fv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) \
-    F(void, ProgramUniformMatrix2fv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) \
-    F(void, ProgramUniform4uiv, (GLuint program, GLint location, GLsizei count, const GLuint *value)) \
-    F(void, ProgramUniform4ui, (GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)) \
-    F(void, ProgramUniform4dv, (GLuint program, GLint location, GLsizei count, const GLdouble *value)) \
-    F(void, ProgramUniform4d, (GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3)) \
-    F(void, ProgramUniform4fv, (GLuint program, GLint location, GLsizei count, const GLfloat *value)) \
-    F(void, ProgramUniform4f, (GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)) \
-    F(void, ProgramUniform4iv, (GLuint program, GLint location, GLsizei count, const GLint *value)) \
-    F(void, ProgramUniform4i, (GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)) \
-    F(void, ProgramUniform3uiv, (GLuint program, GLint location, GLsizei count, const GLuint *value)) \
-    F(void, ProgramUniform3ui, (GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2)) \
-    F(void, ProgramUniform3dv, (GLuint program, GLint location, GLsizei count, const GLdouble *value)) \
-    F(void, ProgramUniform3d, (GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2)) \
-    F(void, ProgramUniform3fv, (GLuint program, GLint location, GLsizei count, const GLfloat *value)) \
-    F(void, ProgramUniform3f, (GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)) \
-    F(void, ProgramUniform3iv, (GLuint program, GLint location, GLsizei count, const GLint *value)) \
-    F(void, ProgramUniform3i, (GLuint program, GLint location, GLint v0, GLint v1, GLint v2)) \
-    F(void, ProgramUniform2uiv, (GLuint program, GLint location, GLsizei count, const GLuint *value)) \
-    F(void, ProgramUniform2ui, (GLuint program, GLint location, GLuint v0, GLuint v1)) \
-    F(void, ProgramUniform2dv, (GLuint program, GLint location, GLsizei count, const GLdouble *value)) \
-    F(void, ProgramUniform2d, (GLuint program, GLint location, GLdouble v0, GLdouble v1)) \
-    F(void, ProgramUniform2fv, (GLuint program, GLint location, GLsizei count, const GLfloat *value)) \
-    F(void, ProgramUniform2f, (GLuint program, GLint location, GLfloat v0, GLfloat v1)) \
-    F(void, ProgramUniform2iv, (GLuint program, GLint location, GLsizei count, const GLint *value)) \
-    F(void, ProgramUniform2i, (GLuint program, GLint location, GLint v0, GLint v1)) \
-    F(void, ProgramUniform1uiv, (GLuint program, GLint location, GLsizei count, const GLuint *value)) \
-    F(void, ProgramUniform1ui, (GLuint program, GLint location, GLuint v0)) \
-    F(void, ProgramUniform1dv, (GLuint program, GLint location, GLsizei count, const GLdouble *value)) \
-    F(void, ProgramUniform1d, (GLuint program, GLint location, GLdouble v0)) \
-    F(void, ProgramUniform1fv, (GLuint program, GLint location, GLsizei count, const GLfloat *value)) \
-    F(void, ProgramUniform1f, (GLuint program, GLint location, GLfloat v0)) \
-    F(void, ProgramUniform1iv, (GLuint program, GLint location, GLsizei count, const GLint *value)) \
-    F(void, ProgramUniform1i, (GLuint program, GLint location, GLint v0)) \
-    F(void, GetProgramPipelineiv, (GLuint pipeline, GLenum pname, GLint *params)) \
-    F(GLboolean, IsProgramPipeline, (GLuint pipeline)) \
-    F(void, GenProgramPipelines, (GLsizei n, GLuint *pipelines)) \
-    F(void, DeleteProgramPipelines, (GLsizei n, const GLuint *pipelines)) \
-    F(void, BindProgramPipeline, (GLuint pipeline)) \
-    F(GLuint, CreateShaderProgramv, (GLenum type, GLsizei count, const GLchar* const *strings)) \
-    F(void, ActiveShaderProgram, (GLuint pipeline, GLuint program)) \
-    F(void, UseProgramStages, (GLuint pipeline, GLbitfield stages, GLuint program)) \
-    F(void, ProgramParameteri, (GLuint program, GLenum pname, GLint value)) \
-    F(void, ProgramBinary, (GLuint program, GLenum binaryFormat, const GLvoid *binary, GLsizei length)) \
-    F(void, GetProgramBinary, (GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, GLvoid *binary)) \
-    F(void, ClearDepthf, (GLfloat dd)) \
-    F(void, DepthRangef, (GLfloat n, GLfloat f)) \
-    F(void, GetShaderPrecisionFormat, (GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision)) \
-    F(void, ShaderBinary, (GLsizei count, const GLuint *shaders, GLenum binaryformat, const GLvoid *binary, GLsizei length)) \
-    F(void, ReleaseShaderCompiler, ()) \
-
-    QT_OPENGL_DECLARE(QT_OPENGL_4_1_FUNCTIONS);
-};
-
-class QOpenGLFunctions_4_2_CoreBackend : public QOpenGLVersionFunctionsBackend
-{
-public:
-    QOpenGLFunctions_4_2_CoreBackend(QOpenGLContext *c)
-        : QOpenGLVersionFunctionsBackend(c)
-    {
-        init();
-    }
-
-    Q_DECL_CONSTEXPR static Version versionStatus()
-    { return OpenGL_4_2_Core; }
-
-    // OpenGL 4.2 core functions
-#define QT_OPENGL_4_2_FUNCTIONS(F) \
-    F(void, TexStorage3D, (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)) \
-    F(void, TexStorage2D, (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)) \
-    F(void, TexStorage1D, (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width)) \
-    F(void, MemoryBarrier, (GLbitfield barriers)) \
-    F(void, BindImageTexture, (GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format)) \
-    F(void, GetActiveAtomicCounterBufferiv, (GLuint program, GLuint bufferIndex, GLenum pname, GLint *params)) \
-    F(void, GetInternalformativ, (GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params)) \
-    F(void, DrawTransformFeedbackStreamInstanced, (GLenum mode, GLuint id, GLuint stream, GLsizei instancecount)) \
-    F(void, DrawTransformFeedbackInstanced, (GLenum mode, GLuint id, GLsizei instancecount)) \
-    F(void, DrawElementsInstancedBaseVertexBaseInstance, (GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance)) \
-    F(void, DrawElementsInstancedBaseInstance, (GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLuint baseinstance)) \
-    F(void, DrawArraysInstancedBaseInstance, (GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance)) \
-
-    QT_OPENGL_DECLARE(QT_OPENGL_4_2_FUNCTIONS);
-};
-
-class QOpenGLFunctions_4_3_CoreBackend : public QOpenGLVersionFunctionsBackend
-{
-public:
-    QOpenGLFunctions_4_3_CoreBackend(QOpenGLContext *c)
-        : QOpenGLVersionFunctionsBackend(c)
-    {
-        init();
-    }
-
-    Q_DECL_CONSTEXPR static Version versionStatus()
-    { return OpenGL_4_3_Core; }
-
-    // OpenGL 4.3 core functions
-#define QT_OPENGL_4_3_FUNCTIONS(F) \
-    F(void, TexStorage3DMultisample, (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)) \
-    F(void, TexStorage2DMultisample, (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)) \
-    F(void, TexBufferRange, (GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size)) \
-    F(void, ShaderStorageBlockBinding, (GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding)) \
-    F(GLint, GetProgramResourceLocationIndex, (GLuint program, GLenum programInterface, const GLchar *name)) \
-    F(GLint, GetProgramResourceLocation, (GLuint program, GLenum programInterface, const GLchar *name)) \
-    F(void, GetProgramResourceiv, (GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params)) \
-    F(void, GetProgramResourceName, (GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name)) \
-    F(GLuint, GetProgramResourceIndex, (GLuint program, GLenum programInterface, const GLchar *name)) \
-    F(void, GetProgramInterfaceiv, (GLuint program, GLenum programInterface, GLenum pname, GLint *params)) \
-    F(void, MultiDrawElementsIndirect, (GLenum mode, GLenum type, const void *indirect, GLsizei drawcount, GLsizei stride)) \
-    F(void, MultiDrawArraysIndirect, (GLenum mode, const void *indirect, GLsizei drawcount, GLsizei stride)) \
-    F(void, InvalidateSubFramebuffer, (GLenum target, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height)) \
-    F(void, InvalidateFramebuffer, (GLenum target, GLsizei numAttachments, const GLenum *attachments)) \
-    F(void, InvalidateBufferData, (GLuint buffer)) \
-    F(void, InvalidateBufferSubData, (GLuint buffer, GLintptr offset, GLsizeiptr length)) \
-    F(void, InvalidateTexImage, (GLuint texture, GLint level)) \
-    F(void, InvalidateTexSubImage, (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth)) \
-    F(void, GetInternalformati64v, (GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint64 *params)) \
-    F(void, GetFramebufferParameteriv, (GLenum target, GLenum pname, GLint *params)) \
-    F(void, FramebufferParameteri, (GLenum target, GLenum pname, GLint param)) \
-    F(void, VertexBindingDivisor, (GLuint bindingindex, GLuint divisor)) \
-    F(void, VertexAttribBinding, (GLuint attribindex, GLuint bindingindex)) \
-    F(void, VertexAttribLFormat, (GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)) \
-    F(void, VertexAttribIFormat, (GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)) \
-    F(void, VertexAttribFormat, (GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset)) \
-    F(void, BindVertexBuffer, (GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride)) \
-    F(void, TextureView, (GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers)) \
-    F(void, CopyImageSubData, (GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth)) \
-    F(void, DispatchComputeIndirect, (GLintptr indirect)) \
-    F(void, DispatchCompute, (GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z)) \
-    F(void, ClearBufferSubData, (GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data)) \
-    F(void, ClearBufferData, (GLenum target, GLenum internalformat, GLenum format, GLenum type, const void *data)) \
-    F(void, GetObjectPtrLabel, (const GLvoid *ptr, GLsizei bufSize, GLsizei *length, GLchar *label)) \
-    F(void, ObjectPtrLabel, (const GLvoid *ptr, GLsizei length, const GLchar *label)) \
-    F(void, GetObjectLabel, (GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label)) \
-    F(void, ObjectLabel, (GLenum identifier, GLuint name, GLsizei length, const GLchar *label)) \
-    F(void, PopDebugGroup, ()) \
-    F(void, PushDebugGroup, (GLenum source, GLuint id, GLsizei length, const GLchar *message)) \
-    F(GLuint, GetDebugMessageLog, (GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog)) \
-    F(void, DebugMessageCallback, (GLDEBUGPROC callback, const GLvoid *userParam)) \
-    F(void, DebugMessageInsert, (GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf)) \
-    F(void, DebugMessageControl, (GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled)) \
-
-    QT_OPENGL_DECLARE(QT_OPENGL_4_3_FUNCTIONS);
-};
-
-class QOpenGLFunctions_4_4_CoreBackend : public QOpenGLVersionFunctionsBackend
-{
-public:
-    QOpenGLFunctions_4_4_CoreBackend(QOpenGLContext *c)
-        : QOpenGLVersionFunctionsBackend(c)
-    {
-        init();
-    }
-
-    Q_DECL_CONSTEXPR static Version versionStatus()
-    { return OpenGL_4_4_Core; }
-
-    // OpenGL 4.4 core functions
-#define QT_OPENGL_4_4_FUNCTIONS(F) \
-    F(void, BindVertexBuffers, (GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides)) \
-    F(void, BindImageTextures, (GLuint first, GLsizei count, const GLuint *textures)) \
-    F(void, BindSamplers, (GLuint first, GLsizei count, const GLuint *samplers)) \
-    F(void, BindTextures, (GLuint first, GLsizei count, const GLuint *textures)) \
-    F(void, BindBuffersRange, (GLenum target, GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizeiptr *sizes)) \
-    F(void, BindBuffersBase, (GLenum target, GLuint first, GLsizei count, const GLuint *buffers)) \
-    F(void, ClearTexSubImage, (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *data)) \
-    F(void, ClearTexImage, (GLuint texture, GLint level, GLenum format, GLenum type, const void *data)) \
-    F(void, BufferStorage, (GLenum target, GLsizeiptr size, const void *data, GLbitfield flags)) \
-
-    QT_OPENGL_DECLARE(QT_OPENGL_4_4_FUNCTIONS);
-};
-
-class QOpenGLFunctions_4_5_CoreBackend : public QOpenGLVersionFunctionsBackend
-{
-public:
-    QOpenGLFunctions_4_5_CoreBackend(QOpenGLContext *c)
-        : QOpenGLVersionFunctionsBackend(c)
-    {
-        init();
-    }
-
-    Q_DECL_CONSTEXPR static Version versionStatus()
-    { return OpenGL_4_5_Core; }
-
-    // OpenGL 4.5 core functions
-#define QT_OPENGL_4_5_FUNCTIONS(F) \
-    F(void, TextureBarrier, ()) \
-    F(void, ReadnPixels, (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data)) \
-    F(void, GetnUniformuiv, (GLuint program, GLint location, GLsizei bufSize, GLuint *params)) \
-    F(void, GetnUniformiv, (GLuint program, GLint location, GLsizei bufSize, GLint *params)) \
-    F(void, GetnUniformfv, (GLuint program, GLint location, GLsizei bufSize, GLfloat *params)) \
-    F(void, GetnUniformdv, (GLuint program, GLint location, GLsizei bufSize, GLdouble *params)) \
-    F(void, GetnTexImage, (GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, void *pixels)) \
-    F(void, GetnCompressedTexImage, (GLenum target, GLint lod, GLsizei bufSize, void *pixels)) \
-    F(GLenum, GetGraphicsResetStatus, ()) \
-    F(void, GetCompressedTextureSubImage, (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei bufSize, void *pixels)) \
-    F(void, GetTextureSubImage, (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLsizei bufSize, void *pixels)) \
-    F(void, MemoryBarrierByRegion, (GLbitfield barriers)) \
-    F(void, CreateQueries, (GLenum target, GLsizei n, GLuint *ids)) \
-    F(void, CreateProgramPipelines, (GLsizei n, GLuint *pipelines)) \
-    F(void, CreateSamplers, (GLsizei n, GLuint *samplers)) \
-    F(void, GetVertexArrayIndexed64iv, (GLuint vaobj, GLuint index, GLenum pname, GLint64 *param)) \
-    F(void, GetVertexArrayIndexediv, (GLuint vaobj, GLuint index, GLenum pname, GLint *param)) \
-    F(void, GetVertexArrayiv, (GLuint vaobj, GLenum pname, GLint *param)) \
-    F(void, VertexArrayBindingDivisor, (GLuint vaobj, GLuint bindingindex, GLuint divisor)) \
-    F(void, VertexArrayAttribLFormat, (GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)) \
-    F(void, VertexArrayAttribIFormat, (GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)) \
-    F(void, VertexArrayAttribFormat, (GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset)) \
-    F(void, VertexArrayAttribBinding, (GLuint vaobj, GLuint attribindex, GLuint bindingindex)) \
-    F(void, VertexArrayVertexBuffers, (GLuint vaobj, GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides)) \
-    F(void, VertexArrayVertexBuffer, (GLuint vaobj, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride)) \
-    F(void, VertexArrayElementBuffer, (GLuint vaobj, GLuint buffer)) \
-    F(void, EnableVertexArrayAttrib, (GLuint vaobj, GLuint index)) \
-    F(void, DisableVertexArrayAttrib, (GLuint vaobj, GLuint index)) \
-    F(void, CreateVertexArrays, (GLsizei n, GLuint *arrays)) \
-    F(void, GetTextureParameteriv, (GLuint texture, GLenum pname, GLint *params)) \
-    F(void, GetTextureParameterIuiv, (GLuint texture, GLenum pname, GLuint *params)) \
-    F(void, GetTextureParameterIiv, (GLuint texture, GLenum pname, GLint *params)) \
-    F(void, GetTextureParameterfv, (GLuint texture, GLenum pname, GLfloat *params)) \
-    F(void, GetTextureLevelParameteriv, (GLuint texture, GLint level, GLenum pname, GLint *params)) \
-    F(void, GetTextureLevelParameterfv, (GLuint texture, GLint level, GLenum pname, GLfloat *params)) \
-    F(void, GetCompressedTextureImage, (GLuint texture, GLint level, GLsizei bufSize, void *pixels)) \
-    F(void, GetTextureImage, (GLuint texture, GLint level, GLenum format, GLenum type, GLsizei bufSize, void *pixels)) \
-    F(void, BindTextureUnit, (GLuint unit, GLuint texture)) \
-    F(void, GenerateTextureMipmap, (GLuint texture)) \
-    F(void, TextureParameteriv, (GLuint texture, GLenum pname, const GLint *param)) \
-    F(void, TextureParameterIuiv, (GLuint texture, GLenum pname, const GLuint *params)) \
-    F(void, TextureParameterIiv, (GLuint texture, GLenum pname, const GLint *params)) \
-    F(void, TextureParameteri, (GLuint texture, GLenum pname, GLint param)) \
-    F(void, TextureParameterfv, (GLuint texture, GLenum pname, const GLfloat *param)) \
-    F(void, TextureParameterf, (GLuint texture, GLenum pname, GLfloat param)) \
-    F(void, CopyTextureSubImage3D, (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)) \
-    F(void, CopyTextureSubImage2D, (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)) \
-    F(void, CopyTextureSubImage1D, (GLuint texture, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)) \
-    F(void, CompressedTextureSubImage3D, (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data)) \
-    F(void, CompressedTextureSubImage2D, (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data)) \
-    F(void, CompressedTextureSubImage1D, (GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data)) \
-    F(void, TextureSubImage3D, (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels)) \
-    F(void, TextureSubImage2D, (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)) \
-    F(void, TextureSubImage1D, (GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels)) \
-    F(void, TextureStorage3DMultisample, (GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)) \
-    F(void, TextureStorage2DMultisample, (GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)) \
-    F(void, TextureStorage3D, (GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)) \
-    F(void, TextureStorage2D, (GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)) \
-    F(void, TextureStorage1D, (GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width)) \
-    F(void, TextureBufferRange, (GLuint texture, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizei size)) \
-    F(void, TextureBuffer, (GLuint texture, GLenum internalformat, GLuint buffer)) \
-    F(void, CreateTextures, (GLenum target, GLsizei n, GLuint *textures)) \
-    F(void, GetNamedRenderbufferParameteriv, (GLuint renderbuffer, GLenum pname, GLint *params)) \
-    F(void, NamedRenderbufferStorageMultisample, (GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)) \
-    F(void, NamedRenderbufferStorage, (GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height)) \
-    F(void, CreateRenderbuffers, (GLsizei n, GLuint *renderbuffers)) \
-    F(void, GetNamedFramebufferAttachmentParameteriv, (GLuint framebuffer, GLenum attachment, GLenum pname, GLint *params)) \
-    F(void, GetNamedFramebufferParameteriv, (GLuint framebuffer, GLenum pname, GLint *param)) \
-    F(GLenum, CheckNamedFramebufferStatus, (GLuint framebuffer, GLenum target)) \
-    F(void, BlitNamedFramebuffer, (GLuint readFramebuffer, GLuint drawFramebuffer, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)) \
-    F(void, ClearNamedFramebufferfi, (GLuint framebuffer, GLenum buffer, GLfloat depth, GLint stencil)) \
-    F(void, ClearNamedFramebufferfv, (GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLfloat *value)) \
-    F(void, ClearNamedFramebufferuiv, (GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLuint *value)) \
-    F(void, ClearNamedFramebufferiv, (GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLint *value)) \
-    F(void, InvalidateNamedFramebufferSubData, (GLuint framebuffer, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height)) \
-    F(void, InvalidateNamedFramebufferData, (GLuint framebuffer, GLsizei numAttachments, const GLenum *attachments)) \
-    F(void, NamedFramebufferReadBuffer, (GLuint framebuffer, GLenum src)) \
-    F(void, NamedFramebufferDrawBuffers, (GLuint framebuffer, GLsizei n, const GLenum *bufs)) \
-    F(void, NamedFramebufferDrawBuffer, (GLuint framebuffer, GLenum buf)) \
-    F(void, NamedFramebufferTextureLayer, (GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer)) \
-    F(void, NamedFramebufferTexture, (GLuint framebuffer, GLenum attachment, GLuint texture, GLint level)) \
-    F(void, NamedFramebufferParameteri, (GLuint framebuffer, GLenum pname, GLint param)) \
-    F(void, NamedFramebufferRenderbuffer, (GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)) \
-    F(void, CreateFramebuffers, (GLsizei n, GLuint *framebuffers)) \
-    F(void, GetNamedBufferSubData, (GLuint buffer, GLintptr offset, GLsizei size, void *data)) \
-    F(void, GetNamedBufferPointerv, (GLuint buffer, GLenum pname, GLvoid* *params)) \
-    F(void, GetNamedBufferParameteri64v, (GLuint buffer, GLenum pname, GLint64 *params)) \
-    F(void, GetNamedBufferParameteriv, (GLuint buffer, GLenum pname, GLint *params)) \
-    F(void, FlushMappedNamedBufferRange, (GLuint buffer, GLintptr offset, GLsizei length)) \
-    F(GLboolean, UnmapNamedBuffer, (GLuint buffer)) \
-    F(GLvoid *, MapNamedBufferRange, (GLuint buffer, GLintptr offset, GLsizei length, GLbitfield access)) \
-    F(GLvoid *, MapNamedBuffer, (GLuint buffer, GLenum access)) \
-    F(void, ClearNamedBufferSubData, (GLuint buffer, GLenum internalformat, GLintptr offset, GLsizei size, GLenum format, GLenum type, const void *data)) \
-    F(void, ClearNamedBufferData, (GLuint buffer, GLenum internalformat, GLenum format, GLenum type, const void *data)) \
-    F(void, CopyNamedBufferSubData, (GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizei size)) \
-    F(void, NamedBufferSubData, (GLuint buffer, GLintptr offset, GLsizei size, const void *data)) \
-    F(void, NamedBufferData, (GLuint buffer, GLsizei size, const void *data, GLenum usage)) \
-    F(void, NamedBufferStorage, (GLuint buffer, GLsizei size, const void *data, GLbitfield flags)) \
-    F(void, CreateBuffers, (GLsizei n, GLuint *buffers)) \
-    F(void, GetTransformFeedbacki64_v,(GLuint xfb, GLenum pname, GLuint index, GLint64 *param)) \
-    F(void, GetTransformFeedbacki_v,(GLuint xfb, GLenum pname, GLuint index, GLint *param)) \
-    F(void, GetTransformFeedbackiv, (GLuint xfb, GLenum pname, GLint *param)) \
-    F(void, TransformFeedbackBufferRange, (GLuint xfb, GLuint index, GLuint buffer, GLintptr offset, GLsizei size)) \
-    F(void, TransformFeedbackBufferBase, (GLuint xfb, GLuint index, GLuint buffer)) \
-    F(void, CreateTransformFeedbacks, (GLsizei n, GLuint *ids)) \
-    F(void, ClipControl, (GLenum origin, GLenum depth)) \
-
-    QT_OPENGL_DECLARE(QT_OPENGL_4_5_FUNCTIONS);
-};
-
-class QOpenGLFunctions_1_0_DeprecatedBackend : public QOpenGLVersionFunctionsBackend
-{
-public:
-    QOpenGLFunctions_1_0_DeprecatedBackend(QOpenGLContext *c)
-        : QOpenGLVersionFunctionsBackend(c)
-    {
-        init();
-    }
-
-    Q_DECL_CONSTEXPR static Version versionStatus()
-    { return OpenGL_1_0_Deprecated; }
-
-    // OpenGL 1.0 deprecated functions
-#define QT_OPENGL_1_0_DEPRECATED_FUNCTIONS(F) \
-    F(void, Translatef, (GLfloat x, GLfloat y, GLfloat z)) \
-    F(void, Translated, (GLdouble x, GLdouble y, GLdouble z)) \
-    F(void, Scalef, (GLfloat x, GLfloat y, GLfloat z)) \
-    F(void, Scaled, (GLdouble x, GLdouble y, GLdouble z)) \
-    F(void, Rotatef, (GLfloat angle, GLfloat x, GLfloat y, GLfloat z)) \
-    F(void, Rotated, (GLdouble angle, GLdouble x, GLdouble y, GLdouble z)) \
-    F(void, PushMatrix, ()) \
-    F(void, PopMatrix, ()) \
-    F(void, Ortho, (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)) \
-    F(void, MultMatrixd, (const GLdouble *m)) \
-    F(void, MultMatrixf, (const GLfloat *m)) \
-    F(void, MatrixMode, (GLenum mode)) \
-    F(void, LoadMatrixd, (const GLdouble *m)) \
-    F(void, LoadMatrixf, (const GLfloat *m)) \
-    F(void, LoadIdentity, ()) \
-    F(void, Frustum, (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)) \
-    F(GLboolean, IsList, (GLuint list)) \
-    F(void, GetTexGeniv, (GLenum coord, GLenum pname, GLint *params)) \
-    F(void, GetTexGenfv, (GLenum coord, GLenum pname, GLfloat *params)) \
-    F(void, GetTexGendv, (GLenum coord, GLenum pname, GLdouble *params)) \
-    F(void, GetTexEnviv, (GLenum target, GLenum pname, GLint *params)) \
-    F(void, GetTexEnvfv, (GLenum target, GLenum pname, GLfloat *params)) \
-    F(void, GetPolygonStipple, (GLubyte *mask)) \
-    F(void, GetPixelMapusv, (GLenum map, GLushort *values)) \
-    F(void, GetPixelMapuiv, (GLenum map, GLuint *values)) \
-    F(void, GetPixelMapfv, (GLenum map, GLfloat *values)) \
-    F(void, GetMaterialiv, (GLenum face, GLenum pname, GLint *params)) \
-    F(void, GetMaterialfv, (GLenum face, GLenum pname, GLfloat *params)) \
-    F(void, GetMapiv, (GLenum target, GLenum query, GLint *v)) \
-    F(void, GetMapfv, (GLenum target, GLenum query, GLfloat *v)) \
-    F(void, GetMapdv, (GLenum target, GLenum query, GLdouble *v)) \
-    F(void, GetLightiv, (GLenum light, GLenum pname, GLint *params)) \
-    F(void, GetLightfv, (GLenum light, GLenum pname, GLfloat *params)) \
-    F(void, GetClipPlane, (GLenum plane, GLdouble *equation)) \
-    F(void, DrawPixels, (GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)) \
-    F(void, CopyPixels, (GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)) \
-    F(void, PixelMapusv, (GLenum map, GLsizei mapsize, const GLushort *values)) \
-    F(void, PixelMapuiv, (GLenum map, GLsizei mapsize, const GLuint *values)) \
-    F(void, PixelMapfv, (GLenum map, GLsizei mapsize, const GLfloat *values)) \
-    F(void, PixelTransferi, (GLenum pname, GLint param)) \
-    F(void, PixelTransferf, (GLenum pname, GLfloat param)) \
-    F(void, PixelZoom, (GLfloat xfactor, GLfloat yfactor)) \
-    F(void, AlphaFunc, (GLenum func, GLfloat ref)) \
-    F(void, EvalPoint2, (GLint i, GLint j)) \
-    F(void, EvalMesh2, (GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)) \
-    F(void, EvalPoint1, (GLint i)) \
-    F(void, EvalMesh1, (GLenum mode, GLint i1, GLint i2)) \
-    F(void, EvalCoord2fv, (const GLfloat *u)) \
-    F(void, EvalCoord2f, (GLfloat u, GLfloat v)) \
-    F(void, EvalCoord2dv, (const GLdouble *u)) \
-    F(void, EvalCoord2d, (GLdouble u, GLdouble v)) \
-    F(void, EvalCoord1fv, (const GLfloat *u)) \
-    F(void, EvalCoord1f, (GLfloat u)) \
-    F(void, EvalCoord1dv, (const GLdouble *u)) \
-    F(void, EvalCoord1d, (GLdouble u)) \
-    F(void, MapGrid2f, (GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)) \
-    F(void, MapGrid2d, (GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)) \
-    F(void, MapGrid1f, (GLint un, GLfloat u1, GLfloat u2)) \
-    F(void, MapGrid1d, (GLint un, GLdouble u1, GLdouble u2)) \
-    F(void, Map2f, (GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)) \
-    F(void, Map2d, (GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)) \
-    F(void, Map1f, (GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)) \
-    F(void, Map1d, (GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)) \
-    F(void, PushAttrib, (GLbitfield mask)) \
-    F(void, PopAttrib, ()) \
-    F(void, Accum, (GLenum op, GLfloat value)) \
-    F(void, IndexMask, (GLuint mask)) \
-    F(void, ClearIndex, (GLfloat c)) \
-    F(void, ClearAccum, (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)) \
-    F(void, PushName, (GLuint name)) \
-    F(void, PopName, ()) \
-    F(void, PassThrough, (GLfloat token)) \
-    F(void, LoadName, (GLuint name)) \
-    F(void, InitNames, ()) \
-    F(GLint, RenderMode, (GLenum mode)) \
-    F(void, SelectBuffer, (GLsizei size, GLuint *buffer)) \
-    F(void, FeedbackBuffer, (GLsizei size, GLenum type, GLfloat *buffer)) \
-    F(void, TexGeniv, (GLenum coord, GLenum pname, const GLint *params)) \
-    F(void, TexGeni, (GLenum coord, GLenum pname, GLint param)) \
-    F(void, TexGenfv, (GLenum coord, GLenum pname, const GLfloat *params)) \
-    F(void, TexGenf, (GLenum coord, GLenum pname, GLfloat param)) \
-    F(void, TexGendv, (GLenum coord, GLenum pname, const GLdouble *params)) \
-    F(void, TexGend, (GLenum coord, GLenum pname, GLdouble param)) \
-    F(void, TexEnviv, (GLenum target, GLenum pname, const GLint *params)) \
-    F(void, TexEnvi, (GLenum target, GLenum pname, GLint param)) \
-    F(void, TexEnvfv, (GLenum target, GLenum pname, const GLfloat *params)) \
-    F(void, TexEnvf, (GLenum target, GLenum pname, GLfloat param)) \
-    F(void, ShadeModel, (GLenum mode)) \
-    F(void, PolygonStipple, (const GLubyte *mask)) \
-    F(void, Materialiv, (GLenum face, GLenum pname, const GLint *params)) \
-    F(void, Materiali, (GLenum face, GLenum pname, GLint param)) \
-    F(void, Materialfv, (GLenum face, GLenum pname, const GLfloat *params)) \
-    F(void, Materialf, (GLenum face, GLenum pname, GLfloat param)) \
-    F(void, LineStipple, (GLint factor, GLushort pattern)) \
-    F(void, LightModeliv, (GLenum pname, const GLint *params)) \
-    F(void, LightModeli, (GLenum pname, GLint param)) \
-    F(void, LightModelfv, (GLenum pname, const GLfloat *params)) \
-    F(void, LightModelf, (GLenum pname, GLfloat param)) \
-    F(void, Lightiv, (GLenum light, GLenum pname, const GLint *params)) \
-    F(void, Lighti, (GLenum light, GLenum pname, GLint param)) \
-    F(void, Lightfv, (GLenum light, GLenum pname, const GLfloat *params)) \
-    F(void, Lightf, (GLenum light, GLenum pname, GLfloat param)) \
-    F(void, Fogiv, (GLenum pname, const GLint *params)) \
-    F(void, Fogi, (GLenum pname, GLint param)) \
-    F(void, Fogfv, (GLenum pname, const GLfloat *params)) \
-    F(void, Fogf, (GLenum pname, GLfloat param)) \
-    F(void, ColorMaterial, (GLenum face, GLenum mode)) \
-    F(void, ClipPlane, (GLenum plane, const GLdouble *equation)) \
-    F(void, Vertex4sv, (const GLshort *v)) \
-    F(void, Vertex4s, (GLshort x, GLshort y, GLshort z, GLshort w)) \
-    F(void, Vertex4iv, (const GLint *v)) \
-    F(void, Vertex4i, (GLint x, GLint y, GLint z, GLint w)) \
-    F(void, Vertex4fv, (const GLfloat *v)) \
-    F(void, Vertex4f, (GLfloat x, GLfloat y, GLfloat z, GLfloat w)) \
-    F(void, Vertex4dv, (const GLdouble *v)) \
-    F(void, Vertex4d, (GLdouble x, GLdouble y, GLdouble z, GLdouble w)) \
-    F(void, Vertex3sv, (const GLshort *v)) \
-    F(void, Vertex3s, (GLshort x, GLshort y, GLshort z)) \
-    F(void, Vertex3iv, (const GLint *v)) \
-    F(void, Vertex3i, (GLint x, GLint y, GLint z)) \
-    F(void, Vertex3fv, (const GLfloat *v)) \
-    F(void, Vertex3f, (GLfloat x, GLfloat y, GLfloat z)) \
-    F(void, Vertex3dv, (const GLdouble *v)) \
-    F(void, Vertex3d, (GLdouble x, GLdouble y, GLdouble z)) \
-    F(void, Vertex2sv, (const GLshort *v)) \
-    F(void, Vertex2s, (GLshort x, GLshort y)) \
-    F(void, Vertex2iv, (const GLint *v)) \
-    F(void, Vertex2i, (GLint x, GLint y)) \
-    F(void, Vertex2fv, (const GLfloat *v)) \
-    F(void, Vertex2f, (GLfloat x, GLfloat y)) \
-    F(void, Vertex2dv, (const GLdouble *v)) \
-    F(void, Vertex2d, (GLdouble x, GLdouble y)) \
-    F(void, TexCoord4sv, (const GLshort *v)) \
-    F(void, TexCoord4s, (GLshort s, GLshort t, GLshort r, GLshort q)) \
-    F(void, TexCoord4iv, (const GLint *v)) \
-    F(void, TexCoord4i, (GLint s, GLint t, GLint r, GLint q)) \
-    F(void, TexCoord4fv, (const GLfloat *v)) \
-    F(void, TexCoord4f, (GLfloat s, GLfloat t, GLfloat r, GLfloat q)) \
-    F(void, TexCoord4dv, (const GLdouble *v)) \
-    F(void, TexCoord4d, (GLdouble s, GLdouble t, GLdouble r, GLdouble q)) \
-    F(void, TexCoord3sv, (const GLshort *v)) \
-    F(void, TexCoord3s, (GLshort s, GLshort t, GLshort r)) \
-    F(void, TexCoord3iv, (const GLint *v)) \
-    F(void, TexCoord3i, (GLint s, GLint t, GLint r)) \
-    F(void, TexCoord3fv, (const GLfloat *v)) \
-    F(void, TexCoord3f, (GLfloat s, GLfloat t, GLfloat r)) \
-    F(void, TexCoord3dv, (const GLdouble *v)) \
-    F(void, TexCoord3d, (GLdouble s, GLdouble t, GLdouble r)) \
-    F(void, TexCoord2sv, (const GLshort *v)) \
-    F(void, TexCoord2s, (GLshort s, GLshort t)) \
-    F(void, TexCoord2iv, (const GLint *v)) \
-    F(void, TexCoord2i, (GLint s, GLint t)) \
-    F(void, TexCoord2fv, (const GLfloat *v)) \
-    F(void, TexCoord2f, (GLfloat s, GLfloat t)) \
-    F(void, TexCoord2dv, (const GLdouble *v)) \
-    F(void, TexCoord2d, (GLdouble s, GLdouble t)) \
-    F(void, TexCoord1sv, (const GLshort *v)) \
-    F(void, TexCoord1s, (GLshort s)) \
-    F(void, TexCoord1iv, (const GLint *v)) \
-    F(void, TexCoord1i, (GLint s)) \
-    F(void, TexCoord1fv, (const GLfloat *v)) \
-    F(void, TexCoord1f, (GLfloat s)) \
-    F(void, TexCoord1dv, (const GLdouble *v)) \
-    F(void, TexCoord1d, (GLdouble s)) \
-    F(void, Rectsv, (const GLshort *v1, const GLshort *v2)) \
-    F(void, Rects, (GLshort x1, GLshort y1, GLshort x2, GLshort y2)) \
-    F(void, Rectiv, (const GLint *v1, const GLint *v2)) \
-    F(void, Recti, (GLint x1, GLint y1, GLint x2, GLint y2)) \
-    F(void, Rectfv, (const GLfloat *v1, const GLfloat *v2)) \
-    F(void, Rectf, (GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)) \
-    F(void, Rectdv, (const GLdouble *v1, const GLdouble *v2)) \
-    F(void, Rectd, (GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)) \
-    F(void, RasterPos4sv, (const GLshort *v)) \
-    F(void, RasterPos4s, (GLshort x, GLshort y, GLshort z, GLshort w)) \
-    F(void, RasterPos4iv, (const GLint *v)) \
-    F(void, RasterPos4i, (GLint x, GLint y, GLint z, GLint w)) \
-    F(void, RasterPos4fv, (const GLfloat *v)) \
-    F(void, RasterPos4f, (GLfloat x, GLfloat y, GLfloat z, GLfloat w)) \
-    F(void, RasterPos4dv, (const GLdouble *v)) \
-    F(void, RasterPos4d, (GLdouble x, GLdouble y, GLdouble z, GLdouble w)) \
-    F(void, RasterPos3sv, (const GLshort *v)) \
-    F(void, RasterPos3s, (GLshort x, GLshort y, GLshort z)) \
-    F(void, RasterPos3iv, (const GLint *v)) \
-    F(void, RasterPos3i, (GLint x, GLint y, GLint z)) \
-    F(void, RasterPos3fv, (const GLfloat *v)) \
-    F(void, RasterPos3f, (GLfloat x, GLfloat y, GLfloat z)) \
-    F(void, RasterPos3dv, (const GLdouble *v)) \
-    F(void, RasterPos3d, (GLdouble x, GLdouble y, GLdouble z)) \
-    F(void, RasterPos2sv, (const GLshort *v)) \
-    F(void, RasterPos2s, (GLshort x, GLshort y)) \
-    F(void, RasterPos2iv, (const GLint *v)) \
-    F(void, RasterPos2i, (GLint x, GLint y)) \
-    F(void, RasterPos2fv, (const GLfloat *v)) \
-    F(void, RasterPos2f, (GLfloat x, GLfloat y)) \
-    F(void, RasterPos2dv, (const GLdouble *v)) \
-    F(void, RasterPos2d, (GLdouble x, GLdouble y)) \
-    F(void, Normal3sv, (const GLshort *v)) \
-    F(void, Normal3s, (GLshort nx, GLshort ny, GLshort nz)) \
-    F(void, Normal3iv, (const GLint *v)) \
-    F(void, Normal3i, (GLint nx, GLint ny, GLint nz)) \
-    F(void, Normal3fv, (const GLfloat *v)) \
-    F(void, Normal3f, (GLfloat nx, GLfloat ny, GLfloat nz)) \
-    F(void, Normal3dv, (const GLdouble *v)) \
-    F(void, Normal3d, (GLdouble nx, GLdouble ny, GLdouble nz)) \
-    F(void, Normal3bv, (const GLbyte *v)) \
-    F(void, Normal3b, (GLbyte nx, GLbyte ny, GLbyte nz)) \
-    F(void, Indexsv, (const GLshort *c)) \
-    F(void, Indexs, (GLshort c)) \
-    F(void, Indexiv, (const GLint *c)) \
-    F(void, Indexi, (GLint c)) \
-    F(void, Indexfv, (const GLfloat *c)) \
-    F(void, Indexf, (GLfloat c)) \
-    F(void, Indexdv, (const GLdouble *c)) \
-    F(void, Indexd, (GLdouble c)) \
-    F(void, End, ()) \
-    F(void, EdgeFlagv, (const GLboolean *flag)) \
-    F(void, EdgeFlag, (GLboolean flag)) \
-    F(void, Color4usv, (const GLushort *v)) \
-    F(void, Color4us, (GLushort red, GLushort green, GLushort blue, GLushort alpha)) \
-    F(void, Color4uiv, (const GLuint *v)) \
-    F(void, Color4ui, (GLuint red, GLuint green, GLuint blue, GLuint alpha)) \
-    F(void, Color4ubv, (const GLubyte *v)) \
-    F(void, Color4ub, (GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)) \
-    F(void, Color4sv, (const GLshort *v)) \
-    F(void, Color4s, (GLshort red, GLshort green, GLshort blue, GLshort alpha)) \
-    F(void, Color4iv, (const GLint *v)) \
-    F(void, Color4i, (GLint red, GLint green, GLint blue, GLint alpha)) \
-    F(void, Color4fv, (const GLfloat *v)) \
-    F(void, Color4f, (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)) \
-    F(void, Color4dv, (const GLdouble *v)) \
-    F(void, Color4d, (GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)) \
-    F(void, Color4bv, (const GLbyte *v)) \
-    F(void, Color4b, (GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)) \
-    F(void, Color3usv, (const GLushort *v)) \
-    F(void, Color3us, (GLushort red, GLushort green, GLushort blue)) \
-    F(void, Color3uiv, (const GLuint *v)) \
-    F(void, Color3ui, (GLuint red, GLuint green, GLuint blue)) \
-    F(void, Color3ubv, (const GLubyte *v)) \
-    F(void, Color3ub, (GLubyte red, GLubyte green, GLubyte blue)) \
-    F(void, Color3sv, (const GLshort *v)) \
-    F(void, Color3s, (GLshort red, GLshort green, GLshort blue)) \
-    F(void, Color3iv, (const GLint *v)) \
-    F(void, Color3i, (GLint red, GLint green, GLint blue)) \
-    F(void, Color3fv, (const GLfloat *v)) \
-    F(void, Color3f, (GLfloat red, GLfloat green, GLfloat blue)) \
-    F(void, Color3dv, (const GLdouble *v)) \
-    F(void, Color3d, (GLdouble red, GLdouble green, GLdouble blue)) \
-    F(void, Color3bv, (const GLbyte *v)) \
-    F(void, Color3b, (GLbyte red, GLbyte green, GLbyte blue)) \
-    F(void, Bitmap, (GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)) \
-    F(void, Begin, (GLenum mode)) \
-    F(void, ListBase, (GLuint base)) \
-    F(GLuint, GenLists, (GLsizei range)) \
-    F(void, DeleteLists, (GLuint list, GLsizei range)) \
-    F(void, CallLists, (GLsizei n, GLenum type, const GLvoid *lists)) \
-    F(void, CallList, (GLuint list)) \
-    F(void, EndList, ()) \
-    F(void, NewList, (GLuint list, GLenum mode)) \
-
-    QT_OPENGL_DECLARE(QT_OPENGL_1_0_DEPRECATED_FUNCTIONS);
-};
-
-class QOpenGLFunctions_1_1_DeprecatedBackend : public QOpenGLVersionFunctionsBackend
-{
-public:
-    QOpenGLFunctions_1_1_DeprecatedBackend(QOpenGLContext *c)
-        : QOpenGLVersionFunctionsBackend(c)
-    {
-        init();
-    }
-
-    Q_DECL_CONSTEXPR static Version versionStatus()
-    { return OpenGL_1_1_Deprecated; }
-
-    // OpenGL 1.1 deprecated functions
-#define QT_OPENGL_1_1_DEPRECATED_FUNCTIONS(F) \
-    F(void, PushClientAttrib, (GLbitfield mask)) \
-    F(void, PopClientAttrib, ()) \
-    F(void, PrioritizeTextures, (GLsizei n, const GLuint *textures, const GLfloat *priorities)) \
-    F(GLboolean, AreTexturesResident, (GLsizei n, const GLuint *textures, GLboolean *residences)) \
-    F(void, VertexPointer, (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)) \
-    F(void, TexCoordPointer, (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)) \
-    F(void, NormalPointer, (GLenum type, GLsizei stride, const GLvoid *pointer)) \
-    F(void, InterleavedArrays, (GLenum format, GLsizei stride, const GLvoid *pointer)) \
-    F(void, IndexPointer, (GLenum type, GLsizei stride, const GLvoid *pointer)) \
-    F(void, EnableClientState, (GLenum array)) \
-    F(void, EdgeFlagPointer, (GLsizei stride, const GLvoid *pointer)) \
-    F(void, DisableClientState, (GLenum array)) \
-    F(void, ColorPointer, (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)) \
-    F(void, ArrayElement, (GLint i)) \
-    F(void, Indexubv, (const GLubyte *c)) \
-    F(void, Indexub, (GLubyte c)) \
-    F(void, GetPointerv, (GLenum pname, GLvoid* *params)) \
-
-    QT_OPENGL_DECLARE(QT_OPENGL_1_1_DEPRECATED_FUNCTIONS);
-};
-
-class QOpenGLFunctions_1_2_DeprecatedBackend : public QOpenGLVersionFunctionsBackend
-{
-public:
-    QOpenGLFunctions_1_2_DeprecatedBackend(QOpenGLContext *c)
-        : QOpenGLVersionFunctionsBackend(c)
-    {
-        init();
-    }
-
-    Q_DECL_CONSTEXPR static Version versionStatus()
-    { return OpenGL_1_2_Deprecated; }
-
-    // OpenGL 1.2 deprecated functions
-#define QT_OPENGL_1_2_DEPRECATED_FUNCTIONS(F) \
-    F(void, ColorTableParameterfv, (GLenum target, GLenum pname, const GLfloat *params)) \
-    F(void, ColorTableParameteriv, (GLenum target, GLenum pname, const GLint *params)) \
-    F(void, CopyColorTable, (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)) \
-    F(void, GetColorTable, (GLenum target, GLenum format, GLenum type, GLvoid *table)) \
-    F(void, GetColorTableParameterfv, (GLenum target, GLenum pname, GLfloat *params)) \
-    F(void, GetColorTableParameteriv, (GLenum target, GLenum pname, GLint *params)) \
-    F(void, ColorSubTable, (GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data)) \
-    F(void, CopyColorSubTable, (GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)) \
-    F(void, ConvolutionFilter1D, (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image)) \
-    F(void, ConvolutionFilter2D, (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image)) \
-    F(void, ConvolutionParameterf, (GLenum target, GLenum pname, GLfloat params)) \
-    F(void, ConvolutionParameterfv, (GLenum target, GLenum pname, const GLfloat *params)) \
-    F(void, ConvolutionParameteri, (GLenum target, GLenum pname, GLint params)) \
-    F(void, ConvolutionParameteriv, (GLenum target, GLenum pname, const GLint *params)) \
-    F(void, CopyConvolutionFilter1D, (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)) \
-    F(void, CopyConvolutionFilter2D, (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)) \
-    F(void, GetConvolutionFilter, (GLenum target, GLenum format, GLenum type, GLvoid *image)) \
-    F(void, GetConvolutionParameterfv, (GLenum target, GLenum pname, GLfloat *params)) \
-    F(void, GetConvolutionParameteriv, (GLenum target, GLenum pname, GLint *params)) \
-    F(void, GetSeparableFilter, (GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span)) \
-    F(void, SeparableFilter2D, (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column)) \
-    F(void, GetHistogram, (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)) \
-    F(void, GetHistogramParameterfv, (GLenum target, GLenum pname, GLfloat *params)) \
-    F(void, GetHistogramParameteriv, (GLenum target, GLenum pname, GLint *params)) \
-    F(void, GetMinmax, (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)) \
-    F(void, GetMinmaxParameterfv, (GLenum target, GLenum pname, GLfloat *params)) \
-    F(void, GetMinmaxParameteriv, (GLenum target, GLenum pname, GLint *params)) \
-    F(void, Histogram, (GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)) \
-    F(void, Minmax, (GLenum target, GLenum internalformat, GLboolean sink)) \
-    F(void, ResetHistogram, (GLenum target)) \
-    F(void, ResetMinmax, (GLenum target)) \
-    F(void, ColorTable, (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table)) \
-
-    QT_OPENGL_DECLARE(QT_OPENGL_1_2_DEPRECATED_FUNCTIONS);
-};
-
-class QOpenGLFunctions_1_3_DeprecatedBackend : public QOpenGLVersionFunctionsBackend
-{
-public:
-    QOpenGLFunctions_1_3_DeprecatedBackend(QOpenGLContext *c)
-        : QOpenGLVersionFunctionsBackend(c)
-    {
-        init();
-    }
-
-    Q_DECL_CONSTEXPR static Version versionStatus()
-    { return OpenGL_1_3_Deprecated; }
-
-    // OpenGL 1.3 deprecated functions
-#define QT_OPENGL_1_3_DEPRECATED_FUNCTIONS(F) \
-    F(void, MultTransposeMatrixd, (const GLdouble *m)) \
-    F(void, MultTransposeMatrixf, (const GLfloat *m)) \
-    F(void, LoadTransposeMatrixd, (const GLdouble *m)) \
-    F(void, LoadTransposeMatrixf, (const GLfloat *m)) \
-    F(void, MultiTexCoord4sv, (GLenum target, const GLshort *v)) \
-    F(void, MultiTexCoord4s, (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)) \
-    F(void, MultiTexCoord4iv, (GLenum target, const GLint *v)) \
-    F(void, MultiTexCoord4i, (GLenum target, GLint s, GLint t, GLint r, GLint q)) \
-    F(void, MultiTexCoord4fv, (GLenum target, const GLfloat *v)) \
-    F(void, MultiTexCoord4f, (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)) \
-    F(void, MultiTexCoord4dv, (GLenum target, const GLdouble *v)) \
-    F(void, MultiTexCoord4d, (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)) \
-    F(void, MultiTexCoord3sv, (GLenum target, const GLshort *v)) \
-    F(void, MultiTexCoord3s, (GLenum target, GLshort s, GLshort t, GLshort r)) \
-    F(void, MultiTexCoord3iv, (GLenum target, const GLint *v)) \
-    F(void, MultiTexCoord3i, (GLenum target, GLint s, GLint t, GLint r)) \
-    F(void, MultiTexCoord3fv, (GLenum target, const GLfloat *v)) \
-    F(void, MultiTexCoord3f, (GLenum target, GLfloat s, GLfloat t, GLfloat r)) \
-    F(void, MultiTexCoord3dv, (GLenum target, const GLdouble *v)) \
-    F(void, MultiTexCoord3d, (GLenum target, GLdouble s, GLdouble t, GLdouble r)) \
-    F(void, MultiTexCoord2sv, (GLenum target, const GLshort *v)) \
-    F(void, MultiTexCoord2s, (GLenum target, GLshort s, GLshort t)) \
-    F(void, MultiTexCoord2iv, (GLenum target, const GLint *v)) \
-    F(void, MultiTexCoord2i, (GLenum target, GLint s, GLint t)) \
-    F(void, MultiTexCoord2fv, (GLenum target, const GLfloat *v)) \
-    F(void, MultiTexCoord2f, (GLenum target, GLfloat s, GLfloat t)) \
-    F(void, MultiTexCoord2dv, (GLenum target, const GLdouble *v)) \
-    F(void, MultiTexCoord2d, (GLenum target, GLdouble s, GLdouble t)) \
-    F(void, MultiTexCoord1sv, (GLenum target, const GLshort *v)) \
-    F(void, MultiTexCoord1s, (GLenum target, GLshort s)) \
-    F(void, MultiTexCoord1iv, (GLenum target, const GLint *v)) \
-    F(void, MultiTexCoord1i, (GLenum target, GLint s)) \
-    F(void, MultiTexCoord1fv, (GLenum target, const GLfloat *v)) \
-    F(void, MultiTexCoord1f, (GLenum target, GLfloat s)) \
-    F(void, MultiTexCoord1dv, (GLenum target, const GLdouble *v)) \
-    F(void, MultiTexCoord1d, (GLenum target, GLdouble s)) \
-    F(void, ClientActiveTexture, (GLenum texture)) \
-
-    QT_OPENGL_DECLARE(QT_OPENGL_1_3_DEPRECATED_FUNCTIONS);
-};
-
-class QOpenGLFunctions_1_4_DeprecatedBackend : public QOpenGLVersionFunctionsBackend
-{
-public:
-    QOpenGLFunctions_1_4_DeprecatedBackend(QOpenGLContext *c)
-        : QOpenGLVersionFunctionsBackend(c)
-    {
-        init();
-    }
-
-    Q_DECL_CONSTEXPR static Version versionStatus()
-    { return OpenGL_1_4_Deprecated; }
-
-    // OpenGL 1.4 deprecated functions
-#define QT_OPENGL_1_4_DEPRECATED_FUNCTIONS(F) \
-    F(void, WindowPos3sv, (const GLshort *v)) \
-    F(void, WindowPos3s, (GLshort x, GLshort y, GLshort z)) \
-    F(void, WindowPos3iv, (const GLint *v)) \
-    F(void, WindowPos3i, (GLint x, GLint y, GLint z)) \
-    F(void, WindowPos3fv, (const GLfloat *v)) \
-    F(void, WindowPos3f, (GLfloat x, GLfloat y, GLfloat z)) \
-    F(void, WindowPos3dv, (const GLdouble *v)) \
-    F(void, WindowPos3d, (GLdouble x, GLdouble y, GLdouble z)) \
-    F(void, WindowPos2sv, (const GLshort *v)) \
-    F(void, WindowPos2s, (GLshort x, GLshort y)) \
-    F(void, WindowPos2iv, (const GLint *v)) \
-    F(void, WindowPos2i, (GLint x, GLint y)) \
-    F(void, WindowPos2fv, (const GLfloat *v)) \
-    F(void, WindowPos2f, (GLfloat x, GLfloat y)) \
-    F(void, WindowPos2dv, (const GLdouble *v)) \
-    F(void, WindowPos2d, (GLdouble x, GLdouble y)) \
-    F(void, SecondaryColorPointer, (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)) \
-    F(void, SecondaryColor3usv, (const GLushort *v)) \
-    F(void, SecondaryColor3us, (GLushort red, GLushort green, GLushort blue)) \
-    F(void, SecondaryColor3uiv, (const GLuint *v)) \
-    F(void, SecondaryColor3ui, (GLuint red, GLuint green, GLuint blue)) \
-    F(void, SecondaryColor3ubv, (const GLubyte *v)) \
-    F(void, SecondaryColor3ub, (GLubyte red, GLubyte green, GLubyte blue)) \
-    F(void, SecondaryColor3sv, (const GLshort *v)) \
-    F(void, SecondaryColor3s, (GLshort red, GLshort green, GLshort blue)) \
-    F(void, SecondaryColor3iv, (const GLint *v)) \
-    F(void, SecondaryColor3i, (GLint red, GLint green, GLint blue)) \
-    F(void, SecondaryColor3fv, (const GLfloat *v)) \
-    F(void, SecondaryColor3f, (GLfloat red, GLfloat green, GLfloat blue)) \
-    F(void, SecondaryColor3dv, (const GLdouble *v)) \
-    F(void, SecondaryColor3d, (GLdouble red, GLdouble green, GLdouble blue)) \
-    F(void, SecondaryColor3bv, (const GLbyte *v)) \
-    F(void, SecondaryColor3b, (GLbyte red, GLbyte green, GLbyte blue)) \
-    F(void, FogCoordPointer, (GLenum type, GLsizei stride, const GLvoid *pointer)) \
-    F(void, FogCoorddv, (const GLdouble *coord)) \
-    F(void, FogCoordd, (GLdouble coord)) \
-    F(void, FogCoordfv, (const GLfloat *coord)) \
-    F(void, FogCoordf, (GLfloat coord)) \
-
-    QT_OPENGL_DECLARE(QT_OPENGL_1_4_DEPRECATED_FUNCTIONS);
-};
-
-class QOpenGLFunctions_2_0_DeprecatedBackend : public QOpenGLVersionFunctionsBackend
-{
-public:
-    QOpenGLFunctions_2_0_DeprecatedBackend(QOpenGLContext *c)
-        : QOpenGLVersionFunctionsBackend(c)
-    {
-        init();
-    }
-
-    Q_DECL_CONSTEXPR static Version versionStatus()
-    { return OpenGL_2_0_Deprecated; }
-
-    // OpenGL 2.0 deprecated functions
-#define QT_OPENGL_2_0_DEPRECATED_FUNCTIONS(F) \
-    F(void, VertexAttrib4usv, (GLuint index, const GLushort *v)) \
-    F(void, VertexAttrib4uiv, (GLuint index, const GLuint *v)) \
-    F(void, VertexAttrib4ubv, (GLuint index, const GLubyte *v)) \
-    F(void, VertexAttrib4sv, (GLuint index, const GLshort *v)) \
-    F(void, VertexAttrib4s, (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)) \
-    F(void, VertexAttrib4iv, (GLuint index, const GLint *v)) \
-    F(void, VertexAttrib4fv, (GLuint index, const GLfloat *v)) \
-    F(void, VertexAttrib4f, (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)) \
-    F(void, VertexAttrib4dv, (GLuint index, const GLdouble *v)) \
-    F(void, VertexAttrib4d, (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)) \
-    F(void, VertexAttrib4bv, (GLuint index, const GLbyte *v)) \
-    F(void, VertexAttrib4Nusv, (GLuint index, const GLushort *v)) \
-    F(void, VertexAttrib4Nuiv, (GLuint index, const GLuint *v)) \
-    F(void, VertexAttrib4Nubv, (GLuint index, const GLubyte *v)) \
-    F(void, VertexAttrib4Nub, (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)) \
-    F(void, VertexAttrib4Nsv, (GLuint index, const GLshort *v)) \
-    F(void, VertexAttrib4Niv, (GLuint index, const GLint *v)) \
-    F(void, VertexAttrib4Nbv, (GLuint index, const GLbyte *v)) \
-    F(void, VertexAttrib3sv, (GLuint index, const GLshort *v)) \
-    F(void, VertexAttrib3s, (GLuint index, GLshort x, GLshort y, GLshort z)) \
-    F(void, VertexAttrib3fv, (GLuint index, const GLfloat *v)) \
-    F(void, VertexAttrib3f, (GLuint index, GLfloat x, GLfloat y, GLfloat z)) \
-    F(void, VertexAttrib3dv, (GLuint index, const GLdouble *v)) \
-    F(void, VertexAttrib3d, (GLuint index, GLdouble x, GLdouble y, GLdouble z)) \
-    F(void, VertexAttrib2sv, (GLuint index, const GLshort *v)) \
-    F(void, VertexAttrib2s, (GLuint index, GLshort x, GLshort y)) \
-    F(void, VertexAttrib2fv, (GLuint index, const GLfloat *v)) \
-    F(void, VertexAttrib2f, (GLuint index, GLfloat x, GLfloat y)) \
-    F(void, VertexAttrib2dv, (GLuint index, const GLdouble *v)) \
-    F(void, VertexAttrib2d, (GLuint index, GLdouble x, GLdouble y)) \
-    F(void, VertexAttrib1sv, (GLuint index, const GLshort *v)) \
-    F(void, VertexAttrib1s, (GLuint index, GLshort x)) \
-    F(void, VertexAttrib1fv, (GLuint index, const GLfloat *v)) \
-    F(void, VertexAttrib1f, (GLuint index, GLfloat x)) \
-    F(void, VertexAttrib1dv, (GLuint index, const GLdouble *v)) \
-    F(void, VertexAttrib1d, (GLuint index, GLdouble x)) \
-
-    QT_OPENGL_DECLARE(QT_OPENGL_2_0_DEPRECATED_FUNCTIONS);
-};
-
-class QOpenGLFunctions_3_0_DeprecatedBackend : public QOpenGLVersionFunctionsBackend
-{
-public:
-    QOpenGLFunctions_3_0_DeprecatedBackend(QOpenGLContext *c)
-        : QOpenGLVersionFunctionsBackend(c)
-    {
-        init();
-    }
-
-    Q_DECL_CONSTEXPR static Version versionStatus()
-    { return OpenGL_3_0_Deprecated; }
-
-    // OpenGL 3.0 deprecated functions
-#define QT_OPENGL_3_0_DEPRECATED_FUNCTIONS(F) \
-    F(void, VertexAttribI4usv, (GLuint index, const GLushort *v)) \
-    F(void, VertexAttribI4ubv, (GLuint index, const GLubyte *v)) \
-    F(void, VertexAttribI4sv, (GLuint index, const GLshort *v)) \
-    F(void, VertexAttribI4bv, (GLuint index, const GLbyte *v)) \
-    F(void, VertexAttribI4uiv, (GLuint index, const GLuint *v)) \
-    F(void, VertexAttribI3uiv, (GLuint index, const GLuint *v)) \
-    F(void, VertexAttribI2uiv, (GLuint index, const GLuint *v)) \
-    F(void, VertexAttribI1uiv, (GLuint index, const GLuint *v)) \
-    F(void, VertexAttribI4iv, (GLuint index, const GLint *v)) \
-    F(void, VertexAttribI3iv, (GLuint index, const GLint *v)) \
-    F(void, VertexAttribI2iv, (GLuint index, const GLint *v)) \
-    F(void, VertexAttribI1iv, (GLuint index, const GLint *v)) \
-    F(void, VertexAttribI4ui, (GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)) \
-    F(void, VertexAttribI3ui, (GLuint index, GLuint x, GLuint y, GLuint z)) \
-    F(void, VertexAttribI2ui, (GLuint index, GLuint x, GLuint y)) \
-    F(void, VertexAttribI1ui, (GLuint index, GLuint x)) \
-    F(void, VertexAttribI4i, (GLuint index, GLint x, GLint y, GLint z, GLint w)) \
-    F(void, VertexAttribI3i, (GLuint index, GLint x, GLint y, GLint z)) \
-    F(void, VertexAttribI2i, (GLuint index, GLint x, GLint y)) \
-    F(void, VertexAttribI1i, (GLuint index, GLint x)) \
-
-    QT_OPENGL_DECLARE(QT_OPENGL_3_0_DEPRECATED_FUNCTIONS);
-};
-
-class QOpenGLFunctions_3_3_DeprecatedBackend : public QOpenGLVersionFunctionsBackend
-{
-public:
-    QOpenGLFunctions_3_3_DeprecatedBackend(QOpenGLContext *c)
-        : QOpenGLVersionFunctionsBackend(c)
-    {
-        init();
-    }
-
-    Q_DECL_CONSTEXPR static Version versionStatus()
-    { return OpenGL_3_3_Deprecated; }
-
-    // OpenGL 3.3 deprecated functions
-#define QT_OPENGL_3_3_DEPRECATED_FUNCTIONS(F) \
-    F(void, SecondaryColorP3uiv, (GLenum type, const GLuint *color)) \
-    F(void, SecondaryColorP3ui, (GLenum type, GLuint color)) \
-    F(void, ColorP4uiv, (GLenum type, const GLuint *color)) \
-    F(void, ColorP4ui, (GLenum type, GLuint color)) \
-    F(void, ColorP3uiv, (GLenum type, const GLuint *color)) \
-    F(void, ColorP3ui, (GLenum type, GLuint color)) \
-    F(void, NormalP3uiv, (GLenum type, const GLuint *coords)) \
-    F(void, NormalP3ui, (GLenum type, GLuint coords)) \
-    F(void, MultiTexCoordP4uiv, (GLenum texture, GLenum type, const GLuint *coords)) \
-    F(void, MultiTexCoordP4ui, (GLenum texture, GLenum type, GLuint coords)) \
-    F(void, MultiTexCoordP3uiv, (GLenum texture, GLenum type, const GLuint *coords)) \
-    F(void, MultiTexCoordP3ui, (GLenum texture, GLenum type, GLuint coords)) \
-    F(void, MultiTexCoordP2uiv, (GLenum texture, GLenum type, const GLuint *coords)) \
-    F(void, MultiTexCoordP2ui, (GLenum texture, GLenum type, GLuint coords)) \
-    F(void, MultiTexCoordP1uiv, (GLenum texture, GLenum type, const GLuint *coords)) \
-    F(void, MultiTexCoordP1ui, (GLenum texture, GLenum type, GLuint coords)) \
-    F(void, TexCoordP4uiv, (GLenum type, const GLuint *coords)) \
-    F(void, TexCoordP4ui, (GLenum type, GLuint coords)) \
-    F(void, TexCoordP3uiv, (GLenum type, const GLuint *coords)) \
-    F(void, TexCoordP3ui, (GLenum type, GLuint coords)) \
-    F(void, TexCoordP2uiv, (GLenum type, const GLuint *coords)) \
-    F(void, TexCoordP2ui, (GLenum type, GLuint coords)) \
-    F(void, TexCoordP1uiv, (GLenum type, const GLuint *coords)) \
-    F(void, TexCoordP1ui, (GLenum type, GLuint coords)) \
-    F(void, VertexP4uiv, (GLenum type, const GLuint *value)) \
-    F(void, VertexP4ui, (GLenum type, GLuint value)) \
-    F(void, VertexP3uiv, (GLenum type, const GLuint *value)) \
-    F(void, VertexP3ui, (GLenum type, GLuint value)) \
-    F(void, VertexP2uiv, (GLenum type, const GLuint *value)) \
-    F(void, VertexP2ui, (GLenum type, GLuint value)) \
-
-    QT_OPENGL_DECLARE(QT_OPENGL_3_3_DEPRECATED_FUNCTIONS);
-};
-
-class QOpenGLFunctions_4_5_DeprecatedBackend : public QOpenGLVersionFunctionsBackend
-{
-public:
-    QOpenGLFunctions_4_5_DeprecatedBackend(QOpenGLContext *c)
-        : QOpenGLVersionFunctionsBackend(c)
-    {
-        init();
-    }
-
-    Q_DECL_CONSTEXPR static Version versionStatus()
-    { return OpenGL_4_5_Deprecated; }
-
-    // OpenGL 4.5 deprecated functions
-#define QT_OPENGL_4_5_DEPRECATED_FUNCTIONS(F) \
-    F(void, GetnMinmax, (GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, GLvoid *values)) \
-    F(void, GetnHistogram, (GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, GLvoid *values)) \
-    F(void, GetnSeparableFilter, (GLenum target, GLenum format, GLenum type, GLsizei rowBufSize, GLvoid *row, GLsizei columnBufSize, GLvoid *column, GLvoid *span)) \
-    F(void, GetnConvolutionFilter, (GLenum target, GLenum format, GLenum type, GLsizei bufSize, GLvoid *image)) \
-    F(void, GetnColorTable, (GLenum target, GLenum format, GLenum type, GLsizei bufSize, GLvoid *table)) \
-    F(void, GetnPolygonStipple, (GLsizei bufSize, GLubyte *pattern)) \
-    F(void, GetnPixelMapusv, (GLenum map, GLsizei bufSize, GLushort *values)) \
-    F(void, GetnPixelMapuiv, (GLenum map, GLsizei bufSize, GLuint *values)) \
-    F(void, GetnPixelMapfv, (GLenum map, GLsizei bufSize, GLfloat *values)) \
-    F(void, GetnMapiv, (GLenum target, GLenum query, GLsizei bufSize, GLint *v)) \
-    F(void, GetnMapfv, (GLenum target, GLenum query, GLsizei bufSize, GLfloat *v)) \
-    F(void, GetnMapdv, (GLenum target, GLenum query, GLsizei bufSize, GLdouble *v)) \
-
-    QT_OPENGL_DECLARE(QT_OPENGL_4_5_DEPRECATED_FUNCTIONS);
-};
-
-#else
-
-// No need for backend classes with function pointers with ES2.
-// All function addresses are independent of context and display.
-
-#endif // !QT_OPENGL_ES_2
-
-#undef QT_OPENGL_DECLARE_FUNCTIONS
-#undef QT_OPENGL_COUNT_FUNCTIONS
-#undef QT_OPENGL_DECLARE
-
-
-QT_END_NAMESPACE
-
-#ifdef Q_OS_WIN
-#pragma pop_macro("MemoryBarrier")
-#endif
-
-#endif // QT_NO_OPENGL
-
-#endif
diff --git a/src/gui/opengl/qopenglversionfunctionsfactory.cpp b/src/gui/opengl/qopenglversionfunctionsfactory.cpp
deleted file mode 100644
index ca7daedf34..0000000000
--- a/src/gui/opengl/qopenglversionfunctionsfactory.cpp
+++ /dev/null
@@ -1,163 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#include "qopenglversionfunctionsfactory_p.h"
-
-#if !defined(QT_OPENGL_ES_2)
-#include "qopenglfunctions_4_5_core.h"
-#include "qopenglfunctions_4_5_compatibility.h"
-#include "qopenglfunctions_4_4_core.h"
-#include "qopenglfunctions_4_4_compatibility.h"
-#include "qopenglfunctions_4_3_core.h"
-#include "qopenglfunctions_4_3_compatibility.h"
-#include "qopenglfunctions_4_2_core.h"
-#include "qopenglfunctions_4_2_compatibility.h"
-#include "qopenglfunctions_4_1_core.h"
-#include "qopenglfunctions_4_1_compatibility.h"
-#include "qopenglfunctions_4_0_core.h"
-#include "qopenglfunctions_4_0_compatibility.h"
-#include "qopenglfunctions_3_3_core.h"
-#include "qopenglfunctions_3_3_compatibility.h"
-#include "qopenglfunctions_3_2_core.h"
-#include "qopenglfunctions_3_2_compatibility.h"
-#include "qopenglfunctions_3_1.h"
-#include "qopenglfunctions_3_0.h"
-#include "qopenglfunctions_2_1.h"
-#include "qopenglfunctions_2_0.h"
-#include "qopenglfunctions_1_5.h"
-#include "qopenglfunctions_1_4.h"
-#include "qopenglfunctions_1_3.h"
-#include "qopenglfunctions_1_2.h"
-#include "qopenglfunctions_1_1.h"
-#include "qopenglfunctions_1_0.h"
-#else
-#include "qopenglfunctions_es2.h"
-#endif
-
-QT_BEGIN_NAMESPACE
-
-QAbstractOpenGLFunctions *QOpenGLVersionFunctionsFactory::create(const QOpenGLVersionProfile &versionProfile)
-{
-#if !defined(QT_OPENGL_ES_2)
-    const int major = versionProfile.version().first;
-    const int minor = versionProfile.version().second;
-
-    if (versionProfile.hasProfiles()) {
-        switch (versionProfile.profile()) {
-        case QSurfaceFormat::CoreProfile:
-            if (major == 4 && minor == 5)
-                return new QOpenGLFunctions_4_5_Core;
-            else if (major == 4 && minor == 4)
-                return new QOpenGLFunctions_4_4_Core;
-            else if (major == 4 && minor == 3)
-                return new QOpenGLFunctions_4_3_Core;
-            else if (major == 4 && minor == 2)
-                return new QOpenGLFunctions_4_2_Core;
-            else if (major == 4 && minor == 1)
-                return new QOpenGLFunctions_4_1_Core;
-            else if (major == 4 && minor == 0)
-                return new QOpenGLFunctions_4_0_Core;
-            else if (major == 3 && minor == 3)
-                return new QOpenGLFunctions_3_3_Core;
-            else if (major == 3 && minor == 2)
-                return new QOpenGLFunctions_3_2_Core;
-            break;
-
-        case QSurfaceFormat::CompatibilityProfile:
-            if (major == 4 && minor == 5)
-                return new QOpenGLFunctions_4_5_Compatibility;
-            else if (major == 4 && minor == 4)
-                return new QOpenGLFunctions_4_4_Compatibility;
-            else if (major == 4 && minor == 3)
-                return new QOpenGLFunctions_4_3_Compatibility;
-            else if (major == 4 && minor == 2)
-                return new QOpenGLFunctions_4_2_Compatibility;
-            else if (major == 4 && minor == 1)
-                return new QOpenGLFunctions_4_1_Compatibility;
-            else if (major == 4 && minor == 0)
-                return new QOpenGLFunctions_4_0_Compatibility;
-            else if (major == 3 && minor == 3)
-                return new QOpenGLFunctions_3_3_Compatibility;
-            else if (major == 3 && minor == 2)
-                return new QOpenGLFunctions_3_2_Compatibility;
-            break;
-
-        case QSurfaceFormat::NoProfile:
-        default:
-            break;
-        };
-    } else {
-        if (major == 3 && minor == 1)
-            return new QOpenGLFunctions_3_1;
-        else if (major == 3 && minor == 0)
-            return new QOpenGLFunctions_3_0;
-        else if (major == 2 && minor == 1)
-            return new QOpenGLFunctions_2_1;
-        else if (major == 2 && minor == 0)
-            return new QOpenGLFunctions_2_0;
-        else if (major == 1 && minor == 5)
-            return new QOpenGLFunctions_1_5;
-        else if (major == 1 && minor == 4)
-            return new QOpenGLFunctions_1_4;
-        else if (major == 1 && minor == 3)
-            return new QOpenGLFunctions_1_3;
-        else if (major == 1 && minor == 2)
-            return new QOpenGLFunctions_1_2;
-        else if (major == 1 && minor == 1)
-            return new QOpenGLFunctions_1_1;
-        else if (major == 1 && minor == 0)
-            return new QOpenGLFunctions_1_0;
-    }
-    return nullptr;
-#else
-    Q_UNUSED(versionProfile);
-    return new QOpenGLFunctions_ES2;
-#endif
-}
-
-QT_END_NAMESPACE
diff --git a/src/gui/opengl/qopenglversionfunctionsfactory_p.h b/src/gui/opengl/qopenglversionfunctionsfactory_p.h
deleted file mode 100644
index 469a9cc624..0000000000
--- a/src/gui/opengl/qopenglversionfunctionsfactory_p.h
+++ /dev/null
@@ -1,83 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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$
-**
-**
-** This file was generated by glgen version 0.1
-** Command line was: glgen
-**
-** glgen is Copyright (C) 2012 Klaralvdalens Datakonsult AB (KDAB)
-**
-** This is an auto-generated file.
-** Do not edit! All changes made to it will be lost.
-**
-****************************************************************************/
-
-#ifndef QOPENGLVERSIONFUNCTIONFACTORY_P_H
-#define QOPENGLVERSIONFUNCTIONFACTORY_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 <QtGui/private/qtguiglobal_p.h>
-
-#ifndef QT_NO_OPENGL
-
-#include <QtGui/qopenglcontext.h>
-
-QT_BEGIN_NAMESPACE
-
-class QAbstractOpenGLFunctions;
-
-class QOpenGLVersionFunctionsFactory
-{
-public:
-    static QAbstractOpenGLFunctions *create(const QOpenGLVersionProfile &versionProfile);
-};
-
-QT_END_NAMESPACE
-
-#endif // QT_NO_OPENGL
-
-#endif
diff --git a/src/gui/opengl/qopenglvertexarrayobject.cpp b/src/gui/opengl/qopenglvertexarrayobject.cpp
deleted file mode 100644
index f15fe06ee8..0000000000
--- a/src/gui/opengl/qopenglvertexarrayobject.cpp
+++ /dev/null
@@ -1,531 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2014 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com, author Sean Harmer <sean.harmer@kdab.com>
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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 "qopenglvertexarrayobject.h"
-
-#include <QtCore/private/qobject_p.h>
-#include <QtCore/qthread.h>
-#include <QtGui/qopenglcontext.h>
-#include <QtGui/qoffscreensurface.h>
-#include <QtGui/qguiapplication.h>
-
-#include <QtGui/qopenglfunctions_3_0.h>
-#include <QtGui/qopenglfunctions_3_2_core.h>
-
-#include <private/qopenglextensions_p.h>
-#include <private/qopenglvertexarrayobject_p.h>
-
-QT_BEGIN_NAMESPACE
-
-class QOpenGLFunctions_3_0;
-class QOpenGLFunctions_3_2_Core;
-
-void qtInitializeVertexArrayObjectHelper(QOpenGLVertexArrayObjectHelper *helper, QOpenGLContext *context)
-{
-    Q_ASSERT(helper);
-    Q_ASSERT(context);
-
-    bool tryARB = true;
-
-    if (context->isOpenGLES()) {
-        if (context->format().majorVersion() >= 3) {
-            QOpenGLExtraFunctionsPrivate *extra = static_cast<QOpenGLExtensions *>(context->extraFunctions())->d();
-            helper->GenVertexArrays = extra->f.GenVertexArrays;
-            helper->DeleteVertexArrays = extra->f.DeleteVertexArrays;
-            helper->BindVertexArray = extra->f.BindVertexArray;
-            helper->IsVertexArray = extra->f.IsVertexArray;
-            tryARB = false;
-        } else if (context->hasExtension(QByteArrayLiteral("GL_OES_vertex_array_object"))) {
-            helper->GenVertexArrays = reinterpret_cast<QOpenGLVertexArrayObjectHelper::qt_GenVertexArrays_t>(context->getProcAddress("glGenVertexArraysOES"));
-            helper->DeleteVertexArrays = reinterpret_cast<QOpenGLVertexArrayObjectHelper::qt_DeleteVertexArrays_t>(context->getProcAddress("glDeleteVertexArraysOES"));
-            helper->BindVertexArray = reinterpret_cast<QOpenGLVertexArrayObjectHelper::qt_BindVertexArray_t>(context->getProcAddress("glBindVertexArrayOES"));
-            helper->IsVertexArray = reinterpret_cast<QOpenGLVertexArrayObjectHelper::qt_IsVertexArray_t>(context->getProcAddress("glIsVertexArrayOES"));
-            tryARB = false;
-        }
-    } else if (context->hasExtension(QByteArrayLiteral("GL_APPLE_vertex_array_object")) &&
-               !context->hasExtension(QByteArrayLiteral("GL_ARB_vertex_array_object"))) {
-        helper->GenVertexArrays = reinterpret_cast<QOpenGLVertexArrayObjectHelper::qt_GenVertexArrays_t>(context->getProcAddress("glGenVertexArraysAPPLE"));
-        helper->DeleteVertexArrays = reinterpret_cast<QOpenGLVertexArrayObjectHelper::qt_DeleteVertexArrays_t>(context->getProcAddress("glDeleteVertexArraysAPPLE"));
-        helper->BindVertexArray = reinterpret_cast<QOpenGLVertexArrayObjectHelper::qt_BindVertexArray_t>(context->getProcAddress("glBindVertexArrayAPPLE"));
-        helper->IsVertexArray = reinterpret_cast<QOpenGLVertexArrayObjectHelper::qt_IsVertexArray_t>(context->getProcAddress("glIsVertexArrayAPPLE"));
-        tryARB = false;
-    }
-
-    if (tryARB && context->hasExtension(QByteArrayLiteral("GL_ARB_vertex_array_object"))) {
-        helper->GenVertexArrays = reinterpret_cast<QOpenGLVertexArrayObjectHelper::qt_GenVertexArrays_t>(context->getProcAddress("glGenVertexArrays"));
-        helper->DeleteVertexArrays = reinterpret_cast<QOpenGLVertexArrayObjectHelper::qt_DeleteVertexArrays_t>(context->getProcAddress("glDeleteVertexArrays"));
-        helper->BindVertexArray = reinterpret_cast<QOpenGLVertexArrayObjectHelper::qt_BindVertexArray_t>(context->getProcAddress("glBindVertexArray"));
-        helper->IsVertexArray = reinterpret_cast<QOpenGLVertexArrayObjectHelper::qt_IsVertexArray_t>(context->getProcAddress("glIsVertexArray"));
-    }
-}
-
-class QOpenGLVertexArrayObjectPrivate : public QObjectPrivate
-{
-public:
-    QOpenGLVertexArrayObjectPrivate()
-        : vao(0)
-        , vaoFuncsType(NotSupported)
-        , context(nullptr)
-    {
-    }
-
-    ~QOpenGLVertexArrayObjectPrivate()
-    {
-        if (vaoFuncsType == ARB || vaoFuncsType == APPLE || vaoFuncsType == OES)
-            delete vaoFuncs.helper;
-    }
-
-    bool create();
-    void destroy();
-    void bind();
-    void release();
-    void _q_contextAboutToBeDestroyed();
-
-    Q_DECLARE_PUBLIC(QOpenGLVertexArrayObject)
-
-    GLuint vao;
-
-    union {
-        QOpenGLFunctions_3_0 *core_3_0;
-        QOpenGLFunctions_3_2_Core *core_3_2;
-        QOpenGLVertexArrayObjectHelper *helper;
-    } vaoFuncs;
-    enum {
-        NotSupported,
-        Core_3_0,
-        Core_3_2,
-        ARB,
-        APPLE,
-        OES
-    } vaoFuncsType;
-
-    QOpenGLContext *context;
-};
-
-bool QOpenGLVertexArrayObjectPrivate::create()
-{
-    if (vao) {
-        qWarning("QOpenGLVertexArrayObject::create() VAO is already created");
-        return false;
-    }
-
-    Q_Q(QOpenGLVertexArrayObject);
-
-    QOpenGLContext *ctx = QOpenGLContext::currentContext();
-    if (!ctx) {
-        qWarning("QOpenGLVertexArrayObject::create() requires a valid current OpenGL context");
-        return false;
-    }
-
-    //Fail early, if context is the same as ctx, it means we have tried to initialize for this context and failed
-    if (ctx == context)
-        return false;
-
-    context = ctx;
-    QObject::connect(context, SIGNAL(aboutToBeDestroyed()), q, SLOT(_q_contextAboutToBeDestroyed()));
-
-    if (ctx->isOpenGLES()) {
-        if (ctx->format().majorVersion() >= 3 || ctx->hasExtension(QByteArrayLiteral("GL_OES_vertex_array_object"))) {
-            vaoFuncs.helper = new QOpenGLVertexArrayObjectHelper(ctx);
-            vaoFuncsType = OES;
-            vaoFuncs.helper->glGenVertexArrays(1, &vao);
-        }
-    } else {
-        vaoFuncs.core_3_0 = nullptr;
-        vaoFuncsType = NotSupported;
-        QSurfaceFormat format = ctx->format();
-#ifndef QT_OPENGL_ES_2
-        if (format.version() >= qMakePair<int, int>(3,2)) {
-            vaoFuncs.core_3_2 = ctx->versionFunctions<QOpenGLFunctions_3_2_Core>();
-            vaoFuncsType = Core_3_2;
-            vaoFuncs.core_3_2->glGenVertexArrays(1, &vao);
-        } else if (format.majorVersion() >= 3) {
-            vaoFuncs.core_3_0 = ctx->versionFunctions<QOpenGLFunctions_3_0>();
-            vaoFuncsType = Core_3_0;
-            vaoFuncs.core_3_0->glGenVertexArrays(1, &vao);
-        } else
-#endif
-        if (ctx->hasExtension(QByteArrayLiteral("GL_ARB_vertex_array_object"))) {
-            vaoFuncs.helper = new QOpenGLVertexArrayObjectHelper(ctx);
-            vaoFuncsType = ARB;
-            vaoFuncs.helper->glGenVertexArrays(1, &vao);
-        } else if (ctx->hasExtension(QByteArrayLiteral("GL_APPLE_vertex_array_object"))) {
-            vaoFuncs.helper = new QOpenGLVertexArrayObjectHelper(ctx);
-            vaoFuncsType = APPLE;
-            vaoFuncs.helper->glGenVertexArrays(1, &vao);
-        }
-    }
-
-    return (vao != 0);
-}
-
-void QOpenGLVertexArrayObjectPrivate::destroy()
-{
-    Q_Q(QOpenGLVertexArrayObject);
-
-    QOpenGLContext *ctx = QOpenGLContext::currentContext();
-    QOpenGLContext *oldContext = nullptr;
-    QSurface *oldContextSurface = nullptr;
-    QScopedPointer<QOffscreenSurface> offscreenSurface;
-    if (context && context != ctx) {
-        oldContext = ctx;
-        oldContextSurface = ctx ? ctx->surface() : nullptr;
-        // Before going through the effort of creating an offscreen surface
-        // check that we are on the GUI thread because otherwise many platforms
-        // will not able to create that offscreen surface.
-        if (QThread::currentThread() != qGuiApp->thread()) {
-            ctx = nullptr;
-        } else {
-            // Cannot just make the current surface current again with another context.
-            // The format may be incompatible and some platforms (iOS) may impose
-            // restrictions on using a window with different contexts. Create an
-            // offscreen surface (a pbuffer or a hidden window) instead to be safe.
-            offscreenSurface.reset(new QOffscreenSurface);
-            offscreenSurface->setFormat(context->format());
-            offscreenSurface->create();
-            if (context->makeCurrent(offscreenSurface.data())) {
-                ctx = context;
-            } else {
-                qWarning("QOpenGLVertexArrayObject::destroy() failed to make VAO's context current");
-                ctx = nullptr;
-            }
-        }
-    }
-
-    if (context) {
-        QObject::disconnect(context, SIGNAL(aboutToBeDestroyed()), q, SLOT(_q_contextAboutToBeDestroyed()));
-        context = nullptr;
-    }
-
-    if (vao && ctx) {
-        switch (vaoFuncsType) {
-#ifndef QT_OPENGL_ES_2
-        case Core_3_2:
-            vaoFuncs.core_3_2->glDeleteVertexArrays(1, &vao);
-            break;
-        case Core_3_0:
-            vaoFuncs.core_3_0->glDeleteVertexArrays(1, &vao);
-            break;
-#endif
-        case ARB:
-        case APPLE:
-        case OES:
-            vaoFuncs.helper->glDeleteVertexArrays(1, &vao);
-            break;
-        default:
-            break;
-        }
-
-        vao = 0;
-    }
-
-    if (oldContext && oldContextSurface) {
-        if (!oldContext->makeCurrent(oldContextSurface))
-            qWarning("QOpenGLVertexArrayObject::destroy() failed to restore current context");
-    }
-}
-
-/*!
-    \internal
-*/
-void QOpenGLVertexArrayObjectPrivate::_q_contextAboutToBeDestroyed()
-{
-    destroy();
-}
-
-void QOpenGLVertexArrayObjectPrivate::bind()
-{
-    switch (vaoFuncsType) {
-#ifndef QT_OPENGL_ES_2
-    case Core_3_2:
-        vaoFuncs.core_3_2->glBindVertexArray(vao);
-        break;
-    case Core_3_0:
-        vaoFuncs.core_3_0->glBindVertexArray(vao);
-        break;
-#endif
-    case ARB:
-    case APPLE:
-    case OES:
-        vaoFuncs.helper->glBindVertexArray(vao);
-        break;
-    default:
-        break;
-    }
-}
-
-void QOpenGLVertexArrayObjectPrivate::release()
-{
-    switch (vaoFuncsType) {
-#ifndef QT_OPENGL_ES_2
-    case Core_3_2:
-        vaoFuncs.core_3_2->glBindVertexArray(0);
-        break;
-    case Core_3_0:
-        vaoFuncs.core_3_0->glBindVertexArray(0);
-        break;
-#endif
-    case ARB:
-    case APPLE:
-    case OES:
-        vaoFuncs.helper->glBindVertexArray(0);
-        break;
-    default:
-        break;
-    }
-}
-
-
-/*!
-    \class QOpenGLVertexArrayObject
-    \brief The QOpenGLVertexArrayObject class wraps an OpenGL Vertex Array Object.
-    \inmodule QtGui
-    \since 5.1
-    \ingroup painting-3D
-
-    A Vertex Array Object (VAO) is an OpenGL container object that encapsulates
-    the state needed to specify per-vertex attribute data to the OpenGL pipeline.
-    To put it another way, a VAO remembers the states of buffer objects (see
-    QOpenGLBuffer) and their associated state (e.g. vertex attribute divisors).
-    This allows a very easy and efficient method of switching between OpenGL buffer
-    states for rendering different "objects" in a scene. The QOpenGLVertexArrayObject
-    class is a thin wrapper around an OpenGL VAO.
-
-    For the desktop, VAOs are supported as a core feature in OpenGL 3.0 or newer and by the
-    GL_ARB_vertex_array_object for older versions. On OpenGL ES 2, VAOs are provided by
-    the optional GL_OES_vertex_array_object extension. You can check the version of
-    OpenGL with QOpenGLContext::surfaceFormat() and check for the presence of extensions
-    with QOpenGLContext::hasExtension().
-
-    As with the other Qt OpenGL classes, QOpenGLVertexArrayObject has a create()
-    function to create the underlying OpenGL object. This is to allow the developer to
-    ensure that there is a valid current OpenGL context at the time.
-
-    Once you have successfully created a VAO the typical usage pattern is:
-
-    \list
-        \li In scene initialization function, for each visual object:
-        \list
-            \li Bind the VAO
-            \li Set vertex data state for this visual object (vertices, normals, texture coordinates etc.)
-            \li Unbind (release()) the VAO
-        \endlist
-        \li In render function, for each visual object:
-        \list
-            \li Bind the VAO (and shader program if needed)
-            \li Call a glDraw*() function
-            \li Unbind (release()) the VAO
-        \endlist
-    \endlist
-
-    The act of binding the VAO in the render function has the effect of restoring
-    all of the vertex data state setup in the initialization phase. In this way we can
-    set a great deal of state when setting up a VAO and efficiently switch between
-    state sets of objects to be rendered. Using VAOs also allows the OpenGL driver
-    to amortise the validation checks of the vertex data.
-
-    \note Vertex Array Objects, like all other OpenGL container objects, are specific
-    to the context for which they were created and cannot be shared amongst a
-    context group.
-
-    \sa QOpenGLVertexArrayObject::Binder, QOpenGLBuffer
-*/
-
-/*!
-    Creates a QOpenGLVertexArrayObject with the given \a parent. You must call create()
-    with a valid OpenGL context before using.
-*/
-QOpenGLVertexArrayObject::QOpenGLVertexArrayObject(QObject* parent)
-    : QObject(*new QOpenGLVertexArrayObjectPrivate, parent)
-{
-}
-
-/*!
-    \internal
-*/
-QOpenGLVertexArrayObject::QOpenGLVertexArrayObject(QOpenGLVertexArrayObjectPrivate &dd)
-    : QObject(dd)
-{
-}
-
-/*!
-    Destroys the QOpenGLVertexArrayObject and the underlying OpenGL resource.
-*/
-QOpenGLVertexArrayObject::~QOpenGLVertexArrayObject()
-{
-    destroy();
-}
-
-/*!
-    Creates the underlying OpenGL vertex array object. There must be a valid OpenGL context
-    that supports vertex array objects current for this function to succeed.
-
-    Returns \c true if the OpenGL vertex array object was successfully created.
-
-    When the return value is \c false, vertex array object support is not available. This
-    is not an error: on systems with OpenGL 2.x or OpenGL ES 2.0 vertex array objects may
-    not be supported. The application is free to continue execution in this case, but it
-    then has to be prepared to operate in a VAO-less manner too. This means that instead
-    of merely calling bind(), the value of isCreated() must be checked and the vertex
-    arrays has to be initialized in the traditional way when there is no vertex array
-    object present.
-
-    \sa isCreated()
-*/
-bool QOpenGLVertexArrayObject::create()
-{
-    Q_D(QOpenGLVertexArrayObject);
-    return d->create();
-}
-
-/*!
-    Destroys the underlying OpenGL vertex array object. There must be a valid OpenGL context
-    that supports vertex array objects current for this function to succeed.
-*/
-void QOpenGLVertexArrayObject::destroy()
-{
-    Q_D(QOpenGLVertexArrayObject);
-    d->destroy();
-}
-
-/*!
-    Returns \c true is the underlying OpenGL vertex array object has been created. If this
-    returns \c true and the associated OpenGL context is current, then you are able to bind()
-    this object.
-*/
-bool QOpenGLVertexArrayObject::isCreated() const
-{
-    Q_D(const QOpenGLVertexArrayObject);
-    return (d->vao != 0);
-}
-
-/*!
-    Returns the id of the underlying OpenGL vertex array object.
-*/
-GLuint QOpenGLVertexArrayObject::objectId() const
-{
-    Q_D(const QOpenGLVertexArrayObject);
-    return d->vao;
-}
-
-/*!
-    Binds this vertex array object to the OpenGL binding point. From this point on
-    and until release() is called or another vertex array object is bound, any
-    modifications made to vertex data state are stored inside this vertex array object.
-
-    If another vertex array object is then bound you can later restore the set of
-    state associated with this object by calling bind() on this object once again.
-    This allows efficient changes between vertex data states in rendering functions.
-*/
-void QOpenGLVertexArrayObject::bind()
-{
-    Q_D(QOpenGLVertexArrayObject);
-    d->bind();
-}
-
-/*!
-    Unbinds this vertex array object by binding the default vertex array object (id = 0).
-*/
-void QOpenGLVertexArrayObject::release()
-{
-    Q_D(QOpenGLVertexArrayObject);
-    d->release();
-}
-
-
-/*!
-    \class QOpenGLVertexArrayObject::Binder
-    \brief The QOpenGLVertexArrayObject::Binder class is a convenience class to help
-    with the binding and releasing of OpenGL Vertex Array Objects.
-    \inmodule QtGui
-    \reentrant
-    \since 5.1
-    \ingroup painting-3D
-
-    QOpenGLVertexArrayObject::Binder is a simple convenience class that can be used
-    to assist with the binding and releasing of QOpenGLVertexArrayObject instances.
-    This class is to QOpenGLVertexArrayObject as QMutexLocker is to QMutex.
-
-    This class implements the RAII principle which helps to ensure behavior in
-    complex code or in the presence of exceptions.
-
-    The constructor of this class accepts a QOpenGLVertexArrayObject (VAO) as an
-    argument and attempts to bind the VAO, calling QOpenGLVertexArrayObject::create()
-    if necessary. The destructor of this class calls QOpenGLVertexArrayObject::release()
-    which unbinds the VAO.
-
-    If needed the VAO can be temporarily unbound with the release() function and bound
-    once more with rebind().
-
-    \sa QOpenGLVertexArrayObject
-*/
-
-/*!
-    \fn QOpenGLVertexArrayObject::Binder::Binder(QOpenGLVertexArrayObject *v)
-
-    Creates a QOpenGLVertexArrayObject::Binder object and binds \a v by calling
-    QOpenGLVertexArrayObject::bind(). If necessary it first calls
-    QOpenGLVertexArrayObject::create().
-*/
-
-/*!
-    \fn QOpenGLVertexArrayObject::Binder::~Binder()
-
-    Destroys the QOpenGLVertexArrayObject::Binder and releases the associated vertex array object.
-*/
-
-/*!
-    \fn QOpenGLVertexArrayObject::Binder::release()
-
-    Can be used to temporarily release the associated vertex array object.
-
-    \sa rebind()
-*/
-
-/*!
-    \fn QOpenGLVertexArrayObject::Binder::rebind()
-
-    Can be used to rebind the associated vertex array object.
-
-    \sa release()
-*/
-
-QT_END_NAMESPACE
-
-#include "moc_qopenglvertexarrayobject.cpp"
diff --git a/src/gui/opengl/qopenglvertexarrayobject.h b/src/gui/opengl/qopenglvertexarrayobject.h
deleted file mode 100644
index b81ae6a2a9..0000000000
--- a/src/gui/opengl/qopenglvertexarrayobject.h
+++ /dev/null
@@ -1,111 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2014 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com, author Sean Harmer <sean.harmer@kdab.com>
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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 QOPENGLVERTEXARRAYOBJECT_H
-#define QOPENGLVERTEXARRAYOBJECT_H
-
-#include <QtGui/qtguiglobal.h>
-
-#ifndef QT_NO_OPENGL
-
-#include <QtCore/QObject>
-#include <QtGui/qopengl.h>
-
-QT_BEGIN_NAMESPACE
-
-class QOpenGLVertexArrayObjectPrivate;
-
-class Q_GUI_EXPORT QOpenGLVertexArrayObject : public QObject
-{
-    Q_OBJECT
-
-public:
-    explicit QOpenGLVertexArrayObject(QObject* parent = nullptr);
-    ~QOpenGLVertexArrayObject();
-
-    bool create();
-    void destroy();
-    bool isCreated() const;
-    GLuint objectId() const;
-    void bind();
-    void release();
-
-    class Q_GUI_EXPORT Binder
-    {
-    public:
-        inline Binder(QOpenGLVertexArrayObject *v)
-            : vao(v)
-        {
-            Q_ASSERT(v);
-            if (vao->isCreated() || vao->create())
-                vao->bind();
-        }
-
-        inline ~Binder()
-        {
-            release();
-        }
-
-        inline void release()
-        {
-            vao->release();
-        }
-
-        inline void rebind()
-        {
-            vao->bind();
-        }
-
-    private:
-        Q_DISABLE_COPY(Binder)
-        QOpenGLVertexArrayObject *vao;
-    };
-
-private:
-    Q_DISABLE_COPY(QOpenGLVertexArrayObject)
-    Q_DECLARE_PRIVATE(QOpenGLVertexArrayObject)
-    Q_PRIVATE_SLOT(d_func(), void _q_contextAboutToBeDestroyed())
-    QOpenGLVertexArrayObject(QOpenGLVertexArrayObjectPrivate &dd);
-};
-
-QT_END_NAMESPACE
-
-#endif
-
-#endif // QOPENGLVERTEXARRAYOBJECT_H
diff --git a/src/gui/opengl/qopenglvertexarrayobject_p.h b/src/gui/opengl/qopenglvertexarrayobject_p.h
deleted file mode 100644
index fd3a6f0f89..0000000000
--- a/src/gui/opengl/qopenglvertexarrayobject_p.h
+++ /dev/null
@@ -1,125 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2014 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com, author Sean Harmer <sean.harmer@kdab.com>
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui 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 QOPENGLVERTEXARRAYOBJECT_P_H
-#define QOPENGLVERTEXARRAYOBJECT_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 <QtCore/qglobal.h>
-
-#ifndef QT_NO_OPENGL
-
-#include <QtGui/qopengl.h>
-
-QT_BEGIN_NAMESPACE
-
-class QOpenGLVertexArrayObjectHelper;
-class QOpenGLContext;
-
-void Q_GUI_EXPORT qtInitializeVertexArrayObjectHelper(QOpenGLVertexArrayObjectHelper *helper, QOpenGLContext *context);
-
-class QOpenGLVertexArrayObjectHelper
-{
-    Q_DISABLE_COPY(QOpenGLVertexArrayObjectHelper)
-
-public:
-    explicit inline QOpenGLVertexArrayObjectHelper(QOpenGLContext *context)
-        : GenVertexArrays(nullptr)
-        , DeleteVertexArrays(nullptr)
-        , BindVertexArray(nullptr)
-        , IsVertexArray(nullptr)
-    {
-        qtInitializeVertexArrayObjectHelper(this, context);
-    }
-
-    inline bool isValid() const
-    {
-        return GenVertexArrays && DeleteVertexArrays && BindVertexArray && IsVertexArray;
-    }
-
-    inline void glGenVertexArrays(GLsizei n, GLuint *arrays) const
-    {
-        GenVertexArrays(n, arrays);
-    }
-
-    inline void glDeleteVertexArrays(GLsizei n, const GLuint *arrays) const
-    {
-        DeleteVertexArrays(n, arrays);
-    }
-
-    inline void glBindVertexArray(GLuint array) const
-    {
-        BindVertexArray(array);
-    }
-
-    inline GLboolean glIsVertexArray(GLuint array) const
-    {
-        return IsVertexArray(array);
-    }
-
-private:
-    friend void Q_GUI_EXPORT qtInitializeVertexArrayObjectHelper(QOpenGLVertexArrayObjectHelper *helper, QOpenGLContext *context);
-
-    // Function signatures are equivalent between desktop core, ARB, APPLE, ES 3 and ES 2 extensions
-    typedef void (QOPENGLF_APIENTRYP qt_GenVertexArrays_t)(GLsizei n, GLuint *arrays);
-    typedef void (QOPENGLF_APIENTRYP qt_DeleteVertexArrays_t)(GLsizei n, const GLuint *arrays);
-    typedef void (QOPENGLF_APIENTRYP qt_BindVertexArray_t)(GLuint array);
-    typedef GLboolean (QOPENGLF_APIENTRYP qt_IsVertexArray_t)(GLuint array);
-
-    qt_GenVertexArrays_t GenVertexArrays;
-    qt_DeleteVertexArrays_t DeleteVertexArrays;
-    qt_BindVertexArray_t BindVertexArray;
-    qt_IsVertexArray_t IsVertexArray;
-};
-
-QT_END_NAMESPACE
-
-#endif // QT_NO_OPENGL
-
-#endif // QOPENGLVERTEXARRAYOBJECT_P_H
diff --git a/src/gui/opengl/qt_attribution.json b/src/gui/opengl/qt_attribution.json
index d3ff10d803..44310980e2 100644
--- a/src/gui/opengl/qt_attribution.json
+++ b/src/gui/opengl/qt_attribution.json
@@ -5,7 +5,7 @@
         "QDocModule": "qtgui",
         "Description": "OpenGL header generated from the Khronos OpenGL / OpenGL ES XML API Registry.",
         "QtUsage": "Used on Windows and Linux in the OpenGL related headers of Qt GUI.",
-        "Path": "qopenglext.h",
+        "Files": "qopenglext.h",
 
         "Homepage": "https://www.khronos.org/",
         "Version": "Revision 27684",
@@ -20,7 +20,7 @@
         "QDocModule": "qtgui",
         "Description": "OpenGL ES 2 header generated from the Khronos OpenGL / OpenGL ES XML API Registry.",
         "QtUsage": "Used on Windows and Linux in the OpenGL related headers of Qt GUI.",
-        "Path": "qopengles2ext.h",
+        "Files": "qopengles2ext.h",
 
         "Homepage": "https://www.khronos.org/",
         "Version": "Revision 27673",