qrhiwidget.cpp

Go to the documentation of this file.

// Copyright (C) 2023 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 "qrhiwidget_p.h"
#include <private/qguiapplication_p.h>
#include <qpa/qplatformintegration.h>
#include <private/qwidgetrepaintmanager_p.h>
 
QT_BEGIN_NAMESPACE
 
QRhiWidget::QRhiWidget(QWidget *parent, Qt::WindowFlags f)
    : QWidget(*(new QRhiWidgetPrivate), parent, f)
{
    Q_D(QRhiWidget);
    if (Q_UNLIKELY(!QGuiApplicationPrivate::platformIntegration()->hasCapability(QPlatformIntegration::RhiBasedRendering)))
        qWarning("QRhiWidget: QRhi is not supported on this platform.");
    else
        d->setRenderToTexture();
 
    d->config.setEnabled(true);
#if defined(Q_OS_DARWIN)
    d->config.setApi(QPlatformBackingStoreRhiConfig::Metal);
#elif defined(Q_OS_WIN)
    d->config.setApi(QPlatformBackingStoreRhiConfig::D3D11);
#else
    d->config.setApi(QPlatformBackingStoreRhiConfig::OpenGL);
#endif
}
 
QRhiWidget::~QRhiWidget()
{
    Q_D(QRhiWidget);
 
    if (d->rhi) {
        d->rhi->removeCleanupCallback(this);
        // rhi resources must be destroyed here, due to how QWidget teardown works;
        // it should not be left to the private object's destruction.
        d->resetRenderTargetObjects();
        d->resetColorBufferObjects();
        qDeleteAll(d->pendingDeletes);
    }
 
    d->offscreenRenderer.reset();
}
 
void QRhiWidget::resizeEvent(QResizeEvent *e)
{
    Q_D(QRhiWidget);
 
    if (e->size().isEmpty()) {
        d->noSize = true;
        return;
    }
    d->noSize = false;
 
    d->sendPaintEvent(QRect(QPoint(0, 0), size()));
}
 
void QRhiWidget::paintEvent(QPaintEvent *)
{
    Q_D(QRhiWidget);
    if (!updatesEnabled() || d->noSize)
        return;
 
    d->ensureRhi();
    if (!d->rhi) {
        qWarning("QRhiWidget: No QRhi");
        emit renderFailed();
        return;
    }
 
    QRhiCommandBuffer *cb = nullptr;
    if (d->rhi->beginOffscreenFrame(&cb) != QRhi::FrameOpSuccess)
        return;
 
    bool needsInit = false;
    d->ensureTexture(&needsInit);
    if (d->colorTexture || d->msaaColorBuffer) {
        bool canRender = true;
        if (needsInit)
            canRender = d->invokeInitialize(cb);
        if (canRender)
            render(cb);
    }
 
    d->rhi->endOffscreenFrame();
}
 
bool QRhiWidget::event(QEvent *e)
{
    Q_D(QRhiWidget);
    switch (e->type()) {
    case QEvent::WindowAboutToChangeInternal:
        // The QRhi will almost certainly change, prevent texture() from
        // returning the existing QRhiTexture in the meantime.
        d->textureInvalid = true;
 
        if (d->rhi && d->rhi != d->offscreenRenderer.rhi()) {
            // Drop the cleanup callback registered to the toplevel's rhi and
            // do the early-release, there may not be another chance to do
            // this, and the QRhi we have currently set may be destroyed by the
            // time we get to ensureRhi() again.
            d->rhi->removeCleanupCallback(this);
            releaseResources(); // notify the user code about the early-release
            d->releaseResources();
            // must _not_ null out d->rhi here, for proper interaction with ensureRhi()
        }
 
        break;
 
    case QEvent::Show:
        if (isVisible())
            d->sendPaintEvent(QRect(QPoint(0, 0), size()));
        break;
    default:
        break;
    }
    return QWidget::event(e);
}
 
