qopenglwidget.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 "qopenglwidget.h"
#include <QtGui/QOpenGLContext>
#include <QtGui/QOffscreenSurface>
#include <QtGui/QOpenGLFunctions>
#include <QtGui/QWindow>
#include <QtGui/QGuiApplication>
#include <QtGui/QScreen>
#include <QtGui/qpa/qplatformwindow.h>
#include <QtGui/qpa/qplatformintegration.h>
#include <QtOpenGL/QOpenGLFramebufferObject>
#include <QtOpenGL/QOpenGLPaintDevice>
 
#include <QtGui/private/qguiapplication_p.h>
#include <QtGui/private/qopenglextensions_p.h>
#include <QtGui/private/qfont_p.h>
#include <QtGui/private/qopenglcontext_p.h>
#include <QtOpenGL/private/qopenglframebufferobject_p.h>
#include <QtOpenGL/private/qopenglpaintdevice_p.h>
 
#include <QtWidgets/private/qwidget_p.h>
#include <QtWidgets/private/qwidgetrepaintmanager_p.h>
 
#include <rhi/qrhi.h>
 
QT_BEGIN_NAMESPACE
 
class QOpenGLWidgetPaintDevicePrivate : public QOpenGLPaintDevicePrivate
{
public:
    explicit QOpenGLWidgetPaintDevicePrivate(QOpenGLWidget *widget)
        : QOpenGLPaintDevicePrivate(QSize()),
          w(widget) { }
 
    void beginPaint() override;
    void endPaint() override;
 
    QOpenGLWidget *w;
};
 
class QOpenGLWidgetPaintDevice : public QOpenGLPaintDevice
{
public:
    explicit QOpenGLWidgetPaintDevice(QOpenGLWidget *widget)
        : QOpenGLPaintDevice(*new QOpenGLWidgetPaintDevicePrivate(widget)) { }
    void ensureActiveTarget() override;
};
 
class QOpenGLWidgetPrivate : public QWidgetPrivate
{
    Q_DECLARE_PUBLIC(QOpenGLWidget)
public:
    QOpenGLWidgetPrivate() = default;
 
    void reset();
    void resetRhiDependentResources();
    void recreateFbos();
    void ensureRhiDependentResources();
 
    QWidgetPrivate::TextureData texture() const override;
    QPlatformTextureList::Flags textureListFlags() override;
 
    QPlatformBackingStoreRhiConfig rhiConfig() const override { return { QPlatformBackingStoreRhiConfig::OpenGL }; }
 
    void initialize();
    void render();
 
    void invalidateFbo();
 
    void destroyFbos();
 
    bool setCurrentTargetBuffer(QOpenGLWidget::TargetBuffer targetBuffer);
    QImage grabFramebuffer(QOpenGLWidget::TargetBuffer targetBuffer);
    QImage grabFramebuffer() override;
    void beginBackingStorePainting() override { inBackingStorePaint = true; }
    void endBackingStorePainting() override { inBackingStorePaint = false; }
    void beginCompose() override;
    void endCompose() override;
    void initializeViewportFramebuffer() override;
    bool isStereoEnabled() override;
    bool toggleStereoTargetBuffer() override;
    void resizeViewportFramebuffer() override;
    void resolveSamples() override;
 
    void resolveSamplesForBuffer(QOpenGLWidget::TargetBuffer targetBuffer);
 
    QOpenGLContext *context = nullptr;
    QRhiTexture *wrapperTextures[2] = {};
    QOpenGLFramebufferObject *fbos[2] = {};
    QOpenGLFramebufferObject *resolvedFbos[2] = {};
    QOffscreenSurface *surface = nullptr;
    QOpenGLPaintDevice *paintDevice = nullptr;
    int requestedSamples = 0;
    GLenum textureFormat = 0;
    QSurfaceFormat requestedFormat = QSurfaceFormat::defaultFormat();
    QOpenGLWidget::UpdateBehavior updateBehavior = QOpenGLWidget::NoPartialUpdate;
    bool initialized = false;
    bool fakeHidden = false;
    bool inBackingStorePaint = false;
    bool hasBeenComposed = false;
    bool flushPending = false;
    bool inPaintGL = false;
    QOpenGLWidget::TargetBuffer currentTargetBuffer = QOpenGLWidget::LeftBuffer;
};
 
