qopenglcontext.cpp

Go to the documentation of this file.

// 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 <qpa/qplatformopenglcontext.h>
#include <qpa/qplatformintegration.h>
#include "qopenglcontext.h"
#include "qopenglcontext_p.h"
#include "qwindow.h"
 
#include <QtCore/QThreadStorage>
#include <QtCore/QThread>
#include <QtCore/private/qlocking_p.h>
 
#include <QtGui/private/qguiapplication_p.h>
#include <QtGui/private/qopengl_p.h>
#include <QtGui/private/qwindow_p.h>
#include <QtGui/QScreen>
#include <qpa/qplatformnativeinterface.h>
 
#include <private/qopenglextensions_p.h>
 
#include <QDebug>
 
QT_BEGIN_NAMESPACE
 
class QGuiGLThreadContext
{
public:
    QGuiGLThreadContext()
        : context(nullptr)
    {
    }
    ~QGuiGLThreadContext() {
        if (context)
            context->doneCurrent();
    }
    QOpenGLContext *context;
};
 
Q_GLOBAL_STATIC(QThreadStorage<QGuiGLThreadContext *>, qwindow_context_storage);
static QOpenGLContext *global_share_context = nullptr;
 
#ifndef QT_NO_DEBUG
QHash<QOpenGLContext *, bool> QOpenGLContextPrivate::makeCurrentTracker;
Q_CONSTINIT QMutex QOpenGLContextPrivate::makeCurrentTrackerMutex;
#endif
 
void qt_gl_set_global_share_context(QOpenGLContext *context)
{
    global_share_context = context;
}
 
QOpenGLContext *qt_gl_global_share_context()
{
    return global_share_context;
}
 
QOpenGLContext *QOpenGLContextPrivate::setCurrentContext(QOpenGLContext *context)
{
    QGuiGLThreadContext *threadContext = qwindow_context_storage()->localData();
    if (!threadContext) {
        if (!QThread::currentThread()) {
            qWarning("No QTLS available. currentContext won't work");
            return nullptr;
        }
        threadContext = new QGuiGLThreadContext;
        qwindow_context_storage()->setLocalData(threadContext);
    }
    QOpenGLContext *previous = threadContext->context;
    threadContext->context = context;
    return previous;
}
 
int QOpenGLContextPrivate::maxTextureSize()
{
    if (max_texture_size != -1)
        return max_texture_size;
 
    Q_Q(QOpenGLContext);
    QOpenGLFunctions *funcs = q->functions();
    funcs->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max_texture_size);
 