QWidgetPrivate::TextureData QRhiWidgetPrivate::texture() const
{
    // This is the only safe place to clear pendingDeletes, due to the
    // possibility of the texture returned in the previous invocation of this
    // function having been added to pendingDeletes, meaning the object then
    // needs to be valid until the next (this) invocation of this function.
    // (the exact object lifetime requirements depend on the
    // QWidget/RepaintManager internal implementation; for now avoid relying on
    // such details by clearing pendingDeletes only here, not in endCompose())
    qDeleteAll(pendingDeletes);
    pendingDeletes.clear();
 
    TextureData td;
    if (!textureInvalid)
        td.textureLeft = resolveTexture ? resolveTexture : colorTexture;
    return td;
}
 
QPlatformTextureList::Flags QRhiWidgetPrivate::textureListFlags()
{
    QPlatformTextureList::Flags flags = QWidgetPrivate::textureListFlags();
    if (mirrorVertically)
        flags |= QPlatformTextureList::MirrorVertically;
    return flags;
}
 
QPlatformBackingStoreRhiConfig QRhiWidgetPrivate::rhiConfig() const
{
    return config;
}
 
void QRhiWidgetPrivate::endCompose()
{
    // This function is called by QWidgetRepaintManager right after the
    // backingstore's QRhi-based flush returns. In practice that means after
    // the begin-endFrame() on the top-level window's swapchain.
 
    if (rhi) {
        Q_Q(QRhiWidget);
        emit q->frameSubmitted();
    }
}
 
// This is reimplemented to enable calling QWidget::grab() on the widget or an
// ancestor of it. At the same time, QRhiWidget provides its own
// grabFramebuffer() as well, mirroring QQuickWidget and QOpenGLWidget for
// consistency. In both types of grabs we end up in here.
QImage QRhiWidgetPrivate::grabFramebuffer()
{
    Q_Q(QRhiWidget);
    if (noSize)
        return QImage();
 
    ensureRhi();
    if (!rhi) {
        // The widget (and its parent chain, if any) may not be shown at
        // all, yet one may still want to use it for grabs. This is
        // ridiculous of course because the rendering infrastructure is
        // tied to the top-level widget that initializes upon expose, but
        // it has to be supported.
        offscreenRenderer.setConfig(config);
        // no window passed in, so no swapchain, but we get a functional QRhi which we own
        offscreenRenderer.create();
        rhi = offscreenRenderer.rhi();
        if (!rhi) {
            qWarning("QRhiWidget: Failed to create dedicated QRhi for grabbing");
            emit q->renderFailed();
            return QImage();
        }
    }
 
    QRhiCommandBuffer *cb = nullptr;
    if (rhi->beginOffscreenFrame(&cb) != QRhi::FrameOpSuccess)
        return QImage();
 
    QRhiReadbackResult readResult;
    bool readCompleted = false;
    bool needsInit = false;
    ensureTexture(&needsInit);
 
    if (colorTexture || msaaColorBuffer) {
        bool canRender = true;
        if (needsInit)
            canRender = invokeInitialize(cb);
        if (canRender)
            q->render(cb);
 
        QRhiResourceUpdateBatch *readbackBatch = rhi->nextResourceUpdateBatch();
        readResult.completed = [&readCompleted] { readCompleted = true; };
        readbackBatch->readBackTexture(resolveTexture ? resolveTexture : colorTexture, &readResult);
        cb->resourceUpdate(readbackBatch);
    }
 
    rhi->endOffscreenFrame();
 
    if (readCompleted) {
        QImage::Format imageFormat = QImage::Format_RGBA8888;
        switch (widgetTextureFormat) {
        case QRhiWidget::TextureFormat::RGBA8:
            break;
        case QRhiWidget::TextureFormat::RGBA16F:
            imageFormat = QImage::Format_RGBA16FPx4;
            break;
        case QRhiWidget::TextureFormat::RGBA32F:
            imageFormat = QImage::Format_RGBA32FPx4;
            break;
        case QRhiWidget::TextureFormat::RGB10A2:
            imageFormat = QImage::Format_BGR30;
            break;
        }
        QImage wrapperImage(reinterpret_cast<const uchar *>(readResult.data.constData()),
                            readResult.pixelSize.width(), readResult.pixelSize.height(),
                            imageFormat);
        QImage result;
        if (rhi->isYUpInFramebuffer())
            result = wrapperImage.mirrored();
        else
            result = wrapperImage.copy();
        result.setDevicePixelRatio(q->devicePixelRatio());
        return result;
    } else {
        Q_UNREACHABLE();
    }
 
    return QImage();
}
 