void QOpenGLWidgetPaintDevicePrivate::beginPaint()
{
    // NB! autoFillBackground is and must be false by default. Otherwise we would clear on
    // every QPainter begin() which is not desirable. This is only for legacy use cases,
    // like using QOpenGLWidget as the viewport of a graphics view, that expect clearing
    // with the palette's background color.
    if (w->autoFillBackground()) {
        QOpenGLFunctions *f = QOpenGLContext::currentContext()->functions();
        if (w->format().hasAlpha()) {
            f->glClearColor(0, 0, 0, 0);
        } else {
            QColor c = w->palette().brush(w->backgroundRole()).color();
            float alpha = c.alphaF();
            f->glClearColor(c.redF() * alpha, c.greenF() * alpha, c.blueF() * alpha, alpha);
        }
        f->glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
    }
}
 
void QOpenGLWidgetPaintDevicePrivate::endPaint()
{
    QOpenGLWidgetPrivate *wd = static_cast<QOpenGLWidgetPrivate *>(QWidgetPrivate::get(w));
    if (!wd->initialized)
        return;
 
    if (!wd->inPaintGL)
        QOpenGLContextPrivate::get(wd->context)->defaultFboRedirect = 0;
}
 
void QOpenGLWidgetPaintDevice::ensureActiveTarget()
{
    QOpenGLWidgetPaintDevicePrivate *d = static_cast<QOpenGLWidgetPaintDevicePrivate *>(d_ptr.data());
    QOpenGLWidgetPrivate *wd = static_cast<QOpenGLWidgetPrivate *>(QWidgetPrivate::get(d->w));
    if (!wd->initialized)
        return;
 
    if (QOpenGLContext::currentContext() != wd->context)
        d->w->makeCurrent();
    else
        wd->fbos[wd->currentTargetBuffer]->bind();
 
 
    if (!wd->inPaintGL)
        QOpenGLContextPrivate::get(wd->context)->defaultFboRedirect = wd->fbos[wd->currentTargetBuffer]->handle();
 
    // When used as a viewport, drawing is done via opening a QPainter on the widget
    // without going through paintEvent(). We will have to make sure a glFlush() is done
    // before the texture is accessed also in this case.
    wd->flushPending = true;
}
 
QWidgetPrivate::TextureData QOpenGLWidgetPrivate::texture() const
{
    return { wrapperTextures[QOpenGLWidget::LeftBuffer], wrapperTextures[QOpenGLWidget::RightBuffer] };
}
 
#ifndef GL_SRGB
#define GL_SRGB 0x8C40
#endif
#ifndef GL_SRGB8
#define GL_SRGB8 0x8C41
#endif
#ifndef GL_SRGB_ALPHA
#define GL_SRGB_ALPHA 0x8C42
#endif
#ifndef GL_SRGB8_ALPHA8
#define GL_SRGB8_ALPHA8 0x8C43
#endif
 
QPlatformTextureList::Flags QOpenGLWidgetPrivate::textureListFlags()
{
    QPlatformTextureList::Flags flags = QWidgetPrivate::textureListFlags();
    switch (textureFormat) {
    case GL_SRGB:
    case GL_SRGB8:
    case GL_SRGB_ALPHA:
    case GL_SRGB8_ALPHA8:
        flags |= QPlatformTextureList::TextureIsSrgb;
        break;
    default:
        break;
    }
    return flags;
}
 
void QOpenGLWidgetPrivate::reset()
{
    Q_Q(QOpenGLWidget);
 
    // Destroy the OpenGL resources first. These need the context to be current.
    if (initialized)
        q->makeCurrent();
 
    delete paintDevice;
    paintDevice = nullptr;
 
    destroyFbos();
 
    if (initialized)
        q->doneCurrent();
 
    // Delete the context first, then the surface. Slots connected to
    // the context's aboutToBeDestroyed() may still call makeCurrent()
    // to perform some cleanup.
    delete context;
    context = nullptr;
    delete surface;
    surface = nullptr;
    initialized = fakeHidden = inBackingStorePaint = false;
}
 
void QOpenGLWidgetPrivate::resetRhiDependentResources()
{
    // QRhi resource created from the QRhi. These must be released whenever the
    // widget gets associated with a different QRhi, even when all OpenGL
    // contexts share resources.
 
    delete wrapperTextures[0];
    wrapperTextures[0] = nullptr;
 
    if (isStereoEnabled()) {
        delete wrapperTextures[1];
        wrapperTextures[1] = nullptr;
    }
}
 
