scene3drenderer.cpp

qt/qt3d/src/quick3d/quick3dscene3d/scene3drenderer.cpp (file symbol)

Enable keyboard shortcuts

Revision control

Copy as Markdown

// Copyright (C) 2016 Klaralvdalens Datakonsult AB (KDAB).

// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only

#include "scene3drenderer_p.h"

#include <Qt3DCore/qaspectengine.h>

#include <Qt3DRender/qrenderaspect.h>

#include <QtCore/qthread.h>

#include <qopenglcontext.h>

#include <qopenglframebufferobject.h>

#include <QtQuick/qquickwindow.h>

#include <rhi/qrhi.h>

#include <Qt3DRender/private/qrenderaspect_p.h>

#include <Qt3DRender/private/abstractrenderer_p.h>

#include <Qt3DCore/private/qaspectengine_p.h>

#include <Qt3DCore/private/qaspectmanager_p.h>

#include <Qt3DCore/private/qchangearbiter_p.h>

#include <Qt3DCore/private/qservicelocator_p.h>

#include <scene3ditem_p.h>

#include <scene3dlogging_p.h>

#include <scene3dsgnode_p.h>

#include <QtQuick/private/qquickwindow_p.h>

QT_BEGIN_NAMESPACE

namespace Qt3DRender {

class ContextSaver

public:

    explicit ContextSaver(QOpenGLContext *context = QOpenGLContext::currentContext())

        : m_context(context),

          m_surface(context ? context->surface() : nullptr)

    ~ContextSaver()

        if (m_context && m_context->surface() != m_surface)

            m_context->makeCurrent(m_surface);

    QOpenGLContext *context() const { return m_context; }

    QSurface *surface() const { return m_surface; }

private:

    QOpenGLContext * const m_context;

    QSurface * const m_surface;

};

/*!

    \class Qt3DRender::Scene3DRenderer

    \internal

    \brief The Scene3DRenderer class takes care of rendering a Qt3D scene

    within a Framebuffer object to be used by the QtQuick 2 renderer.

    The Scene3DRenderer class renders a Qt3D scene as provided by a Scene3DItem.

    It owns the aspectEngine even though it doesn't instantiate it.

    The render loop goes as follows:

    \list

    \li The main thread runs, drives Animations, etc. and causes changes to be

    reported to the Qt3D change arbiter. The first change reported will cause

    the scene3drenderer to be marked dirty.

    \li The QtQuick render thread starts a new frame, synchronizes the scene

    graph and emits afterSynchronizing. This will trigger some preparational

    steps for rendering and mark the QSGNode dirty if the Scene3DRenderer is

    dirty.

    \li The QtQuick render loop emits beforeRendering. If we're marked dirty or

    if the renderPolicy is set to Always, we'll ask the Qt3D renderer aspect to

    render. That call is blocking. If the aspect jobs are not done, yet, the

    renderer will exit early and we skip a frame.

    \endlist

    The shutdown procedure is a two steps process that goes as follow:

    \list

    \li The window is closed

    \li This triggers the windowsChanged signal which the Scene3DRenderer

    uses to perform the necessary cleanups in the QSGRenderThread (destroys

    DebugLogger ...) with the shutdown slot (queued connection).

    \li The destroyed signal of the window is also connected to the

    Scene3DRenderer. When triggered in the context of the main thread, the

    cleanup slot is called.

    \endlist

    There is an alternate shutdown procedure in case the QQuickItem is

    destroyed with an active window which can happen in the case where the

    Scene3D is used with a QtQuick Loader

    In that case the shutdown procedure goes the same except that the destroyed

    signal of the window is not called. Therefore the cleanup method is invoked

    to properly destroy the aspect engine.

*/

