scene3drenderer.cpp

++ // 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"

Revision control