qopenglwindow.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 "qopenglwindow.h"
#include <QtGui/QOpenGLFunctions>
#include <QtGui/private/qpaintdevicewindow_p.h>
#include <QtGui/private/qopenglextensions_p.h>
#include <QtGui/private/qopenglcontext_p.h>
#include <QtGui/QMatrix4x4>
#include <QtGui/QOffscreenSurface>
 
#include <QtOpenGL/private/qopenglframebufferobject_p.h>
#include <QtOpenGL/QOpenGLFramebufferObject>
#include <QtOpenGL/QOpenGLTextureBlitter>
#include <QtOpenGL/QOpenGLPaintDevice>
 
QT_BEGIN_NAMESPACE
 
// GLES2 builds won't have these constants with the suffixless names
#ifndef GL_READ_FRAMEBUFFER
#define GL_READ_FRAMEBUFFER 0x8CA8
#endif
#ifndef GL_DRAW_FRAMEBUFFER
#define GL_DRAW_FRAMEBUFFER 0x8CA9
#endif
 
class QOpenGLWindowPaintDevice : public QOpenGLPaintDevice
{
public:
    QOpenGLWindowPaintDevice(QOpenGLWindow *window) : m_window(window) { }
    void ensureActiveTarget() override;
 
    QOpenGLWindow *m_window;
};
 
class QOpenGLWindowPrivate : public QPaintDeviceWindowPrivate
{
    Q_DECLARE_PUBLIC(QOpenGLWindow)
public:
    QOpenGLWindowPrivate(QOpenGLContext *shareContext, QOpenGLWindow::UpdateBehavior updateBehavior)
        : updateBehavior(updateBehavior)
        , hasFboBlit(false)
        , shareContext(shareContext)
    {
        if (!shareContext)
            this->shareContext = qt_gl_global_share_context();
    }
 
    ~QOpenGLWindowPrivate();
 
    static QOpenGLWindowPrivate *get(QOpenGLWindow *w) { return w->d_func(); }
 
    void bindFBO();
    void initialize();
 
    void beginPaint(const QRegion &region) override;
    void endPaint() override;
    void flush(const QRegion &region) override;
 
    QOpenGLWindow::UpdateBehavior updateBehavior;
    bool hasFboBlit;
    QScopedPointer<QOpenGLContext> context;
    QOpenGLContext *shareContext;
    QScopedPointer<QOpenGLFramebufferObject> fbo;
    QScopedPointer<QOpenGLWindowPaintDevice> paintDevice;
    QOpenGLTextureBlitter blitter;
    QColor backgroundColor;
    QScopedPointer<QOffscreenSurface> offscreenSurface;
};
 
QOpenGLWindowPrivate::~QOpenGLWindowPrivate()
{
    Q_Q(QOpenGLWindow);
    if (q->isValid()) {
        q->makeCurrent(); // this works even when the platformwindow is destroyed
        paintDevice.reset(nullptr);
        fbo.reset(nullptr);
        blitter.destroy();
        q->doneCurrent();
    }
}
 
void QOpenGLWindowPrivate::initialize()
{
    Q_Q(QOpenGLWindow);
 
    if (context)
        return;
 
    if (!q->handle())
        qWarning("Attempted to initialize QOpenGLWindow without a platform window");
 
    context.reset(new QOpenGLContext);
    context->setShareContext(shareContext);
    context->setFormat(q->requestedFormat());
    if (!context->create())
        qWarning("QOpenGLWindow::beginPaint: Failed to create context");
    if (!context->makeCurrent(q))
        qWarning("QOpenGLWindow::beginPaint: Failed to make context current");
 
    paintDevice.reset(new QOpenGLWindowPaintDevice(q));
    if (updateBehavior == QOpenGLWindow::PartialUpdateBlit)
        hasFboBlit = QOpenGLFramebufferObject::hasOpenGLFramebufferBlit();
 
    q->initializeGL();
}
 