Scene3DRenderer::Scene3DRenderer()

    : QObject()

    , m_aspectEngine(nullptr)

    , m_renderAspect(nullptr)

    , m_node(nullptr)

    , m_window(nullptr)

    , m_needsShutdown(true)

    , m_shouldRender(false)

    , m_dirtyViews(false)

    , m_skipFrame(false)

    , m_allowRendering(0)

    , m_compositingMode(Scene3DItem::FBO)

void Scene3DRenderer::init(Qt3DCore::QAspectEngine *aspectEngine,

                           QRenderAspect *renderAspect)

    m_aspectEngine = aspectEngine;

    m_renderAspect = renderAspect;

    m_needsShutdown = true;

    // Detect which Rendering backend Qt3D is using

     Qt3DRender::QRenderAspectPrivate *aspectPriv = static_cast<QRenderAspectPrivate*>(QRenderAspectPrivate::get(m_renderAspect));

     Qt3DRender::Render::AbstractRenderer *renderer = aspectPriv->m_renderer;

    const bool isRHI = renderer->api() == API::RHI;

    if (isRHI)

        m_quickRenderer = new Scene3DRenderer::RHIRenderer;

    else

        m_quickRenderer = new Scene3DRenderer::GLRenderer;

    m_quickRenderer->initialize(this, renderer);

