qquickrendercontrol.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 "qquickrendercontrol.h"
#include "qquickrendercontrol_p.h"
 
#include <QtCore/QCoreApplication>
#include <QtCore/QTime>
#include <QtQuick/private/qquickanimatorcontroller_p.h>
#include <QtQuick/private/qsgdefaultrendercontext_p.h>
#include <QtQuick/private/qsgrhisupport_p.h>
 
#include <private/qsgrhishadereffectnode_p.h>
 
#include <QtGui/private/qguiapplication_p.h>
#include <qpa/qplatformintegration.h>
#include <QtGui/qoffscreensurface.h>
 
#include <QtQml/private/qqmlglobal_p.h>
 
#include <QtQuick/QQuickWindow>
#include <QtQuick/QQuickRenderTarget>
#include <QtQuick/private/qquickwindow_p.h>
#include <QtQuick/private/qquickitem_p.h>
#include <QtQuick/private/qsgsoftwarerenderer_p.h>
#include <QtCore/private/qobject_p.h>
 
#include <QtQuick/private/qquickwindow_p.h>
#include <rhi/qrhi.h>
 
QT_BEGIN_NAMESPACE
 
QSGContext *QQuickRenderControlPrivate::sg = nullptr;
 
QQuickRenderControlPrivate::QQuickRenderControlPrivate(QQuickRenderControl *renderControl)
    : q(renderControl),
      initialized(false),
      window(nullptr),
      rhi(nullptr),
      ownRhi(true),
      cb(nullptr),
      offscreenSurface(nullptr),
      sampleCount(1),
      frameStatus(NotRecordingFrame)
{
    if (!sg) {
        qAddPostRoutine(cleanup);
        sg = QSGContext::createDefaultContext();
    }
    rc = sg->createRenderContext();
}
 
void QQuickRenderControlPrivate::cleanup()
{
    delete sg;
    sg = nullptr;
}
 
QQuickRenderControl::QQuickRenderControl(QObject *parent)
    : QObject(*(new QQuickRenderControlPrivate(this)), parent)
{
}
 
QQuickRenderControl::QQuickRenderControl(QQuickRenderControlPrivate &dd, QObject * parent)
    : QObject(dd, parent)
{
}
 
QQuickRenderControl::~QQuickRenderControl()
{
    Q_D(QQuickRenderControl);
 
    invalidate();
 
    QQuickGraphicsConfiguration config;
    if (d->window) {
        QQuickWindowPrivate *wd = QQuickWindowPrivate::get(d->window);
        wd->renderControl = nullptr;
        config = wd->graphicsConfig;
    }
 
    // It is likely that the cleanup in windowDestroyed() is not called since
    // the standard pattern is to destroy the rendercontrol before the QQuickWindow.
    // Do it here.
    d->windowDestroyed();
 
    delete d->rc;
 
    // Only call rhi related cleanup when we actually got to initialize() and
    // managed to get a QRhi. The software backend for instance would mean
    // using the rendercontrol without ever calling initialize() - it is then
    // important to completely skip calling any QSGRhiSupport functions.
    if (d->rhi)
        d->resetRhi(config);
}
 
void QQuickRenderControlPrivate::windowDestroyed()
{
    if (window) {
        QQuickWindowPrivate *cd = QQuickWindowPrivate::get(window);
        cd->cleanupNodesOnShutdown();
 
        rc->invalidate();
 
        QQuickWindowPrivate::get(window)->animationController.reset();
 
#if QT_CONFIG(quick_shadereffect)
        QSGRhiShaderEffectNode::resetMaterialTypeCache(window);
#endif
 
        window = nullptr;
    }
}
 
void QQuickRenderControl::prepareThread(QThread *targetThread)
{
    Q_D(QQuickRenderControl);
    d->rc->moveToThread(targetThread);
    QQuickWindowPrivate::get(d->window)->animationController->moveToThread(targetThread);
}
 
void QQuickRenderControl::setSamples(int sampleCount)
{
    Q_D(QQuickRenderControl);
    d->sampleCount = qMax(1, sampleCount);
}
 
int QQuickRenderControl::samples() const
{
    Q_D(const QQuickRenderControl);
    return d->sampleCount;
}
 
bool QQuickRenderControl::initialize()
{
    Q_D(QQuickRenderControl);
    if (!d->window) {
        qWarning("QQuickRenderControl::initialize called with no associated window");
        return false;
    }
 
    if (!d->initRhi())
        return false;
 
    QQuickWindowPrivate *wd = QQuickWindowPrivate::get(d->window);
    wd->rhi = d->rhi;
 
    QSGDefaultRenderContext *renderContext = qobject_cast<QSGDefaultRenderContext *>(d->rc);
    if (renderContext) {
        QSGDefaultRenderContext::InitParams params;
        params.rhi = d->rhi;
        params.sampleCount = d->sampleCount;
        params.initialSurfacePixelSize = d->window->size() * d->window->effectiveDevicePixelRatio();
        params.maybeSurface = d->window;
        renderContext->initialize(&params);
        d->initialized = true;
    } else {
        qWarning("QRhi is only compatible with default adaptation");
        return false;
    }
    return true;
}
 