void QOpenGLWindowPrivate::beginPaint(const QRegion &region)
{
    Q_UNUSED(region);
    Q_Q(QOpenGLWindow);
 
    initialize();
    context->makeCurrent(q);
 
    const int deviceWidth = q->width() * q->devicePixelRatio();
    const int deviceHeight = q->height() * q->devicePixelRatio();
    const QSize deviceSize(deviceWidth, deviceHeight);
    if (updateBehavior > QOpenGLWindow::NoPartialUpdate) {
        if (!fbo || fbo->size() != deviceSize) {
            QOpenGLFramebufferObjectFormat fboFormat;
            fboFormat.setAttachment(QOpenGLFramebufferObject::CombinedDepthStencil);
            const int samples = q->requestedFormat().samples();
            if (samples > 0) {
                if (updateBehavior != QOpenGLWindow::PartialUpdateBlend)
                    fboFormat.setSamples(samples);
                else
                    qWarning("QOpenGLWindow: PartialUpdateBlend does not support multisampling");
            }
            fbo.reset(new QOpenGLFramebufferObject(deviceSize, fboFormat));
            markWindowAsDirty();
        }
    } else {
        markWindowAsDirty();
    }
 
    paintDevice->setSize(QSize(deviceWidth, deviceHeight));
    paintDevice->setDevicePixelRatio(q->devicePixelRatio());
    context->functions()->glViewport(0, 0, deviceWidth, deviceHeight);
 
    context->functions()->glBindFramebuffer(GL_FRAMEBUFFER, context->defaultFramebufferObject());
 
    q->paintUnderGL();
 
    if (updateBehavior > QOpenGLWindow::NoPartialUpdate)
        fbo->bind();
}
 
void QOpenGLWindowPrivate::endPaint()
{
    Q_Q(QOpenGLWindow);
 
    if (updateBehavior > QOpenGLWindow::NoPartialUpdate)
        fbo->release();
 
    context->functions()->glBindFramebuffer(GL_FRAMEBUFFER, context->defaultFramebufferObject());
 
    if (updateBehavior == QOpenGLWindow::PartialUpdateBlit && hasFboBlit) {
        const int deviceWidth = q->width() * q->devicePixelRatio();
        const int deviceHeight = q->height() * q->devicePixelRatio();
        QOpenGLExtensions extensions(context.data());
        extensions.glBindFramebuffer(GL_READ_FRAMEBUFFER, fbo->handle());
        extensions.glBindFramebuffer(GL_DRAW_FRAMEBUFFER, context->defaultFramebufferObject());
        extensions.glBlitFramebuffer(0, 0, deviceWidth, deviceHeight,
                                     0, 0, deviceWidth, deviceHeight,
                                     GL_COLOR_BUFFER_BIT, GL_NEAREST);
    } else if (updateBehavior > QOpenGLWindow::NoPartialUpdate) {
        if (updateBehavior == QOpenGLWindow::PartialUpdateBlend) {
            context->functions()->glEnable(GL_BLEND);
            context->functions()->glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        }
        if (!blitter.isCreated())
            blitter.create();
 
        QRect windowRect(QPoint(0, 0), fbo->size());
        QMatrix4x4 target = QOpenGLTextureBlitter::targetTransform(windowRect, windowRect);
        blitter.bind();
        blitter.blit(fbo->texture(), target, QOpenGLTextureBlitter::OriginBottomLeft);
        blitter.release();
 
        if (updateBehavior == QOpenGLWindow::PartialUpdateBlend)
            context->functions()->glDisable(GL_BLEND);
    }
 
    q->paintOverGL();
}
 
void QOpenGLWindowPrivate::bindFBO()
{
    if (updateBehavior > QOpenGLWindow::NoPartialUpdate)
        fbo->bind();
    else
        QOpenGLFramebufferObject::bindDefault();
}
 
void QOpenGLWindowPrivate::flush(const QRegion &region)
{
    Q_UNUSED(region);
    Q_Q(QOpenGLWindow);
    context->swapBuffers(q);
    emit q->frameSwapped();
}
 
void QOpenGLWindowPaintDevice::ensureActiveTarget()
{
    QOpenGLWindowPrivate::get(m_window)->bindFBO();
}
 
QOpenGLWindow::QOpenGLWindow(QOpenGLWindow::UpdateBehavior updateBehavior, QWindow *parent)
    : QPaintDeviceWindow(*(new QOpenGLWindowPrivate(nullptr, updateBehavior)), parent)
{
    setSurfaceType(QSurface::OpenGLSurface);
}
 