void QOpenGLWidgetPrivate::recreateFbos()
{
    Q_Q(QOpenGLWidget);
 
    emit q->aboutToResize();
 
    context->makeCurrent(surface);
 
    destroyFbos();
 
    int samples = requestedSamples;
    QOpenGLExtensions *extfuncs = static_cast<QOpenGLExtensions *>(context->functions());
    if (!extfuncs->hasOpenGLExtension(QOpenGLExtensions::FramebufferMultisample))
        samples = 0;
 
    QOpenGLFramebufferObjectFormat format;
    format.setAttachment(QOpenGLFramebufferObject::CombinedDepthStencil);
    format.setSamples(samples);
    if (textureFormat)
        format.setInternalTextureFormat(textureFormat);
 
    const QSize deviceSize = q->size() * q->devicePixelRatio();
    fbos[QOpenGLWidget::LeftBuffer] = new QOpenGLFramebufferObject(deviceSize, format);
    if (samples > 0)
        resolvedFbos[QOpenGLWidget::LeftBuffer] = new QOpenGLFramebufferObject(deviceSize);
 
    const bool stereo = isStereoEnabled();
 
    if (stereo) {
        fbos[QOpenGLWidget::RightBuffer] = new QOpenGLFramebufferObject(deviceSize, format);
        if (samples > 0)
            resolvedFbos[QOpenGLWidget::RightBuffer] = new QOpenGLFramebufferObject(deviceSize);
    }
 
    textureFormat = fbos[QOpenGLWidget::LeftBuffer]->format().internalTextureFormat();
 
    currentTargetBuffer = QOpenGLWidget::LeftBuffer;
    fbos[currentTargetBuffer]->bind();
    context->functions()->glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
    ensureRhiDependentResources();
 
    if (stereo) {
        currentTargetBuffer = QOpenGLWidget::RightBuffer;
        fbos[currentTargetBuffer]->bind();
        context->functions()->glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
        ensureRhiDependentResources();
        currentTargetBuffer = QOpenGLWidget::LeftBuffer;
    }
 
    flushPending = true; // Make sure the FBO is initialized before use
 
    paintDevice->setSize(deviceSize);
    paintDevice->setDevicePixelRatio(q->devicePixelRatio());
 
    emit q->resized();
}
 
void QOpenGLWidgetPrivate::ensureRhiDependentResources()
{
    Q_Q(QOpenGLWidget);
 
    QRhi *rhi = nullptr;
    if (QWidgetRepaintManager *repaintManager = QWidgetPrivate::get(q->window())->maybeRepaintManager())
        rhi = repaintManager->rhi();
 
    // If there is no rhi, because we are completely offscreen, then there's no wrapperTexture either
    if (rhi && rhi->backend() == QRhi::OpenGLES2) {
        const QSize deviceSize = q->size() * q->devicePixelRatio();
        if (!wrapperTextures[currentTargetBuffer] || wrapperTextures[currentTargetBuffer]->pixelSize() != deviceSize) {
            const uint textureId = resolvedFbos[currentTargetBuffer] ?
                        resolvedFbos[currentTargetBuffer]->texture()
                      : (fbos[currentTargetBuffer] ? fbos[currentTargetBuffer]->texture() : 0);
            if (!wrapperTextures[currentTargetBuffer])
                wrapperTextures[currentTargetBuffer] = rhi->newTexture(QRhiTexture::RGBA8, deviceSize, 1, QRhiTexture::RenderTarget);
            else
                wrapperTextures[currentTargetBuffer]->setPixelSize(deviceSize);
            if (!wrapperTextures[currentTargetBuffer]->createFrom({textureId, 0 }))
                qWarning("QOpenGLWidget: Failed to create wrapper texture");
        }
    }
}
 
void QOpenGLWidgetPrivate::beginCompose()
{
    Q_Q(QOpenGLWidget);
    if (flushPending) {
        flushPending = false;
        q->makeCurrent();
        static_cast<QOpenGLExtensions *>(context->functions())->flushShared();
    }
    hasBeenComposed = true;
    emit q->aboutToCompose();
}
 
void QOpenGLWidgetPrivate::endCompose()
{
    Q_Q(QOpenGLWidget);
    emit q->frameSwapped();
}
 