void QRhiWidgetPrivate::resetColorBufferObjects()
{
    if (colorTexture) {
        pendingDeletes.append(colorTexture);
        colorTexture = nullptr;
    }
    if (msaaColorBuffer) {
        pendingDeletes.append(msaaColorBuffer);
        msaaColorBuffer = nullptr;
    }
    if (resolveTexture) {
        pendingDeletes.append(resolveTexture);
        resolveTexture = nullptr;
    }
}
 
void QRhiWidgetPrivate::resetRenderTargetObjects()
{
    if (renderTarget) {
        renderTarget->deleteLater();
        renderTarget = nullptr;
    }
    if (renderPassDescriptor) {
        renderPassDescriptor->deleteLater();
        renderPassDescriptor = nullptr;
    }
    if (depthStencilBuffer) {
        depthStencilBuffer->deleteLater();
        depthStencilBuffer = nullptr;
    }
}
 
void QRhiWidgetPrivate::releaseResources()
{
    resetRenderTargetObjects();
    resetColorBufferObjects();
    qDeleteAll(pendingDeletes);
    pendingDeletes.clear();
}
 
void QRhiWidgetPrivate::ensureRhi()
{
    Q_Q(QRhiWidget);
    QRhi *currentRhi = QWidgetPrivate::rhi();
    if (currentRhi && currentRhi->backend() != QBackingStoreRhiSupport::apiToRhiBackend(config.api())) {
        qWarning("The top-level window is already using another graphics API for composition, "
                 "'%s' is not compatible with this widget",
                 currentRhi->backendName());
        return;
    }
 
    // NB the rhi member may be an invalid object, the pointer can be used, but no deref
    if (currentRhi && rhi != currentRhi) {
        if (rhi) {
            // if previously we created our own but now get a QRhi from the
            // top-level, then drop what we have and start using the top-level's
            if (rhi == offscreenRenderer.rhi()) {
                q->releaseResources(); // notify the user code about the early-release
                releaseResources();
                offscreenRenderer.reset();
            } else {
                // rhi resources created by us all belong to the old rhi, drop them;
                // due to nulling out colorTexture this is also what ensures that
                // initialize() is going to be called again eventually
                resetRenderTargetObjects();
                resetColorBufferObjects();
            }
        }
 
        // Normally the widget gets destroyed before the QRhi (which is managed by
        // the top-level's backingstore). When reparenting between top-levels is
        // involved, that is not always the case. Therefore we use a per-widget rhi
        // cleanup callback to get notified when the QRhi is about to be destroyed
        // while the QRhiWidget is still around.
        currentRhi->addCleanupCallback(q, [q, this](QRhi *regRhi) {
            if (!QWidgetPrivate::get(q)->data.in_destructor && this->rhi == regRhi) {
                q->releaseResources(); // notify the user code about the early-release
                releaseResources();
                // must null out our ref, the QRhi object is going to be invalid
                this->rhi = nullptr;
            }
        });
    }
 
    rhi = currentRhi;
}
 