QOpenGLWindow::QOpenGLWindow(QOpenGLContext *shareContext, UpdateBehavior updateBehavior, QWindow *parent)
    : QPaintDeviceWindow(*(new QOpenGLWindowPrivate(shareContext, updateBehavior)), parent)
{
    setSurfaceType(QSurface::OpenGLSurface);
}
 
QOpenGLWindow::~QOpenGLWindow()
{
    makeCurrent();
}
 
QOpenGLWindow::UpdateBehavior QOpenGLWindow::updateBehavior() const
{
    Q_D(const QOpenGLWindow);
    return d->updateBehavior;
}
 
bool QOpenGLWindow::isValid() const
{
    Q_D(const QOpenGLWindow);
    return d->context && d->context->isValid();
}
 
void QOpenGLWindow::makeCurrent()
{
    Q_D(QOpenGLWindow);
 
    if (!isValid())
        return;
 
    // The platform window may be destroyed at this stage and therefore
    // makeCurrent() may not safely be called with 'this'.
    if (handle()) {
        d->context->makeCurrent(this);
    } else {
        if (!d->offscreenSurface) {
            d->offscreenSurface.reset(new QOffscreenSurface(screen()));
            d->offscreenSurface->setFormat(d->context->format());
            d->offscreenSurface->create();
        }
        d->context->makeCurrent(d->offscreenSurface.data());
    }
 
    d->bindFBO();
}
 
void QOpenGLWindow::doneCurrent()
{
    Q_D(QOpenGLWindow);
 
    if (!isValid())
        return;
 
    d->context->doneCurrent();
}
 
QOpenGLContext *QOpenGLWindow::context() const
{
    Q_D(const QOpenGLWindow);
    return d->context.data();
}
 
QOpenGLContext *QOpenGLWindow::shareContext() const
{
    Q_D(const QOpenGLWindow);
    return d->shareContext;
}
 
GLuint QOpenGLWindow::defaultFramebufferObject() const
{
    Q_D(const QOpenGLWindow);
    if (d->updateBehavior > NoPartialUpdate && d->fbo)
        return d->fbo->handle();
    else if (QOpenGLContext *ctx = QOpenGLContext::currentContext())
        return ctx->defaultFramebufferObject();
    else
        return 0;
}
 
QImage QOpenGLWindow::grabFramebuffer()
{
    if (!isValid())
        return QImage();
 
    makeCurrent();
 
    const bool hasAlpha = format().hasAlpha();
    QImage img = qt_gl_read_framebuffer(size() * devicePixelRatio(), hasAlpha, hasAlpha);
    img.setDevicePixelRatio(devicePixelRatio());
    return img;
}
 
void QOpenGLWindow::initializeGL()
{
}
 
void QOpenGLWindow::resizeGL(int w, int h)
{
    Q_UNUSED(w);
    Q_UNUSED(h);
}
 
void QOpenGLWindow::paintGL()
{
}
 
void QOpenGLWindow::paintUnderGL()
{
}
 
void QOpenGLWindow::paintOverGL()
{
}
 
void QOpenGLWindow::paintEvent(QPaintEvent *event)
{
    Q_UNUSED(event);
    paintGL();
}
 
void QOpenGLWindow::resizeEvent(QResizeEvent *event)
{
    Q_UNUSED(event);
    Q_D(QOpenGLWindow);
    d->initialize();
    resizeGL(width(), height());
}
 
int QOpenGLWindow::metric(PaintDeviceMetric metric) const
{
    Q_D(const QOpenGLWindow);
 
    switch (metric) {
        case PdmDepth:
            if (d->paintDevice)
                return d->paintDevice->depth();
            break;
        default:
            break;
    }
    return QPaintDeviceWindow::metric(metric);
}
 
QPaintDevice *QOpenGLWindow::redirected(QPoint *) const
{
    Q_D(const QOpenGLWindow);
    if (QOpenGLContext::currentContext() == d->context.data())
        return d->paintDevice.data();
    return nullptr;
}
 
QT_END_NAMESPACE
 
#include "moc_qopenglwindow.cpp"