void QOpenGLWidgetPrivate::initialize()
{
    Q_Q(QOpenGLWidget);
    if (initialized)
        return;
 
    // If no global shared context get our toplevel's context with which we
    // will share in order to make the texture usable by the underlying window's backingstore.
    QWidget *tlw = q->window();
    QWidgetPrivate *tlwd = get(tlw);
 
    // Do not include the sample count. Requesting a multisampled context is not necessary
    // since we render into an FBO, never to an actual surface. What's more, attempting to
    // create a pbuffer with a multisampled config crashes certain implementations. Just
    // avoid the entire hassle, the result is the same.
    requestedSamples = requestedFormat.samples();
    requestedFormat.setSamples(0);
 
    QRhi *rhi = nullptr;
    if (QWidgetRepaintManager *repaintManager = tlwd->maybeRepaintManager())
        rhi = repaintManager->rhi();
 
    // Could be that something else already initialized the window with some
    // other graphics API for the QRhi, that's not good.
    if (rhi && rhi->backend() != QRhi::OpenGLES2) {
        qWarning("The top-level window is not using OpenGL for composition, '%s' is not compatible with QOpenGLWidget",
                 rhi->backendName());
        return;
    }
 
    // If rhi or contextFromRhi is null, showing content on-screen will not work.
    // However, offscreen rendering and grabFramebuffer() will stay fully functional.
 
    QOpenGLContext *contextFromRhi = rhi ? static_cast<const QRhiGles2NativeHandles *>(rhi->nativeHandles())->context : nullptr;
 
    context = new QOpenGLContext;
    context->setFormat(requestedFormat);
    if (contextFromRhi) {
        context->setShareContext(contextFromRhi);
        context->setScreen(contextFromRhi->screen());
    }
    if (Q_UNLIKELY(!context->create())) {
        qWarning("QOpenGLWidget: Failed to create context");
        return;
    }
 
    surface = new QOffscreenSurface;
    surface->setFormat(context->format());
    surface->setScreen(context->screen());
    surface->create();
 
    if (Q_UNLIKELY(!context->makeCurrent(surface))) {
        qWarning("QOpenGLWidget: Failed to make context current");
        return;
    }
 
    // Propagate settings that make sense only for the tlw. Note that this only
    // makes sense for properties that get picked up even after the native
    // window is created.
    if (tlw->windowHandle()) {
        QSurfaceFormat tlwFormat = tlw->windowHandle()->format();
        if (requestedFormat.swapInterval() != tlwFormat.swapInterval()) {
            // Most platforms will pick up the changed swap interval on the next
            // makeCurrent or swapBuffers.
            tlwFormat.setSwapInterval(requestedFormat.swapInterval());
            tlw->windowHandle()->setFormat(tlwFormat);
        }
        if (requestedFormat.swapBehavior() != tlwFormat.swapBehavior()) {
            tlwFormat.setSwapBehavior(requestedFormat.swapBehavior());
            tlw->windowHandle()->setFormat(tlwFormat);
        }
    }
 
    paintDevice = new QOpenGLWidgetPaintDevice(q);
    paintDevice->setSize(q->size() * q->devicePixelRatio());
    paintDevice->setDevicePixelRatio(q->devicePixelRatio());
 
    initialized = true;
 
    q->initializeGL();
}
 
void QOpenGLWidgetPrivate::resolveSamples()
{
    resolveSamplesForBuffer(QOpenGLWidget::LeftBuffer);
    resolveSamplesForBuffer(QOpenGLWidget::RightBuffer);
}
 
void QOpenGLWidgetPrivate::resolveSamplesForBuffer(QOpenGLWidget::TargetBuffer targetBuffer)
{
    Q_Q(QOpenGLWidget);
    if (resolvedFbos[targetBuffer]) {
        q->makeCurrent(targetBuffer);
        QRect rect(QPoint(0, 0), fbos[targetBuffer]->size());
        QOpenGLFramebufferObject::blitFramebuffer(resolvedFbos[targetBuffer], rect, fbos[targetBuffer], rect);
        flushPending = true;
    }
}
 