void QQuickRenderControl::polishItems()
{
    Q_D(QQuickRenderControl);
    if (!d->window)
        return;
 
    QQuickWindowPrivate *cd = QQuickWindowPrivate::get(d->window);
    cd->deliveryAgentPrivate()->flushFrameSynchronousEvents(d->window);
    if (!d->window)
        return;
    cd->polishItems();
    emit d->window->afterAnimating();
}
 
bool QQuickRenderControl::sync()
{
    Q_D(QQuickRenderControl);
    if (!d->window)
        return false;
 
    QQuickWindowPrivate *cd = QQuickWindowPrivate::get(d->window);
    // we may not have a d->rhi (software backend) hence the check is important
    if (d->rhi) {
        if (!d->rhi->isRecordingFrame()) {
            qWarning("QQuickRenderControl can only sync when beginFrame() has been called");
            return false;
        }
        if (!d->cb) {
            qWarning("QQuickRenderControl cannot be used with QRhi when no QRhiCommandBuffer is provided "
                     "(perhaps beginFrame() was not called or it was unsuccessful?)");
            return false;
        }
        cd->setCustomCommandBuffer(d->cb);
    }
 
    cd->syncSceneGraph();
    d->rc->endSync();
 
    return true;
}
 
void QQuickRenderControl::invalidate()
{
    Q_D(QQuickRenderControl);
    if (!d->window)
        return;
 
    QQuickWindowPrivate *cd = QQuickWindowPrivate::get(d->window);
    cd->fireAboutToStop();
    cd->cleanupNodesOnShutdown();
 
    if (!d->initialized)
        return;
 
    // We must invalidate since the context can potentially be destroyed by the
    // application right after returning from this function. Invalidating is
    // also essential to allow a subsequent initialize() to succeed.
    d->rc->invalidate();
 
    d->frameStatus = QQuickRenderControlPrivate::NotRecordingFrame;
    d->initialized = false;
}
 
void QQuickRenderControl::render()
{
    Q_D(QQuickRenderControl);
    if (!d->window)
        return;
 
    QQuickWindowPrivate *cd = QQuickWindowPrivate::get(d->window);
    // we may not have a d->rhi (software backend) hence the check is important
    if (d->rhi) {
        if (!d->rhi->isRecordingFrame()) {
            qWarning("QQuickRenderControl can only render when beginFrame() has been called");
            return;
        }
        if (!d->cb) {
            qWarning("QQuickRenderControl cannot be used with QRhi when no QRhiCommandBuffer is provided");
            return;
        }
        cd->setCustomCommandBuffer(d->cb);
    }
 
    cd->renderSceneGraph();
}
 
QImage QQuickRenderControlPrivate::grab()
{
    if (!window)
        return QImage();
 
    QImage grabContent;
 
    if (rhi) {
 
        // As documented by QQuickWindow::grabWindow(): Nothing to do here, we
        // do not support "grabbing" with an application-provided render target
        // in Qt 6. (with the exception of the software backend because that
        // does not support custom render targets, so the grab implementation
        // here is still valuable)
 
#if QT_CONFIG(thread)
    } else if (window->rendererInterface()->graphicsApi() == QSGRendererInterface::Software) {
        QQuickWindowPrivate *cd = QQuickWindowPrivate::get(window);
        cd->polishItems();
        cd->syncSceneGraph();
        QSGSoftwareRenderer *softwareRenderer = static_cast<QSGSoftwareRenderer *>(cd->renderer);
        if (softwareRenderer) {
            const qreal dpr = window->effectiveDevicePixelRatio();
            const QSize imageSize = window->size() * dpr;
            grabContent = QImage(imageSize, QImage::Format_ARGB32_Premultiplied);
            grabContent.setDevicePixelRatio(dpr);
            QPaintDevice *prevDev = softwareRenderer->currentPaintDevice();
            softwareRenderer->setCurrentPaintDevice(&grabContent);
            softwareRenderer->markDirty();
            rc->endSync();
            q->render();
            softwareRenderer->setCurrentPaintDevice(prevDev);
        }
#endif
    } else {
        qWarning("QQuickRenderControl: grabs are not supported with the current Qt Quick backend");
    }
 
    return grabContent;
}
 
void QQuickRenderControlPrivate::update()
{
    Q_Q(QQuickRenderControl);
    emit q->renderRequested();
}
 
void QQuickRenderControlPrivate::maybeUpdate()
{
    Q_Q(QQuickRenderControl);
    emit q->sceneChanged();
}
 
QWindow *QQuickRenderControl::renderWindowFor(QQuickWindow *win, QPoint *offset)
{
    if (!win)
        return nullptr;
    QQuickRenderControl *rc = QQuickWindowPrivate::get(win)->renderControl;
    if (rc)
        return rc->renderWindow(offset);
    return nullptr;
}
 