void Scene3DRenderer::setWindow(QQuickWindow *window)

    if (window == m_window)

        return;

    QObject::disconnect(m_window);

    m_window = window;

    if (m_window) {

        QObject::connect(m_window, &QQuickWindow::beforeRendering, this,

                         [this] () { m_quickRenderer->beforeRendering(this); }, Qt::DirectConnection);

        QObject::connect(m_window, &QQuickWindow::beforeRenderPassRecording, this,

                         [this] () { m_quickRenderer->beforeRenderPassRecording(this); }, Qt::DirectConnection);

    } else {

        shutdown();

Scene3DRenderer::~Scene3DRenderer()

    qCDebug(Scene3D) << Q_FUNC_INFO << QThread::currentThread();

    shutdown();

Scene3DSGNode *Scene3DRenderer::sgNode() const

    return m_node;

bool Scene3DRenderer::isYUp() const

    return m_quickRenderer ? m_quickRenderer->isYUp() : true;

// Executed in the QtQuick render thread (which may even be the gui/main with QQuickWidget / RenderControl).

void Scene3DRenderer::shutdown()

    if (!m_needsShutdown)

        return;

    m_needsShutdown = false;

    m_quickRenderer->shutdown(this);

    delete m_quickRenderer;

    m_quickRenderer = nullptr;

// Render Thread, GUI locked

void Scene3DRenderer::beforeSynchronize()

    m_quickRenderer->beforeSynchronize(this);

void Scene3DRenderer::allowRender()

    m_allowRendering.release(1);

void Scene3DRenderer::setCompositingMode(Scene3DItem::CompositingMode mode)

    m_compositingMode = mode;

void Scene3DRenderer::setSkipFrame(bool skip)

    m_skipFrame = skip;

void Scene3DRenderer::setMultisample(bool multisample)

    m_multisample = multisample;

void Scene3DRenderer::setBoundingSize(const QSize &size)

    m_boundingRectSize = size;

QOpenGLFramebufferObject *Scene3DRenderer::GLRenderer::createMultisampledFramebufferObject(const QSize &size)

    QOpenGLFramebufferObjectFormat format;

    format.setAttachment(QOpenGLFramebufferObject::CombinedDepthStencil);

    int samples = QSurfaceFormat::defaultFormat().samples();

    if (samples == -1)

        samples = 4;

    format.setSamples(samples);

    return new QOpenGLFramebufferObject(size, format);

QOpenGLFramebufferObject *Scene3DRenderer::GLRenderer::createFramebufferObject(const QSize &size)

    QOpenGLFramebufferObjectFormat format;

    format.setAttachment(QOpenGLFramebufferObject::Depth);

    return new QOpenGLFramebufferObject(size, format);

void Scene3DRenderer::GLRenderer::initialize(Scene3DRenderer *scene3DRenderer,

                                             Qt3DRender::Render::AbstractRenderer *renderer)

    Q_UNUSED(scene3DRenderer);

    Q_ASSERT(QOpenGLContext::currentContext());

    m_renderer = renderer;

    ContextSaver saver;

    Q_ASSERT(renderer->api() == API::OpenGL);

    m_renderer->setRenderDriver(Qt3DRender::Render::AbstractRenderer::Scene3D);

    m_renderer->setOpenGLContext(saver.context());

    m_renderer->initialize();

void Scene3DRenderer::GLRenderer::beforeSynchronize(Scene3DRenderer *scene3DRenderer)

    // Check size / multisampling

    QQuickWindow *window = scene3DRenderer->m_window;

    if (!window)

        return;

    // Only render if we are sure aspectManager->processFrame was called prior

    // We could otherwise enter a deadlock state

    if (!scene3DRenderer->m_allowRendering.tryAcquire(std::max(scene3DRenderer->m_allowRendering.available(), 1)))

        return;

    // In the case of OnDemand rendering, we still need to get to this

    // point to ensure we have processed jobs for all aspects.

    // We also still need to call render() to allow proceeding with the

    // next frame. However it won't be performing any 3d rendering at all

    // so we do it here and return early. This prevents a costly QtQuick

    // SceneGraph update for nothing

    if (scene3DRenderer->m_skipFrame) {

        scene3DRenderer->m_skipFrame = false;

        ContextSaver saver;

        m_renderer->render(false);

        return;

    scene3DRenderer->m_shouldRender = true;

    m_multisample = scene3DRenderer->multisample();

    const QSize boundingRectSize = scene3DRenderer->boundingSize();

    const QSize currentSize = boundingRectSize * window->effectiveDevicePixelRatio();

    const bool sizeHasChanged = currentSize != m_lastSize;

    const bool multisampleHasChanged = m_multisample != m_lastMultisample;

    const bool forceRecreate = sizeHasChanged || multisampleHasChanged;

    // Store the current size as a comparison

    // point for the next frame

    m_lastSize = currentSize;

    m_lastMultisample = m_multisample;

    // Rebuild FBO if size/multisampling has changed

    const bool usesFBO = scene3DRenderer->m_compositingMode == Scene3DItem::FBO;

    auto node = scene3DRenderer->m_node;

    if (node == nullptr) {

        node = new Scene3DSGNode();

        scene3DRenderer->m_node = node;

    if (usesFBO) {

        // Rebuild FBO and textures if never created or a resize has occurred

        if ((m_multisampledFBO.isNull() || forceRecreate) && m_multisample) {

            m_multisampledFBO.reset(createMultisampledFramebufferObject(m_lastSize));

            if (m_multisampledFBO->format().samples() == 0 || !QOpenGLFramebufferObject::hasOpenGLFramebufferBlit()) {

                m_multisample = false;

                m_multisampledFBO.reset(nullptr);

        const bool generateNewTexture = m_finalFBO.isNull() || forceRecreate;

        if (generateNewTexture) {

            m_finalFBO.reset(createFramebufferObject(m_lastSize));

            m_textureId = m_finalFBO->texture();

            m_texture.reset(QNativeInterface::QSGOpenGLTexture::fromNative(m_textureId, window, m_finalFBO->size(), QQuickWindow::TextureHasAlphaChannel));

        // Set texture on node

        if (!node->texture() || generateNewTexture)

            node->setTexture(m_texture.data());

    // Mark SGNodes as dirty so that QQuick will trigger some rendering

    if (node)

        node->markDirty(QSGNode::DirtyMaterial);

void Scene3DRenderer::GLRenderer::beforeRendering(Scene3DRenderer *scene3DRenderer)

    Q_UNUSED(scene3DRenderer);

void Scene3DRenderer::GLRenderer::beforeRenderPassRecording(Scene3DRenderer *scene3DRenderer)

    // When this is fired, beforeRendering was fired and the RenderPass for QtQuick was

    // started -> meaning the window was cleared but actual draw commands have yet to be

    // recorded.

    // When using the GL Renderer and FBO, that's the state we want to be in.

    QMutexLocker l(&scene3DRenderer->m_windowMutex);

    // Lock to ensure the window doesn't change while we are rendering

    if (!scene3DRenderer->m_window || !scene3DRenderer->m_shouldRender)

        return;

    // Reset flag for next frame

    scene3DRenderer->m_shouldRender = false;

    ContextSaver saver;

    // Create and bind FBO if using the FBO compositing mode

    const bool usesFBO = scene3DRenderer->m_compositingMode == Scene3DItem::FBO;

    if (usesFBO) {

        // Bind FBO

        if (m_multisample) //Only try to use MSAA when available

            m_multisampledFBO->bind();

        else

            m_finalFBO->bind();

    // Render Qt3D Scene

    // Qt3D takes care of resetting the GL state to default values

    m_renderer->render(usesFBO);

    // We may have called doneCurrent() so restore the context if the rendering surface was changed

    // Note: keep in mind that the ContextSave also restores the surface when destroyed

    if (saver.context()->surface() != saver.surface())

        saver.context()->makeCurrent(saver.surface());

    if (usesFBO) {

        if (m_multisample) {

            // Blit multisampled FBO with non multisampled FBO with texture attachment

            const QRect dstRect(QPoint(0, 0), m_finalFBO->size());

            const QRect srcRect(QPoint(0, 0), m_multisampledFBO->size());

            QOpenGLFramebufferObject::blitFramebuffer(m_finalFBO.data(), dstRect,

                                                      m_multisampledFBO.data(), srcRect,

                                                      GL_COLOR_BUFFER_BIT,

                                                      GL_NEAREST,

                                                      0, 0,

                                                      QOpenGLFramebufferObject::DontRestoreFramebufferBinding);

        // Restore QtQuick FBO

        QOpenGLFramebufferObject::bindDefault();

        // Only show the node once Qt3D has rendered to it

        // Avoids showing garbage on the first frame

        if (scene3DRenderer->m_node)

            scene3DRenderer->m_node->show();

void Scene3DRenderer::GLRenderer::shutdown(Scene3DRenderer *sceneRenderer)

    // Shutdown the Renderer Aspect while the OpenGL context

    // is still valid

    if (sceneRenderer->m_renderAspect)

        m_renderer->shutdown();

    m_finalFBO.reset();

    m_multisampledFBO.reset();

void Scene3DRenderer::RHIRenderer::initialize(Scene3DRenderer *scene3DRenderer,

                                              Qt3DRender::Render::AbstractRenderer *renderer)

    QQuickWindow *window = scene3DRenderer->m_window;

    Q_ASSERT(window);

    Q_ASSERT(renderer->api() == API::RHI);

    // Retrieve RHI context

    QSGRendererInterface *rif = window->rendererInterface();

    const bool isRhi = QSGRendererInterface::isApiRhiBased(rif->graphicsApi());

    Q_ASSERT(isRhi);

    if (isRhi) {

        m_rhi = static_cast<QRhi *>(rif->getResource(window, QSGRendererInterface::RhiResource));

        if (!m_rhi)

            qFatal("No QRhi from QQuickWindow, this cannot happen");

        m_renderer = renderer;

        m_renderer->setRenderDriver(Qt3DRender::Render::AbstractRenderer::Scene3D);

        m_renderer->setRHIContext(m_rhi);

        m_renderer->initialize();

void Scene3DRenderer::RHIRenderer::beforeSynchronize(Scene3DRenderer *scene3DRenderer)

    // Check size / multisampling

    QQuickWindow *window = scene3DRenderer->m_window;

    if (!window)

        return;

    // Only render if we are sure aspectManager->processFrame was called prior

    // We could otherwise enter a deadlock state

    if (!scene3DRenderer->m_allowRendering.tryAcquire(std::max(scene3DRenderer->m_allowRendering.available(), 1)))

        return;

    // In the case of OnDemand rendering, we still need to get to this

    // point to ensure we have processed jobs for all aspects.

    // We also still need to call render() to allow proceeding with the

    // next frame. However it won't be performing any 3d rendering at all

    // so we do it here and return early. This prevents a costly QtQuick

    // SceneGraph update for nothing

    if (scene3DRenderer->m_skipFrame) {

        scene3DRenderer->m_skipFrame = false;

        m_renderer->render(false);

        return;

    scene3DRenderer->m_shouldRender = true;

    const QSize boundingRectSize = scene3DRenderer->boundingSize();

    const QSize currentSize = boundingRectSize * window->effectiveDevicePixelRatio();

    const bool sizeHasChanged = currentSize != m_lastSize;

    const bool multisampleHasChanged = scene3DRenderer->multisample() != m_lastMultisample;

    // Store the current size and multisample as a comparison point for the next frame

    m_lastMultisample = scene3DRenderer->multisample();

    m_lastSize = currentSize;

    const bool forceRecreate = sizeHasChanged || multisampleHasChanged;

    const bool usesFBO = scene3DRenderer->m_compositingMode == Scene3DItem::FBO;

    // Not sure how we could support underlay rendering properly given Qt3D RHI will render into its own

    // RHI RenderPasses prior to QtQuick and beginning a new RenderPass clears the screen

    Q_ASSERT(usesFBO);

    const bool generateNewTexture = m_texture.isNull() || forceRecreate;

    const int samples = m_lastMultisample ? 4 : 1;

    if (generateNewTexture) {

        releaseRHIResources();

        // Depth / Stencil

        m_rhiDepthRenderBuffer = m_rhi->newRenderBuffer(QRhiRenderBuffer::DepthStencil, m_lastSize, samples);

        m_rhiDepthRenderBuffer->create();

        // Color Attachment or Color Resolutin texture (if using MSAA)

        m_rhiTexture = m_rhi->newTexture(QRhiTexture::RGBA8, m_lastSize, 1, QRhiTexture::RenderTarget|QRhiTexture::UsedAsTransferSource);

        m_rhiTexture->create();

        // Color Attachment description

        QRhiTextureRenderTargetDescription renderTargetDesc;

        renderTargetDesc.setDepthStencilBuffer(m_rhiDepthRenderBuffer);

        if (samples > 1) {

            m_rhiMSAARenderBuffer = m_rhi->newRenderBuffer(QRhiRenderBuffer::Color, m_lastSize, samples, {}, m_rhiTexture->format());

            m_rhiMSAARenderBuffer->create();

            QRhiColorAttachment att;

            att.setRenderBuffer(m_rhiMSAARenderBuffer);

            att.setResolveTexture(m_rhiTexture);

            renderTargetDesc.setColorAttachments({ att });

        } else {

            renderTargetDesc.setColorAttachments({ m_rhiTexture });

        m_rhiRenderTarget = m_rhi->newTextureRenderTarget(renderTargetDesc);

        m_rhiRenderTargetPassDescriptor = m_rhiRenderTarget->newCompatibleRenderPassDescriptor();

        m_rhiRenderTarget->setRenderPassDescriptor(m_rhiRenderTargetPassDescriptor);

        m_rhiRenderTarget->create();

        // Create QSGTexture from QRhiTexture

        auto *windowPriv = QQuickWindowPrivate::get(window);

        m_texture.reset(windowPriv->createTextureFromNativeTexture(m_rhiTexture->nativeTexture().object,

                                                                   0, m_lastSize, QQuickWindow::TextureHasAlphaChannel));

        // Set the Default RenderTarget to use on the RHI Renderer

        // Note: this will release all pipelines using previousRenderTarget

        m_renderer->setDefaultRHIRenderTarget(m_rhiRenderTarget);

    Scene3DSGNode *node = scene3DRenderer->m_node;

    if (node == nullptr) {

        node = new Scene3DSGNode();

        scene3DRenderer->m_node = node;

    // Set texture on node

    if (!node->texture() || generateNewTexture)

        node->setTexture(m_texture.data());

    // Mark SGNodes as dirty so that QQuick will trigger some rendering

    node->markDirty(QSGNode::DirtyMaterial);

void Scene3DRenderer::RHIRenderer::beforeRendering(Scene3DRenderer *scene3DRenderer)

    // This is fired before QtQuick starts its RenderPass but after a RHI Command Buffer

    // has been created and after the RHI Frame has begun

    // This means the swap chain has been set up and that we only need to record commands

    // On the Qt3D side this also means we shouldn't be calling m_rhi->beginFrame/endFrame

    // and we should only be rendering using the provided swap chain

    // Therefore, if a QRenderSurfaceSelector is used in the FrameGraph to render to another surface,

    // this will not be supported with Scene3D/RHI

    QMutexLocker l(&scene3DRenderer->m_windowMutex);

    // Lock to ensure the window doesn't change while we are rendering

    if (!scene3DRenderer->m_window || !scene3DRenderer->m_shouldRender)

        return;

    // Reset flag for next frame

    scene3DRenderer->m_shouldRender = false;

    // TO DO: We need to check what we do about 3DViews and Composition Mode as those are not

    // directly applicable with RHI

    // Retrieve Command Buffer used by QtQuick

    QRhiCommandBuffer *cb = nullptr;

    QSGRendererInterface *rif = scene3DRenderer->m_window ->rendererInterface();

    QRhiSwapChain *swapchain = static_cast<QRhiSwapChain *>(rif->getResource(scene3DRenderer->m_window, QSGRendererInterface::RhiSwapchainResource));

    if (swapchain) {

        cb = swapchain->currentFrameCommandBuffer();

    } else {

        cb = static_cast<QRhiCommandBuffer *>(rif->getResource(scene3DRenderer->m_window, QSGRendererInterface::RhiRedirectCommandBuffer));

    Q_ASSERT(cb);

    // Tell Qt3D renderer to use provided command buffer

    m_renderer->setRHICommandBuffer(cb);

    m_renderer->render(false);

    // Only show the node once Qt3D has rendered to it

    // Avoids showing garbage on the first frame

    if (scene3DRenderer->m_node)

        scene3DRenderer->m_node->show();

void Scene3DRenderer::RHIRenderer::beforeRenderPassRecording(Scene3DRenderer *scene3DRenderer)

    Q_UNUSED(scene3DRenderer);

void Scene3DRenderer::RHIRenderer::shutdown(Scene3DRenderer *scene3DRenderer)

    if (scene3DRenderer->m_renderAspect)

        m_renderer->shutdown();

    releaseRHIResources();

bool Scene3DRenderer::RHIRenderer::isYUp() const

    return m_rhi->isYUpInFramebuffer();

void Scene3DRenderer::RHIRenderer::releaseRHIResources()

    delete m_rhiRenderTarget;

    m_rhiRenderTarget = nullptr;

    delete m_rhiTexture;

    m_rhiTexture = nullptr;

    delete m_rhiDepthRenderBuffer;

    m_rhiDepthRenderBuffer = nullptr;

    delete m_rhiMSAARenderBuffer;

    m_rhiMSAARenderBuffer = nullptr;

    delete m_rhiColorRenderBuffer;

    m_rhiColorRenderBuffer = nullptr;

    delete m_rhiRenderTargetPassDescriptor;

    m_rhiRenderTargetPassDescriptor = nullptr;

Scene3DRenderer::QuickRenderer::QuickRenderer() {}

Scene3DRenderer::QuickRenderer::~QuickRenderer() {}

} // namespace Qt3DRender

QT_END_NAMESPACE

#include "moc_scene3drenderer_p.cpp"