void QOpenGLWidgetPrivate::render()
{
    Q_Q(QOpenGLWidget);
 
    if (fakeHidden || !initialized)
        return;
 
    setCurrentTargetBuffer(QOpenGLWidget::LeftBuffer);
 
    QOpenGLContext *ctx = QOpenGLContext::currentContext();
    if (!ctx) {
        qWarning("QOpenGLWidget: No current context, cannot render");
        return;
    }
 
    if (!fbos[QOpenGLWidget::LeftBuffer]) {
        qWarning("QOpenGLWidget: No fbo, cannot render");
        return;
    }
 
    const bool stereo = isStereoEnabled();
    if (stereo) {
        static bool warningGiven = false;
        if (!fbos[QOpenGLWidget::RightBuffer] && !warningGiven) {
            qWarning("QOpenGLWidget: Stereo is enabled, but no right buffer. Using only left buffer");
            warningGiven = true;
        }
    }
 
    if (updateBehavior == QOpenGLWidget::NoPartialUpdate && hasBeenComposed) {
        invalidateFbo();
 
        if (stereo && fbos[QOpenGLWidget::RightBuffer]) {
            setCurrentTargetBuffer(QOpenGLWidget::RightBuffer);
            invalidateFbo();
            setCurrentTargetBuffer(QOpenGLWidget::LeftBuffer);
        }
 
        hasBeenComposed = false;
    }
 
    QOpenGLFunctions *f = ctx->functions();
    f->glViewport(0, 0, q->width() * q->devicePixelRatio(), q->height() * q->devicePixelRatio());
    inPaintGL = true;
 
#ifdef Q_OS_WASM
    f->glDepthMask(GL_TRUE);
#endif
 
    QOpenGLContextPrivate::get(ctx)->defaultFboRedirect = fbos[currentTargetBuffer]->handle();
    q->paintGL();
 
    if (stereo && fbos[QOpenGLWidget::RightBuffer]) {
        setCurrentTargetBuffer(QOpenGLWidget::RightBuffer);
        QOpenGLContextPrivate::get(ctx)->defaultFboRedirect = fbos[currentTargetBuffer]->handle();
        q->paintGL();
    }
    QOpenGLContextPrivate::get(ctx)->defaultFboRedirect = 0;
 
    inPaintGL = false;
    flushPending = true;
}
 
void QOpenGLWidgetPrivate::invalidateFbo()
{
    QOpenGLExtensions *f = static_cast<QOpenGLExtensions *>(QOpenGLContext::currentContext()->functions());
    if (f->hasOpenGLExtension(QOpenGLExtensions::DiscardFramebuffer)) {
        const int gl_color_attachment0 = 0x8CE0;  // GL_COLOR_ATTACHMENT0
        const int gl_depth_attachment = 0x8D00;   // GL_DEPTH_ATTACHMENT
        const int gl_stencil_attachment = 0x8D20; // GL_STENCIL_ATTACHMENT
#ifdef Q_OS_WASM
        // webgl does not allow separate depth and stencil attachments
        // QTBUG-69913
        const int gl_depth_stencil_attachment = 0x821A; // GL_DEPTH_STENCIL_ATTACHMENT
 
        const GLenum attachments[] = {
            gl_color_attachment0, gl_depth_attachment, gl_stencil_attachment, gl_depth_stencil_attachment
        };
#else
        const GLenum attachments[] = {
            gl_color_attachment0, gl_depth_attachment, gl_stencil_attachment
        };
#endif
        f->glDiscardFramebufferEXT(GL_FRAMEBUFFER, sizeof attachments / sizeof *attachments, attachments);
    } else {
        f->glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
    }
}
 
void QOpenGLWidgetPrivate::destroyFbos()
{
    delete fbos[QOpenGLWidget::LeftBuffer];
    fbos[QOpenGLWidget::LeftBuffer] = nullptr;
    delete resolvedFbos[QOpenGLWidget::LeftBuffer];
    resolvedFbos[QOpenGLWidget::LeftBuffer] = nullptr;
 
    delete fbos[QOpenGLWidget::RightBuffer];
    fbos[QOpenGLWidget::RightBuffer] = nullptr;
    delete resolvedFbos[QOpenGLWidget::RightBuffer];
    resolvedFbos[QOpenGLWidget::RightBuffer] = nullptr;
 
    resetRhiDependentResources();
}
 
QImage QOpenGLWidgetPrivate::grabFramebuffer()
{
    return grabFramebuffer(QOpenGLWidget::LeftBuffer);
}
 