bool QQuickRenderControlPrivate::isRenderWindowFor(QQuickWindow *quickWin, const QWindow *renderWin)
{
    QQuickRenderControl *rc = QQuickWindowPrivate::get(quickWin)->renderControl;
    if (rc)
        return QQuickRenderControlPrivate::get(rc)->isRenderWindow(renderWin);
    return false;
}
 
bool QQuickRenderControlPrivate::isRenderWindow(const QWindow *w)
{
    Q_Q(QQuickRenderControl);
 
    if (window && w)
        return q->renderWindowFor(window, nullptr) == w;
 
    return false;
}
 
QQuickWindow *QQuickRenderControl::window() const
{
    Q_D(const QQuickRenderControl);
    return d->window;
}
 
QRhi *QQuickRenderControl::rhi() const
{
    Q_D(const QQuickRenderControl);
    return d->rhi;
}
 
QRhiCommandBuffer *QQuickRenderControl::commandBuffer() const
{
    Q_D(const QQuickRenderControl);
    return d->cb;
}
 
void QQuickRenderControl::beginFrame()
{
    Q_D(QQuickRenderControl);
    if (!d->rhi) {
        qWarning("QQuickRenderControl: No QRhi in beginFrame()");
        return;
    }
    if (d->frameStatus == QQuickRenderControlPrivate::RecordingFrame) {
        qWarning("QQuickRenderControl: beginFrame() must be followed by a call to endFrame() before calling beginFrame() again");
        return;
    }
    if (d->rhi->isRecordingFrame()) {
        qWarning("QQuickRenderControl: Attempted to beginFrame() while the QRhi is already recording a frame");
        return;
    }
 
    emit d->window->beforeFrameBegin();
 
    QRhi::FrameOpResult result = d->rhi->beginOffscreenFrame(&d->cb);
 
    switch (result) {
    case QRhi::FrameOpSuccess:
    case QRhi::FrameOpSwapChainOutOfDate:
        d->frameStatus = QQuickRenderControlPrivate::RecordingFrame;
        break;
    case QRhi::FrameOpError:
        d->frameStatus = QQuickRenderControlPrivate::ErrorInBeginFrame;
        break;
    case QRhi::FrameOpDeviceLost:
        d->frameStatus = QQuickRenderControlPrivate::DeviceLostInBeginFrame;
        break;
    default:
        d->frameStatus = QQuickRenderControlPrivate::NotRecordingFrame;
        break;
    }
}
 
void QQuickRenderControl::endFrame()
{
    Q_D(QQuickRenderControl);
    if (!d->rhi) {
        qWarning("QQuickRenderControl: No QRhi in endFrame()");
        return;
    }
    if (d->frameStatus != QQuickRenderControlPrivate::RecordingFrame) {
        qWarning("QQuickRenderControl: endFrame() must only be called after a successful beginFrame()");
        return;
    }
    if (!d->rhi->isRecordingFrame()) {
        qWarning("QQuickRenderControl: Attempted to endFrame() while the QRhi is not recording a frame");
        return;
    }
 
    d->rhi->endOffscreenFrame();
    // do not null out d->cb; this allows calling lastCompletedGpuTime() for example
 
    d->frameStatus = QQuickRenderControlPrivate::NotRecordingFrame;
 
    emit d->window->afterFrameEnd();
}
 
bool QQuickRenderControlPrivate::initRhi()
{
    // initialize() - invalidate() - initialize() uses the QRhi the first
    // initialize() created, so if already exists, we are done. Does not apply
    // when wrapping an externally created QRhi, because we may be associated
    // with a new one now.
    if (rhi && ownRhi)
        return true;
 
    QSGRhiSupport *rhiSupport = QSGRhiSupport::instance();
 
    // sanity check for Vulkan
#if QT_CONFIG(vulkan)
    if (rhiSupport->rhiBackend() == QRhi::Vulkan && !window->vulkanInstance()) {
        qWarning("QQuickRenderControl: No QVulkanInstance set for QQuickWindow, cannot initialize");
        return false;
    }
#endif
 
    // for OpenGL
    if (!offscreenSurface)
        offscreenSurface = rhiSupport->maybeCreateOffscreenSurface(window);
 
    QSGRhiSupport::RhiCreateResult result = rhiSupport->createRhi(window, offscreenSurface);
    if (!result.rhi) {
        qWarning("QQuickRenderControl: Failed to initialize QRhi");
        return false;
    }
 
    rhi = result.rhi;
    ownRhi = result.own;
 
    return true;
}
 
void QQuickRenderControlPrivate::resetRhi(const QQuickGraphicsConfiguration &config)
{
    if (ownRhi)
        QSGRhiSupport::instance()->destroyRhi(rhi, config);
 
    rhi = nullptr;
 
    delete offscreenSurface;
    offscreenSurface = nullptr;
}
 
QT_END_NAMESPACE
 
#include "moc_qquickrendercontrol.cpp"