void QRhiWidgetPrivate::ensureTexture(bool *changed)
{
    Q_Q(QRhiWidget);
 
    QSize newSize = fixedSize;
    if (newSize.isEmpty())
        newSize = q->size() * q->devicePixelRatio();
 
    const int minTexSize = rhi->resourceLimit(QRhi::TextureSizeMin);
    const int maxTexSize = rhi->resourceLimit(QRhi::TextureSizeMax);
    newSize.setWidth(qMin(maxTexSize, qMax(minTexSize, newSize.width())));
    newSize.setHeight(qMin(maxTexSize, qMax(minTexSize, newSize.height())));
 
    if (colorTexture) {
        if (colorTexture->format() != rhiTextureFormat || colorTexture->sampleCount() != samples) {
            resetColorBufferObjects();
            // sample count change needs new depth-stencil, possibly a new
            // render target; format change needs new renderpassdescriptor;
            // therefore must drop the rest too
            resetRenderTargetObjects();
        }
    }
 
    if (msaaColorBuffer) {
        if (msaaColorBuffer->backingFormat() != rhiTextureFormat || msaaColorBuffer->sampleCount() != samples) {
            resetColorBufferObjects();
            // sample count change needs new depth-stencil, possibly a new
            // render target; format change needs new renderpassdescriptor;
            // therefore must drop the rest too
            resetRenderTargetObjects();
        }
    }
 
    if (!colorTexture && samples <= 1) {
        if (changed)
            *changed = true;
        if (!rhi->isTextureFormatSupported(rhiTextureFormat)) {
            qWarning("QRhiWidget: The requested texture format (%d) is not supported by the "
                     "underlying 3D graphics API implementation", int(rhiTextureFormat));
        }
        colorTexture = rhi->newTexture(rhiTextureFormat, newSize, samples, QRhiTexture::RenderTarget | QRhiTexture::UsedAsTransferSource);
        if (!colorTexture->create()) {
            qWarning("Failed to create backing texture for QRhiWidget");
            delete colorTexture;
            colorTexture = nullptr;
            return;
        }
    }
 
    if (samples > 1) {
        if (!msaaColorBuffer) {
            if (changed)
                *changed = true;
            if (!rhi->isFeatureSupported(QRhi::MultisampleRenderBuffer)) {
                qWarning("QRhiWidget: Multisample renderbuffers are reported as unsupported; "
                         "sample count %d will not work as expected", samples);
            }
            if (!rhi->isTextureFormatSupported(rhiTextureFormat)) {
                qWarning("QRhiWidget: The requested texture format (%d) is not supported by the "
                         "underlying 3D graphics API implementation", int(rhiTextureFormat));
            }
            msaaColorBuffer = rhi->newRenderBuffer(QRhiRenderBuffer::Color, newSize, samples, {}, rhiTextureFormat);
            if (!msaaColorBuffer->create()) {
                qWarning("Failed to create multisample color buffer for QRhiWidget");
                delete msaaColorBuffer;
                msaaColorBuffer = nullptr;
                return;
            }
        }
        if (!resolveTexture) {
            if (changed)
                *changed = true;
            resolveTexture = rhi->newTexture(rhiTextureFormat, newSize, 1, QRhiTexture::RenderTarget | QRhiTexture::UsedAsTransferSource);
            if (!resolveTexture->create()) {
                qWarning("Failed to create resolve texture for QRhiWidget");
                delete resolveTexture;
                resolveTexture = nullptr;
                return;
            }
        }
    } else if (resolveTexture) {
        resolveTexture->deleteLater();
        resolveTexture = nullptr;
    }
 
    if (colorTexture && colorTexture->pixelSize() != newSize) {
        if (changed)
            *changed = true;
        colorTexture->setPixelSize(newSize);
        if (!colorTexture->create())
            qWarning("Failed to rebuild texture for QRhiWidget after resizing");
    }
 
    if (msaaColorBuffer && msaaColorBuffer->pixelSize() != newSize) {
        if (changed)
            *changed = true;
        msaaColorBuffer->setPixelSize(newSize);
        if (!msaaColorBuffer->create())
            qWarning("Failed to rebuild multisample color buffer for QRhiWidget after resizing");
    }
 
    if (resolveTexture && resolveTexture->pixelSize() != newSize) {
        if (changed)
            *changed = true;
        resolveTexture->setPixelSize(newSize);
        if (!resolveTexture->create())
            qWarning("Failed to rebuild resolve texture for QRhiWidget after resizing");
    }
 
    textureInvalid = false;
}
 