QImage QOpenGLWidgetPrivate::grabFramebuffer(QOpenGLWidget::TargetBuffer targetBuffer)
{
    Q_Q(QOpenGLWidget);
 
    initialize();
    if (!initialized)
        return QImage();
 
    // The second fbo is only created when stereoscopic rendering is enabled
    // Just use the default one if not.
    if (targetBuffer == QOpenGLWidget::RightBuffer && !isStereoEnabled())
        targetBuffer = QOpenGLWidget::LeftBuffer;
 
    if (!fbos[targetBuffer]) // could be completely offscreen, without ever getting a resize event
        recreateFbos();
 
    if (!inPaintGL)
        render();
 
    setCurrentTargetBuffer(targetBuffer);
    if (resolvedFbos[targetBuffer]) {
        resolveSamplesForBuffer(targetBuffer);
        resolvedFbos[targetBuffer]->bind();
    }
 
    const bool hasAlpha = q->format().hasAlpha();
    QImage res = qt_gl_read_framebuffer(q->size() * q->devicePixelRatio(), hasAlpha, hasAlpha);
    res.setDevicePixelRatio(q->devicePixelRatio());
 
    // While we give no guarantees of what is going to be left bound, prefer the
    // multisample fbo instead of the resolved one. Clients may continue to
    // render straight after calling this function.
    if (resolvedFbos[targetBuffer]) {
        setCurrentTargetBuffer(targetBuffer);
    }
 
    return res;
}
 
void QOpenGLWidgetPrivate::initializeViewportFramebuffer()
{
    Q_Q(QOpenGLWidget);
    // Legacy behavior for compatibility with QGLWidget when used as a graphics view
    // viewport: enable clearing on each painter begin.
    q->setAutoFillBackground(true);
}
 
bool QOpenGLWidgetPrivate::isStereoEnabled()
{
    Q_Q(QOpenGLWidget);
    // Note that because this internally might use the requested format,
    // then this can return a false positive on hardware where
    // steroscopic rendering is not supported.
    return q->format().stereo();
}
 
bool QOpenGLWidgetPrivate::toggleStereoTargetBuffer()
{
    return setCurrentTargetBuffer(currentTargetBuffer == QOpenGLWidget::LeftBuffer ?
                               QOpenGLWidget::RightBuffer :
                               QOpenGLWidget::LeftBuffer);
}
 
void QOpenGLWidgetPrivate::resizeViewportFramebuffer()
{
    Q_Q(QOpenGLWidget);
    if (!initialized)
        return;
 
    if (!fbos[currentTargetBuffer] || q->size() * q->devicePixelRatio() != fbos[currentTargetBuffer]->size()) {
        recreateFbos();
        q->update();
    }
}
 
QOpenGLWidget::QOpenGLWidget(QWidget *parent, Qt::WindowFlags f)
    : QWidget(*(new QOpenGLWidgetPrivate), parent, f)
{
    Q_D(QOpenGLWidget);
    if (Q_UNLIKELY(!QGuiApplicationPrivate::platformIntegration()->hasCapability(QPlatformIntegration::RhiBasedRendering)
                   || !QGuiApplicationPrivate::platformIntegration()->hasCapability(QPlatformIntegration::OpenGL)))
        qWarning("QOpenGLWidget is not supported on this platform.");
    else
        d->setRenderToTexture();
}
 
QOpenGLWidget::~QOpenGLWidget()
{
    // NB! resetting graphics resources must be done from this destructor,
    // *not* from the private class' destructor. This is due to how destruction
    // works and due to the QWidget dtor (for toplevels) destroying the repaint
    // manager and rhi before the (QObject) private gets destroyed. Hence must
    // do it here early on.
 
    Q_D(QOpenGLWidget);
    d->reset();
}
 
void QOpenGLWidget::setUpdateBehavior(UpdateBehavior updateBehavior)
{
    Q_D(QOpenGLWidget);
    d->updateBehavior = updateBehavior;
}
 
QOpenGLWidget::UpdateBehavior QOpenGLWidget::updateBehavior() const
{
    Q_D(const QOpenGLWidget);
    return d->updateBehavior;
}
 
void QOpenGLWidget::setFormat(const QSurfaceFormat &format)
{
    Q_D(QOpenGLWidget);
    if (Q_UNLIKELY(d->initialized)) {
        qWarning("QOpenGLWidget: Already initialized, setting the format has no effect");
        return;
    }
 
    d->requestedFormat = format;
}
 
QSurfaceFormat QOpenGLWidget::format() const
{
    Q_D(const QOpenGLWidget);
    return d->initialized ? d->context->format() : d->requestedFormat;
}
 
