qeglplatformcontext.cpp

/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the plugins 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 <QOpenGLContext>
#include <QtPlatformHeaders/QEGLNativeContext>
#include <QDebug>

#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, const QVariant &nativeHandle, Flags flags)
    : m_eglDisplay(display)
    , m_swapInterval(-1)
    , m_swapIntervalEnvChecked(false)
    , m_swapIntervalFromEnv(-1)
    , m_flags(flags)
{
    if (nativeHandle.isNull()) {
        m_eglConfig = config ? *config : q_configFromGLFormat(display, format);
        m_ownsContext = true;
        init(format, share);
    } else {
        m_ownsContext = false;
        adopt(nativeHandle, share);
    }
}

void QEGLPlatformContext::init(const QSurfaceFormat &format, QPlatformOpenGLContext *share)
{
    m_format = q_glFormatFromConfig(m_eglDisplay, m_eglConfig);
    // 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 : 0;

    QVector<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 = 0;
        m_eglContext = eglCreateContext(m_eglDisplay, m_eglConfig, 0, 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(const QVariant &nativeHandle, QPlatformOpenGLContext *share)
{
    if (!nativeHandle.canConvert<QEGLNativeContext>()) {
        qWarning("QEGLPlatformContext: Requires a QEGLNativeContext");
        return;
    }
    QEGLNativeContext handle = nativeHandle.value<QEGLNativeContext>();
    EGLContext context = handle.context();
    if (!context) {
        qWarning("QEGLPlatformContext: No EGLContext given");
        return;
    }

    // A context belonging to a given EGLDisplay cannot be used with another one.
    if (handle.display() != m_eglDisplay) {
        qWarning("QEGLPlatformContext: Cannot adopt context from different display");
        return;
    }

    // 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) {
        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 : 0;
    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, 0, 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)) {
#if defined(Q_OS_ANDROID) && !defined(Q_OS_ANDROID_EMBEDDED)
                    // Some Android 4.2.2 devices report OpenGL ES 3.0 without the functions being available.
                    static int apiLevel = QtAndroidPrivate::androidSdkVersion();
                    if (apiLevel <= 17 && major >= 3) {
                        major = 2;
                        minor = 0;
                    }
#endif
                    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[] = {
#ifdef QT_OPENGL_ES_2
            { "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_OPENGL_ES_2

#ifdef QT_OPENGL_ES_3
            { "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_OPENGL_ES_3

#ifdef QT_OPENGL_ES_3_1
            { "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_OPENGL_ES_3_1
        };

        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