bool QRhiWidgetPrivate::invokeInitialize(QRhiCommandBuffer *cb)
{
    Q_Q(QRhiWidget);
    if (!colorTexture && !msaaColorBuffer)
        return false;
 
    if (autoRenderTarget) {
        const QSize pixelSize = colorTexture ? colorTexture->pixelSize() : msaaColorBuffer->pixelSize();
        if (!depthStencilBuffer) {
            depthStencilBuffer = rhi->newRenderBuffer(QRhiRenderBuffer::DepthStencil, pixelSize, samples);
            if (!depthStencilBuffer->create()) {
                qWarning("Failed to create depth-stencil buffer for QRhiWidget");
                resetRenderTargetObjects();
                return false;
            }
        } else if (depthStencilBuffer->pixelSize() != pixelSize) {
            depthStencilBuffer->setPixelSize(pixelSize);
            if (!depthStencilBuffer->create()) {
                qWarning("Failed to rebuild depth-stencil buffer for QRhiWidget with new size");
                return false;
            }
        }
 
        if (!renderTarget) {
            QRhiColorAttachment color0;
            if (colorTexture)
                color0.setTexture(colorTexture);
            else
                color0.setRenderBuffer(msaaColorBuffer);
            if (samples > 1)
                color0.setResolveTexture(resolveTexture);
            QRhiTextureRenderTargetDescription rtDesc(color0, depthStencilBuffer);
            renderTarget = rhi->newTextureRenderTarget(rtDesc);
            renderPassDescriptor = renderTarget->newCompatibleRenderPassDescriptor();
            renderTarget->setRenderPassDescriptor(renderPassDescriptor);
            if (!renderTarget->create()) {
                qWarning("Failed to create render target for QRhiWidget");
                resetRenderTargetObjects();
                return false;
            }
        }
    } else {
        resetRenderTargetObjects();
    }
 
    q->initialize(cb);
 
    return true;
}
 
QRhiWidget::Api QRhiWidget::api() const
{
    Q_D(const QRhiWidget);
    switch (d->config.api()) {
    case QPlatformBackingStoreRhiConfig::OpenGL:
        return Api::OpenGL;
    case QPlatformBackingStoreRhiConfig::Metal:
        return Api::Metal;
    case QPlatformBackingStoreRhiConfig::Vulkan:
        return Api::Vulkan;
    case QPlatformBackingStoreRhiConfig::D3D11:
        return Api::Direct3D11;
    case QPlatformBackingStoreRhiConfig::D3D12:
        return Api::Direct3D12;
    case QPlatformBackingStoreRhiConfig::Null:
        return Api::Null;
    }
    Q_UNREACHABLE_RETURN(Api::Null);
}
 
void QRhiWidget::setApi(Api api)
{
    Q_D(QRhiWidget);
    switch (api) {
    case Api::OpenGL:
        d->config.setApi(QPlatformBackingStoreRhiConfig::OpenGL);
        break;
    case Api::Metal:
        d->config.setApi(QPlatformBackingStoreRhiConfig::Metal);
        break;
    case Api::Vulkan:
        d->config.setApi(QPlatformBackingStoreRhiConfig::Vulkan);
        break;
    case Api::Direct3D11:
        d->config.setApi(QPlatformBackingStoreRhiConfig::D3D11);
        break;
    case Api::Direct3D12:
        d->config.setApi(QPlatformBackingStoreRhiConfig::D3D12);
        break;
    case Api::Null:
        d->config.setApi(QPlatformBackingStoreRhiConfig::Null);
        break;
    }
}
 
bool QRhiWidget::isDebugLayerEnabled() const
{
    Q_D(const QRhiWidget);
    return d->config.isDebugLayerEnabled();
}
 
void QRhiWidget::setDebugLayerEnabled(bool enable)
{
    Q_D(QRhiWidget);
    d->config.setDebugLayer(enable);
}
 