void QOpenGLWidget::setTextureFormat(GLenum texFormat)
{
    Q_D(QOpenGLWidget);
    if (Q_UNLIKELY(d->initialized)) {
        qWarning("QOpenGLWidget: Already initialized, setting the internal texture format has no effect");
        return;
    }
 
    d->textureFormat = texFormat;
}
 
GLenum QOpenGLWidget::textureFormat() const
{
    Q_D(const QOpenGLWidget);
    return d->textureFormat;
}
 
bool QOpenGLWidget::isValid() const
{
    Q_D(const QOpenGLWidget);
    return d->initialized && d->context->isValid();
}
 
void QOpenGLWidget::makeCurrent()
{
    Q_D(QOpenGLWidget);
    if (!d->initialized)
        return;
 
    d->context->makeCurrent(d->surface);
 
    if (d->fbos[d->currentTargetBuffer]) // there may not be one if we are in reset()
        d->fbos[d->currentTargetBuffer]->bind();
}
 
void QOpenGLWidget::makeCurrent(TargetBuffer targetBuffer)
{
    Q_D(QOpenGLWidget);
    if (!d->initialized)
        return;
 
    // The FBO for the right buffer is only initialized when stereo is set
   if (targetBuffer == TargetBuffer::RightBuffer && !format().stereo())
       return;
 
    d->setCurrentTargetBuffer(targetBuffer); // calls makeCurrent
}
 
void QOpenGLWidget::doneCurrent()
{
    Q_D(QOpenGLWidget);
    if (!d->initialized)
        return;
 
    d->context->doneCurrent();
}
 
QOpenGLContext *QOpenGLWidget::context() const
{
    Q_D(const QOpenGLWidget);
    return d->context;
}
 
GLuint QOpenGLWidget::defaultFramebufferObject() const
{
    Q_D(const QOpenGLWidget);
    return d->fbos[TargetBuffer::LeftBuffer] ? d->fbos[TargetBuffer::LeftBuffer]->handle() : 0;
}
 
GLuint QOpenGLWidget::defaultFramebufferObject(TargetBuffer targetBuffer) const
{
    Q_D(const QOpenGLWidget);
    return d->fbos[targetBuffer] ? d->fbos[targetBuffer]->handle() : 0;
}
 
void QOpenGLWidget::initializeGL()
{
}
 
void QOpenGLWidget::resizeGL(int w, int h)
{
    Q_UNUSED(w);
    Q_UNUSED(h);
}
 
void QOpenGLWidget::paintGL()
{
}
 
void QOpenGLWidget::resizeEvent(QResizeEvent *e)
{
    Q_D(QOpenGLWidget);
 
    if (e->size().isEmpty()) {
        d->fakeHidden = true;
        return;
    }
    d->fakeHidden = false;
 
    d->initialize();
    if (!d->initialized)
        return;
 
    d->recreateFbos();
    // Make sure our own context is current before invoking user overrides. If
    // the fbo was recreated then there's a chance something else is current now.
    makeCurrent();
    resizeGL(width(), height());
    d->sendPaintEvent(QRect(QPoint(0, 0), size()));
}
 
void QOpenGLWidget::paintEvent(QPaintEvent *e)
{
    Q_UNUSED(e);
    Q_D(QOpenGLWidget);
 
    d->initialize();
    if (d->initialized) {
        d->ensureRhiDependentResources();
        if (updatesEnabled())
            d->render();
    }
}
 
QImage QOpenGLWidget::grabFramebuffer()
{
    Q_D(QOpenGLWidget);
    return d->grabFramebuffer();
}
 
QImage QOpenGLWidget::grabFramebuffer(TargetBuffer targetBuffer)
{
    Q_D(QOpenGLWidget);
    return d->grabFramebuffer(targetBuffer);
}
 
QOpenGLWidget::TargetBuffer QOpenGLWidget::currentTargetBuffer() const
{
    Q_D(const QOpenGLWidget);
    return d->currentTargetBuffer;
}
 