#if !QT_CONFIG(opengles2)
    if (!q->isOpenGLES()) {
        GLenum proxy = GL_PROXY_TEXTURE_2D;
 
        GLint size;
        GLint next = 64;
        funcs->glTexImage2D(proxy, 0, GL_RGBA, next, next, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
 
        QOpenGLExtraFunctions *extraFuncs = q->extraFunctions();
        extraFuncs->glGetTexLevelParameteriv(proxy, 0, GL_TEXTURE_WIDTH, &size);
 
        if (size == 0) {
            return max_texture_size;
        }
        do {
            size = next;
            next = size * 2;
 
            if (next > max_texture_size)
                break;
            funcs->glTexImage2D(proxy, 0, GL_RGBA, next, next, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
            extraFuncs->glGetTexLevelParameteriv(proxy, 0, GL_TEXTURE_WIDTH, &next);
        } while (next > size);
 
        max_texture_size = size;
    }
#endif // QT_CONFIG(opengles2)
 
    return max_texture_size;
}
 
QOpenGLContext* QOpenGLContext::currentContext()
{
    QGuiGLThreadContext *threadContext = qwindow_context_storage()->localData();
    if (threadContext)
        return threadContext->context;
    return nullptr;
}
 
bool QOpenGLContext::areSharing(QOpenGLContext *first, QOpenGLContext *second)
{
    return first->shareGroup() == second->shareGroup();
}
 
QPlatformOpenGLContext *QOpenGLContext::handle() const
{
    Q_D(const QOpenGLContext);
    return d->platformGLContext;
}
 
QPlatformOpenGLContext *QOpenGLContext::shareHandle() const
{
    Q_D(const QOpenGLContext);
    if (d->shareContext)
        return d->shareContext->handle();
    return nullptr;
}
 
QOpenGLContext::QOpenGLContext(QObject *parent)
    : QObject(*new QOpenGLContextPrivate(), parent)
{
    setScreen(QGuiApplication::primaryScreen());
}
 
void QOpenGLContext::setFormat(const QSurfaceFormat &format)
{
    Q_D(QOpenGLContext);
    d->requestedFormat = format;
}
 
void QOpenGLContext::setShareContext(QOpenGLContext *shareContext)
{
    Q_D(QOpenGLContext);
    d->shareContext = shareContext;
}
 
void QOpenGLContext::setScreen(QScreen *screen)
{
    Q_D(QOpenGLContext);
    if (d->screen)
        disconnect(d->screen, SIGNAL(destroyed(QObject*)), this, SLOT(_q_screenDestroyed(QObject*)));
    d->screen = screen;
    if (!d->screen)
        d->screen = QGuiApplication::primaryScreen();
    if (d->screen)
        connect(d->screen, SIGNAL(destroyed(QObject*)), this, SLOT(_q_screenDestroyed(QObject*)));
}
 
void QOpenGLContextPrivate::_q_screenDestroyed(QObject *object)
{
    Q_Q(QOpenGLContext);
    if (object == static_cast<QObject *>(screen)) {
        screen = nullptr;
        q->setScreen(nullptr);
    }
}
 
bool QOpenGLContext::create()
{
    Q_D(QOpenGLContext);
    if (d->platformGLContext)
        destroy();
 
    auto *platformContext = QGuiApplicationPrivate::platformIntegration()->createPlatformOpenGLContext(this);
    if (!platformContext)
        return false;
 
    d->adopt(platformContext);
 
    return isValid();
}
 
QOpenGLContextPrivate::~QOpenGLContextPrivate()
{
}
 
void QOpenGLContextPrivate::adopt(QPlatformOpenGLContext *context)
{
    Q_Q(QOpenGLContext);
 
    platformGLContext = context;
    platformGLContext->setContext(q);
    platformGLContext->initialize();
 
    if (!platformGLContext->isSharing())
        shareContext = nullptr;
    shareGroup = shareContext ? shareContext->shareGroup() : new QOpenGLContextGroup;
    shareGroup->d_func()->addContext(q);
}
 
void QOpenGLContext::destroy()
{
    Q_D(QOpenGLContext);
 
    // Notify that the native context and the QPlatformOpenGLContext are going
    // to go away.
    if (d->platformGLContext)
        emit aboutToBeDestroyed();
 
    // Invoke callbacks for helpers and invalidate.
    if (d->textureFunctionsDestroyCallback) {
        d->textureFunctionsDestroyCallback();
        d->textureFunctionsDestroyCallback = nullptr;
    }
    d->textureFunctions = nullptr;
 
    delete d->versionFunctions;
    d->versionFunctions = nullptr;
 
    if (d->vaoHelperDestroyCallback) {
        Q_ASSERT(d->vaoHelper);
        d->vaoHelperDestroyCallback(d->vaoHelper);
        d->vaoHelperDestroyCallback = nullptr;
    }
    d->vaoHelper = nullptr;
 
    // Tear down function wrappers.
    delete d->versionFunctions;
    d->versionFunctions = nullptr;
 
    delete d->functions;
    d->functions = nullptr;
 
    // Clean up and destroy the native context machinery.
    if (QOpenGLContext::currentContext() == this)
        doneCurrent();
 
    if (d->shareGroup)
        d->shareGroup->d_func()->removeContext(this);
 
    d->shareGroup = nullptr;
 
    delete d->platformGLContext;
    d->platformGLContext = nullptr;
}
 
QOpenGLContext::~QOpenGLContext()
{
    destroy();
 
#ifndef QT_NO_DEBUG
    QOpenGLContextPrivate::cleanMakeCurrentTracker(this);
#endif
}
 
bool QOpenGLContext::isValid() const
{
    Q_D(const QOpenGLContext);
    return d->platformGLContext && d->platformGLContext->isValid();
}
 
QOpenGLFunctions *QOpenGLContext::functions() const
{
    Q_D(const QOpenGLContext);
    if (!d->functions)
        const_cast<QOpenGLFunctions *&>(d->functions) = new QOpenGLExtensions(QOpenGLContext::currentContext());
    return d->functions;
}
 
QOpenGLExtraFunctions *QOpenGLContext::extraFunctions() const
{
    return static_cast<QOpenGLExtraFunctions *>(functions());
}
 
QSet<QByteArray> QOpenGLContext::extensions() const
{
    Q_D(const QOpenGLContext);
    if (d->extensionNames.isEmpty()) {
        QOpenGLExtensionMatcher matcher;
        d->extensionNames = matcher.extensions();
    }
 
    return d->extensionNames;
}
 
bool QOpenGLContext::hasExtension(const QByteArray &extension) const
{
    return extensions().contains(extension);
}
 
GLuint QOpenGLContext::defaultFramebufferObject() const
{
    if (!isValid())
        return 0;
 
    Q_D(const QOpenGLContext);
    if (!d->surface || !d->surface->surfaceHandle())
        return 0;
 
    if (d->defaultFboRedirect)
        return d->defaultFboRedirect;
 
    return d->platformGLContext->defaultFramebufferObject(d->surface->surfaceHandle());
}
 
bool QOpenGLContext::makeCurrent(QSurface *surface)
{
    Q_D(QOpenGLContext);
    if (!isValid())
        return false;
 
    if (Q_UNLIKELY(!qApp->testAttribute(Qt::AA_DontCheckOpenGLContextThreadAffinity)
                   && thread() != QThread::currentThread())) {
        qFatal("Cannot make QOpenGLContext current in a different thread");
    }
 
    if (!surface) {
        doneCurrent();
        return true;
    }
 
    if (!surface->surfaceHandle())
        return false;
    if (!surface->supportsOpenGL()) {
        qWarning() << "QOpenGLContext::makeCurrent() called with non-opengl surface" << surface;
        return false;
    }
 
    if (!d->platformGLContext->makeCurrent(surface->surfaceHandle()))
        return false;
 
    QOpenGLContextPrivate::setCurrentContext(this);
#ifndef QT_NO_DEBUG
    QOpenGLContextPrivate::toggleMakeCurrentTracker(this, true);
#endif
 
    d->surface = surface;
 
    static bool needsWorkaroundSet = false;
    static bool needsWorkaround = false;
 
    if (!needsWorkaroundSet) {
        QByteArray env;
#ifdef Q_OS_ANDROID
        env = qgetenv(QByteArrayLiteral("QT_ANDROID_DISABLE_GLYPH_CACHE_WORKAROUND"));
        needsWorkaround = env.isEmpty() || env == QByteArrayLiteral("0") || env == QByteArrayLiteral("false");
#endif
        env = qgetenv(QByteArrayLiteral("QT_ENABLE_GLYPH_CACHE_WORKAROUND"));
        if (env == QByteArrayLiteral("1") || env == QByteArrayLiteral("true"))
            needsWorkaround = true;
 
        if (!needsWorkaround) {
            const char *rendererString = reinterpret_cast<const char *>(functions()->glGetString(GL_RENDERER));
            if (rendererString)
                needsWorkaround =
                        qstrncmp(rendererString, "Mali-4xx", 6) == 0 // Mali-400, Mali-450
                        || qstrcmp(rendererString, "Mali-T880") == 0
                        || qstrncmp(rendererString, "Adreno (TM) 2xx", 13) == 0 // Adreno 200, 203, 205
                        || qstrncmp(rendererString, "Adreno 2xx", 8) == 0 // Same as above but without the '(TM)'
                        || qstrncmp(rendererString, "Adreno (TM) 3xx", 13) == 0 // Adreno 302, 305, 320, 330
                        || qstrncmp(rendererString, "Adreno 3xx", 8) == 0 // Same as above but without the '(TM)'
                        || qstrncmp(rendererString, "Adreno (TM) 4xx", 13) == 0 // Adreno 405, 418, 420, 430
                        || qstrncmp(rendererString, "Adreno 4xx", 8) == 0 // Same as above but without the '(TM)'
                        || qstrncmp(rendererString, "Adreno (TM) 5xx", 13) == 0 // Adreno 505, 506, 510, 530, 540
                        || qstrncmp(rendererString, "Adreno 5xx", 8) == 0 // Same as above but without the '(TM)'
                        || qstrncmp(rendererString, "Adreno (TM) 6xx", 13) == 0 // Adreno 610, 620, 630
                        || qstrncmp(rendererString, "Adreno 6xx", 8) == 0 // Same as above but without the '(TM)'
                        || qstrcmp(rendererString, "GC800 core") == 0
                        || qstrcmp(rendererString, "GC1000 core") == 0
                        || strstr(rendererString, "GC2000") != nullptr
                        || qstrcmp(rendererString, "Immersion.16") == 0
                        || qstrncmp(rendererString, "Apple Mx", 7) == 0;
        }
        needsWorkaroundSet = true;
    }
 
    if (needsWorkaround)
        d->workaround_brokenFBOReadBack = true;
 
    d->shareGroup->d_func()->deletePendingResources(this);
 
    return true;
}
 
void QOpenGLContext::doneCurrent()
{
    Q_D(QOpenGLContext);
    if (!isValid())
        return;
 
    if (QOpenGLContext::currentContext() == this)
        d->shareGroup->d_func()->deletePendingResources(this);
 
    d->platformGLContext->doneCurrent();
    QOpenGLContextPrivate::setCurrentContext(nullptr);
 
    d->surface = nullptr;
}
 
QSurface *QOpenGLContext::surface() const
{
    Q_D(const QOpenGLContext);
    return d->surface;
}
 
 
void QOpenGLContext::swapBuffers(QSurface *surface)
{
    Q_D(QOpenGLContext);
    if (!isValid())
        return;
 
    if (!surface) {
        qWarning("QOpenGLContext::swapBuffers() called with null argument");
        return;
    }
 
    if (!surface->supportsOpenGL()) {
        qWarning("QOpenGLContext::swapBuffers() called with non-opengl surface");
        return;
    }
 
    QPlatformSurface *surfaceHandle = surface->surfaceHandle();
    if (!surfaceHandle)
        return;
 
#if !defined(QT_NO_DEBUG)
    if (!QOpenGLContextPrivate::toggleMakeCurrentTracker(this, false))
        qWarning("QOpenGLContext::swapBuffers() called without corresponding makeCurrent()");
#endif
    if (surface->format().swapBehavior() == QSurfaceFormat::SingleBuffer)
        functions()->glFlush();
    d->platformGLContext->swapBuffers(surfaceHandle);
}
 
QFunctionPointer QOpenGLContext::getProcAddress(const QByteArray &procName) const
{
    return getProcAddress(procName.constData());
}
 
QFunctionPointer QOpenGLContext::getProcAddress(const char *procName) const
{
    Q_D(const QOpenGLContext);
    if (!d->platformGLContext)
        return nullptr;
    return d->platformGLContext->getProcAddress(procName);
}
 
QSurfaceFormat QOpenGLContext::format() const
{
    Q_D(const QOpenGLContext);
    if (!d->platformGLContext)
        return d->requestedFormat;
    return d->platformGLContext->format();
}
 
QOpenGLContextGroup *QOpenGLContext::shareGroup() const
{
    Q_D(const QOpenGLContext);
    return d->shareGroup;
}
 
QOpenGLContext *QOpenGLContext::shareContext() const
{
    Q_D(const QOpenGLContext);
    return d->shareContext;
}
 
QScreen *QOpenGLContext::screen() const
{
    Q_D(const QOpenGLContext);
    return d->screen;
}
 
QOpenGLContext::OpenGLModuleType QOpenGLContext::openGLModuleType()
{
#if defined(QT_OPENGL_DYNAMIC)
    Q_ASSERT(qGuiApp);
    return QGuiApplicationPrivate::instance()->platformIntegration()->openGLModuleType();
#elif QT_CONFIG(opengles2)
    return LibGLES;
#else
    return LibGL;
#endif
}
 
bool QOpenGLContext::isOpenGLES() const
{
    return format().renderableType() == QSurfaceFormat::OpenGLES;
}
 
bool QOpenGLContext::supportsThreadedOpenGL()
{
    Q_ASSERT(qGuiApp);
    return QGuiApplicationPrivate::instance()->platformIntegration()->hasCapability(QPlatformIntegration::ThreadedOpenGL);
}
 
QOpenGLContext *QOpenGLContext::globalShareContext()
{
    Q_ASSERT(qGuiApp);
    return qt_gl_global_share_context();
}
 
QOpenGLTextureHelper* QOpenGLContext::textureFunctions() const
{
    Q_D(const QOpenGLContext);
    return d->textureFunctions;
}
 
void QOpenGLContext::setTextureFunctions(QOpenGLTextureHelper* textureFuncs, std::function<void()> destroyCallback)
{
    Q_D(QOpenGLContext);
    d->textureFunctions = textureFuncs;
    d->textureFunctionsDestroyCallback = destroyCallback;
}
 
QOpenGLContextGroup::QOpenGLContextGroup()
    : QObject(*new QOpenGLContextGroupPrivate())
{
}
 
QOpenGLContextGroup::~QOpenGLContextGroup()
{
    Q_D(QOpenGLContextGroup);
    d->cleanup();
}
 
QList<QOpenGLContext *> QOpenGLContextGroup::shares() const
{
    Q_D(const QOpenGLContextGroup);
    return d->m_shares;
}
 
QOpenGLContextGroup *QOpenGLContextGroup::currentContextGroup()
{
    QOpenGLContext *current = QOpenGLContext::currentContext();
    return current ? current->shareGroup() : nullptr;
}
 
QOpenGLContextGroupPrivate::~QOpenGLContextGroupPrivate()
    = default;
 
void QOpenGLContextGroupPrivate::addContext(QOpenGLContext *ctx)
{
    const auto locker = qt_scoped_lock(m_mutex);
    m_refs.ref();
    m_shares << ctx;
}
 
void QOpenGLContextGroupPrivate::removeContext(QOpenGLContext *ctx)
{
    Q_Q(QOpenGLContextGroup);
 
    bool deleteObject = false;
 
    {
        const auto locker = qt_scoped_lock(m_mutex);
        m_shares.removeOne(ctx);
 
        if (ctx == m_context && !m_shares.isEmpty())
            m_context = m_shares.constFirst();
 
        if (!m_refs.deref()) {
            cleanup();
            deleteObject = true;
        }
    }
 
    if (deleteObject) {
        if (q->thread() == QThread::currentThread())
            delete q; // Delete directly to prevent leak, refer to QTBUG-29056
        else
            q->deleteLater();
    }
}
 
void QOpenGLContextGroupPrivate::cleanup()
{
    Q_Q(QOpenGLContextGroup);
    {
        QHash<QOpenGLMultiGroupSharedResource *, QOpenGLSharedResource *>::const_iterator it, end;
        end = m_resources.constEnd();
        for (it = m_resources.constBegin(); it != end; ++it)
            it.key()->cleanup(q, it.value());
        m_resources.clear();
    }
 
    QList<QOpenGLSharedResource *>::iterator it = m_sharedResources.begin();
    QList<QOpenGLSharedResource *>::iterator end = m_sharedResources.end();
 
    while (it != end) {
        (*it)->invalidateResource();
        (*it)->m_group = nullptr;
        ++it;
    }
 
    m_sharedResources.clear();
 
    qDeleteAll(m_pendingDeletion.begin(), m_pendingDeletion.end());
    m_pendingDeletion.clear();
}
 
void QOpenGLContextGroupPrivate::deletePendingResources(QOpenGLContext *ctx)
{
    const auto locker = qt_scoped_lock(m_mutex);
 
    const QList<QOpenGLSharedResource *> pending = m_pendingDeletion;
    m_pendingDeletion.clear();
 
    QList<QOpenGLSharedResource *>::const_iterator it = pending.begin();
    QList<QOpenGLSharedResource *>::const_iterator end = pending.end();
    while (it != end) {
        (*it)->freeResource(ctx);
        delete *it;
        ++it;
    }
}
 
QOpenGLSharedResource::QOpenGLSharedResource(QOpenGLContextGroup *group)
    : m_group(group)
{
    const auto locker = qt_scoped_lock(m_group->d_func()->m_mutex);
    m_group->d_func()->m_sharedResources << this;
}
 
QOpenGLSharedResource::~QOpenGLSharedResource()
{
}
 
// schedule the resource for deletion at an appropriate time
void QOpenGLSharedResource::free()
{
    if (!m_group) {
        delete this;
        return;
    }
 
    const auto locker = qt_scoped_lock(m_group->d_func()->m_mutex);
    m_group->d_func()->m_sharedResources.removeOne(this);
    m_group->d_func()->m_pendingDeletion << this;
 
    // can we delete right away?
    QOpenGLContext *current = QOpenGLContext::currentContext();
    if (current && current->shareGroup() == m_group) {
        m_group->d_func()->deletePendingResources(current);
    }
}
 
QOpenGLSharedResourceGuard::~QOpenGLSharedResourceGuard()
    = default;
 
void QOpenGLSharedResourceGuard::freeResource(QOpenGLContext *context)
{
    if (m_id) {
        QOpenGLFunctions functions(context);
        m_func(&functions, m_id);
        m_id = 0;
    }
}
 
QOpenGLMultiGroupSharedResource::QOpenGLMultiGroupSharedResource()
    : active(0)
{
#ifdef QT_GL_CONTEXT_RESOURCE_DEBUG
    qDebug("Creating context group resource object %p.", this);
#endif
}
 
QOpenGLMultiGroupSharedResource::~QOpenGLMultiGroupSharedResource()
{
#ifdef QT_GL_CONTEXT_RESOURCE_DEBUG
    qDebug("Deleting context group resource %p. Group size: %d.", this, m_groups.size());
#endif
    for (int i = 0; i < m_groups.size(); ++i) {
        if (!m_groups.at(i)->shares().isEmpty()) {
            QOpenGLContext *context = m_groups.at(i)->shares().constFirst();
            QOpenGLSharedResource *resource = value(context);
            if (resource)
                resource->free();
        }
        m_groups.at(i)->d_func()->m_resources.remove(this);
        active.deref();
    }
#ifndef QT_NO_DEBUG
    if (active.loadRelaxed() != 0) {
        qWarning("QtGui: Resources are still available at program shutdown.\n"
                 "          This is possibly caused by a leaked QOpenGLWidget, \n"
                 "          QOpenGLFramebufferObject or QOpenGLPixelBuffer.");
    }
#endif
}
 
void QOpenGLMultiGroupSharedResource::insert(QOpenGLContext *context, QOpenGLSharedResource *value)
{
#ifdef QT_GL_CONTEXT_RESOURCE_DEBUG
    qDebug("Inserting context group resource %p for context %p, managed by %p.", value, context, this);
#endif
    QOpenGLContextGroup *group = context->shareGroup();
    Q_ASSERT(!group->d_func()->m_resources.contains(this));
    group->d_func()->m_resources.insert(this, value);
    m_groups.append(group);
    active.ref();
}
 
QOpenGLSharedResource *QOpenGLMultiGroupSharedResource::value(QOpenGLContext *context)
{
    QOpenGLContextGroup *group = context->shareGroup();
    return group->d_func()->m_resources.value(this, nullptr);
}
 
QList<QOpenGLSharedResource *> QOpenGLMultiGroupSharedResource::resources() const
{
    QList<QOpenGLSharedResource *> result;
    for (QList<QOpenGLContextGroup *>::const_iterator it = m_groups.constBegin(); it != m_groups.constEnd(); ++it) {
        QOpenGLSharedResource *resource = (*it)->d_func()->m_resources.value(const_cast<QOpenGLMultiGroupSharedResource *>(this), nullptr);
        if (resource)
            result << resource;
    }
    return result;
}
 
void QOpenGLMultiGroupSharedResource::cleanup(QOpenGLContextGroup *group, QOpenGLSharedResource *value)
{
#ifdef QT_GL_CONTEXT_RESOURCE_DEBUG
    qDebug("Cleaning up context group resource %p, for group %p in thread %p.", this, group, QThread::currentThread());
#endif
    value->invalidateResource();
    value->free();
    active.deref();
 
    Q_ASSERT(m_groups.contains(group));
    m_groups.removeOne(group);
}
 
QOpenGLContextVersionFunctionHelper::~QOpenGLContextVersionFunctionHelper()
    = default;
 
#ifndef QT_NO_DEBUG_STREAM
QDebug operator<<(QDebug debug, const QOpenGLContext *ctx)
{
    QDebugStateSaver saver(debug);
    debug.nospace();
    debug.noquote();
    debug << "QOpenGLContext(";
    if (ctx)  {
        debug << static_cast<const void *>(ctx);
        if (ctx->isValid()) {
            debug << ", format=" << ctx->format();
            if (const QSurface *sf = ctx->surface())
                debug << ", surface=" << sf;
            if (const QScreen *s = ctx->screen())
                debug << ", screen=\"" << s->name() << '"';
        } else {
            debug << ", invalid";
        }
    } else {
        debug << '0';
    }
    debug << ')';
    return debug;
}
 
QDebug operator<<(QDebug debug, const QOpenGLContextGroup *cg)
{
    QDebugStateSaver saver(debug);
    debug.nospace();
    debug << "QOpenGLContextGroup(";
    if (cg)
        debug << cg->shares();
    else
        debug << '0';
    debug << ')';
    return debug;
}
#endif // QT_NO_DEBUG_STREAM
 
using namespace QNativeInterface;
 
void *QOpenGLContext::resolveInterface(const char *name, int revision) const
{
    Q_UNUSED(name); Q_UNUSED(revision);
 
    auto *platformContext = handle();
    Q_UNUSED(platformContext);
 
#if defined(Q_OS_MACOS)
    QT_NATIVE_INTERFACE_RETURN_IF(QCocoaGLContext, platformContext);
#endif
#if defined(Q_OS_WIN)
    QT_NATIVE_INTERFACE_RETURN_IF(QWGLContext, platformContext);
#endif
#if QT_CONFIG(xcb_glx_plugin)
    QT_NATIVE_INTERFACE_RETURN_IF(QGLXContext, platformContext);
#endif
#if QT_CONFIG(egl)
    QT_NATIVE_INTERFACE_RETURN_IF(QEGLContext, platformContext);
#endif
 
    return nullptr;
}
 
QT_END_NAMESPACE
 
#include "moc_qopenglcontext.cpp"