QRhiWidget::TextureFormat QRhiWidget::colorBufferFormat() const
{
    Q_D(const QRhiWidget);
    return d->widgetTextureFormat;
}
 
void QRhiWidget::setColorBufferFormat(TextureFormat format)
{
    Q_D(QRhiWidget);
    if (d->widgetTextureFormat != format) {
        d->widgetTextureFormat = format;
        switch (format) {
        case TextureFormat::RGBA8:
            d->rhiTextureFormat = QRhiTexture::RGBA8;
            break;
        case TextureFormat::RGBA16F:
            d->rhiTextureFormat = QRhiTexture::RGBA16F;
            break;
        case TextureFormat::RGBA32F:
            d->rhiTextureFormat = QRhiTexture::RGBA32F;
            break;
        case TextureFormat::RGB10A2:
            d->rhiTextureFormat = QRhiTexture::RGB10A2;
            break;
        }
        emit colorBufferFormatChanged(format);
        update();
    }
}
 
int QRhiWidget::sampleCount() const
{
    Q_D(const QRhiWidget);
    return d->samples;
}
 
void QRhiWidget::setSampleCount(int samples)
{
    Q_D(QRhiWidget);
    if (d->samples != samples) {
        d->samples = samples;
        emit sampleCountChanged(samples);
        update();
    }
}
 
QSize QRhiWidget::fixedColorBufferSize() const
{
    Q_D(const QRhiWidget);
    return d->fixedSize;
}
 
void QRhiWidget::setFixedColorBufferSize(QSize pixelSize)
{
    Q_D(QRhiWidget);
    if (d->fixedSize != pixelSize) {
        d->fixedSize = pixelSize;
        emit fixedColorBufferSizeChanged(pixelSize);
        update();
    }
}
 
bool QRhiWidget::isMirrorVerticallyEnabled() const
{
    Q_D(const QRhiWidget);
    return d->mirrorVertically;
}
 
void QRhiWidget::setMirrorVertically(bool enabled)
{
    Q_D(QRhiWidget);
    if (d->mirrorVertically != enabled) {
        d->mirrorVertically = enabled;
        emit mirrorVerticallyChanged(enabled);
        update();
    }
}
 
bool QRhiWidget::isAutoRenderTargetEnabled() const
{
    Q_D(const QRhiWidget);
    return d->autoRenderTarget;
}
 
void QRhiWidget::setAutoRenderTarget(bool enabled)
{
    Q_D(QRhiWidget);
    if (d->autoRenderTarget != enabled) {
        d->autoRenderTarget = enabled;
        update();
    }
}
 
QImage QRhiWidget::grabFramebuffer() const
{
    return const_cast<QRhiWidgetPrivate *>(d_func())->grabFramebuffer();
}
 
void QRhiWidget::initialize(QRhiCommandBuffer *cb)
{
    Q_UNUSED(cb);
}
 
void QRhiWidget::render(QRhiCommandBuffer *cb)
{
    Q_UNUSED(cb);
}
 
void QRhiWidget::releaseResources()
{
}
 
QRhi *QRhiWidget::rhi() const
{
    Q_D(const QRhiWidget);
    return d->rhi;
}
 
QRhiTexture *QRhiWidget::colorTexture() const
{
    Q_D(const QRhiWidget);
    return d->colorTexture;
}
 
QRhiRenderBuffer *QRhiWidget::msaaColorBuffer() const
{
    Q_D(const QRhiWidget);
    return d->msaaColorBuffer;
}
 
QRhiTexture *QRhiWidget::resolveTexture() const
{
    Q_D(const QRhiWidget);
    return d->resolveTexture;
}
 
QRhiRenderBuffer *QRhiWidget::depthStencilBuffer() const
{
    Q_D(const QRhiWidget);
    return d->depthStencilBuffer;
}
 
QRhiRenderTarget *QRhiWidget::renderTarget() const
{
    Q_D(const QRhiWidget);
    return d->renderTarget;
}
 
QT_END_NAMESPACE