int QOpenGLWidget::metric(QPaintDevice::PaintDeviceMetric metric) const
{
    Q_D(const QOpenGLWidget);
    if (d->inBackingStorePaint)
        return QWidget::metric(metric);
 
    auto window = d->windowHandle(QWidgetPrivate::WindowHandleMode::TopLevel);
    QScreen *screen = window ? window->screen() : QGuiApplication::primaryScreen();
 
    const float dpmx = qt_defaultDpiX() * 100. / 2.54;
    const float dpmy = qt_defaultDpiY() * 100. / 2.54;
 
    switch (metric) {
    case PdmWidth:
        return width();
    case PdmHeight:
        return height();
    case PdmDepth:
        return 32;
    case PdmWidthMM:
        if (screen)
            return width() * screen->physicalSize().width() / screen->geometry().width();
        else
            return width() * 1000 / dpmx;
    case PdmHeightMM:
        if (screen)
            return height() * screen->physicalSize().height() / screen->geometry().height();
        else
            return height() * 1000 / dpmy;
    case PdmNumColors:
        return 0;
    case PdmDpiX:
        if (screen)
            return qRound(screen->logicalDotsPerInchX());
        else
            return qRound(dpmx * 0.0254);
    case PdmDpiY:
        if (screen)
            return qRound(screen->logicalDotsPerInchY());
        else
            return qRound(dpmy * 0.0254);
    case PdmPhysicalDpiX:
        if (screen)
            return qRound(screen->physicalDotsPerInchX());
        else
            return qRound(dpmx * 0.0254);
    case PdmPhysicalDpiY:
        if (screen)
            return qRound(screen->physicalDotsPerInchY());
        else
            return qRound(dpmy * 0.0254);
    case PdmDevicePixelRatio:
        return QWidget::metric(metric);
    case PdmDevicePixelRatioScaled:
        return QWidget::metric(metric);
    default:
        qWarning("QOpenGLWidget::metric(): unknown metric %d", metric);
        return 0;
    }
}
 
QPaintDevice *QOpenGLWidget::redirected(QPoint *p) const
{
    Q_D(const QOpenGLWidget);
    if (d->inBackingStorePaint)
        return QWidget::redirected(p);
 
    return d->paintDevice;
}
 
QPaintEngine *QOpenGLWidget::paintEngine() const
{
    Q_D(const QOpenGLWidget);
    // QWidget needs to "punch a hole" into the backingstore. This needs the
    // normal paint engine and device, not the GL one. So in this mode, behave
    // like a normal widget.
    if (d->inBackingStorePaint)
        return QWidget::paintEngine();
 
    if (!d->initialized)
        return nullptr;
 
    return d->paintDevice->paintEngine();
}
 
 
bool QOpenGLWidgetPrivate::setCurrentTargetBuffer(QOpenGLWidget::TargetBuffer targetBuffer)
{
    Q_Q(QOpenGLWidget);
 
    if (targetBuffer == QOpenGLWidget::RightBuffer && !isStereoEnabled())
        return false;
 
    currentTargetBuffer = targetBuffer;
    q->makeCurrent();
 
    return true;
}
 
bool QOpenGLWidget::event(QEvent *e)
{
    Q_D(QOpenGLWidget);
    switch (e->type()) {
    case QEvent::WindowAboutToChangeInternal:
        d->resetRhiDependentResources();
        break;
    case QEvent::WindowChangeInternal:
        if (QCoreApplication::testAttribute(Qt::AA_ShareOpenGLContexts))
            break;
        if (d->initialized)
            d->reset();
        if (isHidden())
            break;
        Q_FALLTHROUGH();
    case QEvent::Show: // reparenting may not lead to a resize so reinitialize on Show too
        if (d->initialized && !d->wrapperTextures[d->currentTargetBuffer] && window()->windowHandle()) {
            // Special case: did grabFramebuffer() for a hidden widget that then became visible.
            // Recreate all resources since the context now needs to share with the TLW's.
            if (!QCoreApplication::testAttribute(Qt::AA_ShareOpenGLContexts))
                d->reset();
        }
        if (QWidgetRepaintManager *repaintManager = QWidgetPrivate::get(window())->maybeRepaintManager()) {
            if (!d->initialized && !size().isEmpty() && repaintManager->rhi()) {
                d->initialize();
                if (d->initialized) {
                    d->recreateFbos();
                    // QTBUG-89812: generate a paint event, like resize would do,
                    // otherwise a QOpenGLWidget in a QDockWidget may not show the
                    // content upon (un)docking.
                    d->sendPaintEvent(QRect(QPoint(0, 0), size()));
                }
            }
        }
        break;
    case QEvent::DevicePixelRatioChange:
        if (d->initialized && d->paintDevice->devicePixelRatio() != devicePixelRatio())
            d->recreateFbos();
        break;
    default:
        break;
    }
    return QWidget::event(e);
}
 
QT_END_NAMESPACE
 
#include "moc_qopenglwidget.cpp"