Move eglconvenience to QtGui

Task-number: QTBUG-83255
Change-Id: I8a008d8906308dd73a0793db5b88d3a1b6fdaf5c
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: Tor Arne Vestbø <tor.arne.vestbo@qt.io>

1 files changed, 848 insertions, 0 deletions

diff --git a/src/gui/opengl/platform/egl/qeglplatformcontext.cpp b/src/gui/opengl/platform/egl/qeglplatformcontext.cpp
new file mode 100644
index 0000000000..561079b48f
--- /dev/null
+++ b/src/gui/opengl/platform/egl/qeglplatformcontext.cpp
@@ -0,0 +1,848 @@
+/****************************************************************************
+**
+** Copyright (C) 2020 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 "qeglplatformcontext_p.h"
+#include "qeglconvenience_p.h"
+#include "qeglpbuffer_p.h"
+#include <qpa/qplatformwindow.h>
+#include <QtGui/qopenglcontext.h>
+#include <QtCore/qdebug.h>
+
+#if defined(Q_OS_ANDROID) && !defined(Q_OS_ANDROID_EMBEDDED)
+#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);
+        }
+    }
+
+    // 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);
+    }
+
+    // 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