Revision control
Copy as Markdown
// Copyright (C) 2015 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 "scene3ditem_p.h"
#include <Qt3DCore/qt3dcore_global.h>
#include <Qt3DCore/qentity.h>
#include <Qt3DCore/QAspectEngine>
#if QT_CONFIG(qt3d_input)
#include <Qt3DInput/QInputAspect>
#include <Qt3DInput/qinputsettings.h>
#endif
#if QT_CONFIG(qt3d_logic)
#include <Qt3DLogic/qlogicaspect.h>
#endif
#if QT_CONFIG(qt3d_animation)
#include <Qt3DAnimation/qanimationaspect.h>
#endif
#include <Qt3DRender/QRenderAspect>
#include <Qt3DRender/qcamera.h>
#include <Qt3DRender/qrendersurfaceselector.h>
#include <QtGui/qguiapplication.h>
#include <QtGui/qoffscreensurface.h>
#include <QtQml/private/qqmlglobal_p.h>
#include <QtQuick/qquickwindow.h>
#include <QtQuick/qquickrendercontrol.h>
#include <Qt3DRender/private/qrendersurfaceselector_p.h>
#include <Qt3DRender/private/qrenderaspect_p.h>
#include <Qt3DRender/private/rendersettings_p.h>
#include <Qt3DRender/qt3drender-config.h>
#include <scene3dlogging_p.h>
#include <scene3drenderer_p.h>
#include <scene3dsgnode_p.h>
#include <Qt3DCore/private/qaspectengine_p.h>
#include <Qt3DCore/private/qaspectmanager_p.h>
#include <QThread>
QT_BEGIN_NAMESPACE
namespace Qt3DRender {
class AspectEngineDestroyer : public QObject
{
Q_OBJECT
public:
AspectEngineDestroyer()
: QObject()
{}
~AspectEngineDestroyer()
{
}
void reset(int targetCount)
{
m_allowed = 0;
m_targetAllowed = targetCount;
}
void allowRelease()
{
++m_allowed;
if (m_allowed == m_targetAllowed) {
if (QThread::currentThread() == thread())
delete this;
else
deleteLater();
}
}
void setSGNodeAlive(bool alive) { m_sgNodeAlive = alive; }
bool sgNodeAlive() const { return m_sgNodeAlive;}
private:
int m_allowed = 0;
int m_targetAllowed = 0;
bool m_sgNodeAlive = false;
};
/*!
\class Qt3DRender::Scene3DItem
\internal
\brief The Scene3DItem class is a QQuickItem subclass used to integrate
a Qt3D scene into a QtQuick 2 scene.
The Scene3DItem class renders a Qt3D scene, provided by a Qt3DCore::QEntity
into a multisampled Framebuffer object that is later blitted into a
non-multisampled Framebuffer object to be then rendered through the use of a
Qt3DCore::Scene3DSGNode with premultiplied alpha.
*/
/*!
\qmltype Scene3D
\inherits Item
\inqmlmodule QtQuick.Scene3D
\preliminary
\brief The Scene3D type is used to integrate a Qt3D scene into a QtQuick 2
scene.
The Scene3D type renders a Qt3D scene, provided by an \l Entity, into a
multisampled Framebuffer object. This object is later blitted into a
non-multisampled Framebuffer object, which is then rendered with
premultiplied alpha. If multisampling is not required, it can be avoided
by setting the \l multisample property to \c false. In this case
Scene3D will render directly into the non-multisampled Framebuffer object.
If the scene to be rendered includes non-opaque materials, you may need to
modify those materials with custom blend arguments in order for them to be
rendered correctly. For example, if working with a \l PhongAlphaMaterial and
a scene with an opaque clear color, you will likely want to add:
\qml
sourceAlphaArg: BlendEquationArguments.Zero
destinationAlphaArg: BlendEquationArguments.One
\endqml
to that material.
It is not recommended to instantiate more than a single Scene3D instance
per application. The reason for this is that a Scene3D instance
instantiates the entire Qt 3D engine (for example, memory managers,
thread pool, render) under the scene.
\note Setting the visibility of the Scene3D element to false will halt the
Qt 3D simulation loop. This means that binding the visible property to an
expression that depends on property updates driven by the Qt 3D simulation
loop (FrameAction) will never reevaluate.
*/
Scene3DItem::Scene3DItem(QQuickItem *parent)
: QQuickItem(parent)
, m_entity(nullptr)
, m_aspectEngine(nullptr)
, m_aspectToDelete(nullptr)
, m_lastManagerNode(nullptr)
, m_aspectEngineDestroyer()
, m_multisample(true)
, m_dirty(true)
, m_wasFrameProcessed(false)
, m_wasSGUpdated(false)
, m_cameraAspectRatioMode(AutomaticAspectRatio)
, m_compositingMode(FBO)
, m_framesToRender(ms_framesNeededToFlushPipeline)
{
setFlag(QQuickItem::ItemHasContents, true);
setAcceptedMouseButtons(Qt::MouseButtonMask);
setAcceptHoverEvents(true);
// TO DO: register the event source in the main thread
// Give a default size so that if nothing is specified by the user
// we still won't get ignored by the QtQuick SG when in Underlay mode
setWidth(1);
setHeight(1);
if (qgetenv("QT3D_RENDERER").isEmpty()) {
#if QT_CONFIG(qt3d_rhi_renderer)
qputenv("QT3D_RENDERER", "rhi"); // QtQuick requires RHI
#else
qputenv("QT3D_RENDERER", "opengl"); // QtQuick requires OpenGL
#endif
}
}
Scene3DItem::~Scene3DItem()
{
// The SceneGraph is non deterministic in the order in which it will
// destroy the QSGNode that were created by the item. This unfortunately
// makes it difficult to know when it is safe to destroy the QAspectEngine.
// To track this we use the AspectEngineDestroyer. It allows keeping the
// AspectEngine alive and deleting later when we know that both Scene3DItem
// and Scene3DRenderer have been destroyed.
delete m_aspectToDelete;
if (m_aspectEngineDestroyer)
m_aspectEngineDestroyer->allowRelease();
}
/*!
\qmlproperty list<string> Scene3D::aspects
The list of aspects that should be registered for the 3D scene.
For example, if the scene makes use of FrameAction, the \c "logic" aspect should be included in the list.
The \c "render" aspect is hardwired and does not need to be explicitly listed.
*/
QStringList Scene3DItem::aspects() const
{
return m_aspects;
}
/*!
\qmlproperty Entity Scene3D::entity
\qmldefault
The root entity of the 3D scene to be displayed.
*/
Qt3DCore::QEntity *Scene3DItem::entity() const
{
return m_entity;
}
void Scene3DItem::applyAspects()
{
if (!m_aspectEngine)
return;
// Aspects are owned by the aspect engine
for (const QString &aspect : std::as_const(m_aspects)) {
if (aspect == QLatin1String("render")) // This one is hardwired anyway
continue;
if (aspect == QLatin1String("input")) {
#if QT_CONFIG(qt3d_input)
m_aspectEngine->registerAspect(new Qt3DInput::QInputAspect);
continue;
#else
qFatal("Scene3D requested the Qt 3D input aspect but Qt 3D wasn't configured to build the Qt 3D Input aspect");
#endif
}
if (aspect == QLatin1String("logic")) {
#if QT_CONFIG(qt3d_logic)
m_aspectEngine->registerAspect(new Qt3DLogic::QLogicAspect);
continue;
#else
qFatal("Scene3D requested the Qt 3D logic aspect but Qt 3D wasn't configured to build the Qt 3D Logic aspect");
#endif
}
if (aspect == QLatin1String("animation")) {
#if QT_CONFIG(qt3d_animation)
m_aspectEngine->registerAspect(new Qt3DAnimation::QAnimationAspect);
continue;
#else
qFatal("Scene3D requested the Qt 3D animation aspect but Qt 3D wasn't configured to build the Qt 3D Animation aspect");
#endif
}
m_aspectEngine->registerAspect(aspect);
}
}
void Scene3DItem::setAspects(const QStringList &aspects)
{
if (!m_aspects.isEmpty()) {
qWarning() << "Aspects already set on the Scene3D, ignoring";
return;
}
m_aspects = aspects;
applyAspects();
emit aspectsChanged();
}
void Scene3DItem::setEntity(Qt3DCore::QEntity *entity)
{
if (entity == m_entity)
return;
m_entity = entity;
emit entityChanged();
}
void Scene3DItem::setCameraAspectRatioMode(CameraAspectRatioMode mode)
{
if (m_cameraAspectRatioMode == mode)
return;
m_cameraAspectRatioMode = mode;
setCameraAspectModeHelper();
emit cameraAspectRatioModeChanged(mode);
}
void Scene3DItem::setHoverEnabled(bool enabled)
{
if (enabled != acceptHoverEvents()) {
setAcceptHoverEvents(enabled);
emit hoverEnabledChanged();
}
}
/*!
\qmlproperty enumeration Scene3D::compositingMode
\value FBO
Scene is rendered into a Frame Buffer Object which can be costly on
some platform and hardware but allows a greater amount of
flexibility. Automatic aspect ratio. This is the compositing mode to
choose if your Scene3D element shouldn't occupy the entire screen
and if you optionally plan on having it resized or animated. In this
mode, the position of the Scene3D in the QML file controls its
stacking order with regard to the other Qt Quick elements.
\value Underlay
Suitable for full screen 3D scenes where using an FBO might be too
resource intensive. Scene3D behaves as a QtQuick underlay.
Please note that when using this mode, the size of the Scene3D and
its transformations are ignored and the rendering will occupy the
whole screen. The position of the Scene3D in the QML file won't have
any effect either. The Qt 3D content will be drawn prior to any Qt
Quick content. Care has to be taken not to overdraw and hide the Qt
3D content by overlapping Qt Quick content.
Additionally when using this mode, the window clearBeforeRendering
will be set to false automatically.
The default value is \c FBO.
\since 5.14
*/
void Scene3DItem::setCompositingMode(Scene3DItem::CompositingMode mode)
{
if (m_compositingMode == mode)
return;
m_compositingMode = mode;
emit compositingModeChanged();
QQuickItem::update();
}
/*!
\qmlproperty enumeration Scene3D::cameraAspectRatioMode
Defines how the aspect ratio of a camera found in the scene is computed.
\value Scene3D.AutomaticAspectRatio
Automatic aspect ratio.
\value Scene3D.UserAspectRatio
User defined aspect ratio.
*/
Scene3DItem::CameraAspectRatioMode Scene3DItem::cameraAspectRatioMode() const
{
return m_cameraAspectRatioMode;
}
Scene3DItem::CompositingMode Scene3DItem::compositingMode() const
{
return m_compositingMode;
}
void Scene3DItem::applyRootEntityChange()
{
if (m_aspectEngine->rootEntity().data() != m_entity) {
Qt3DCore::QEntityPtr entityPtr;
// We must reuse the QEntityPtr of the old AspectEngine
// otherwise it will delete the Entity once it gets destroyed
if (m_aspectToDelete)
entityPtr = m_aspectToDelete->rootEntity();
else
entityPtr = Qt3DCore::QEntityPtr(m_entity);
m_aspectEngine->setRootEntity(entityPtr);
/* If we changed window, the old aspect engine must be deleted only after we have set
the root entity for the new one so that it doesn't delete the root node. */
if (m_aspectToDelete) {
delete m_aspectToDelete;
m_aspectToDelete = nullptr;
}
// Set the render surface
if (!m_entity)
return;
setWindowSurface(entity());
if (m_cameraAspectRatioMode == AutomaticAspectRatio) {
// Set aspect ratio of first camera to match the window
QList<Qt3DRender::QCamera *> cameras
= m_entity->findChildren<Qt3DRender::QCamera *>();
if (cameras.isEmpty()) {
qCDebug(Scene3D) << "No camera found and automatic aspect ratio requested";
} else {
m_camera = cameras.first();
setCameraAspectModeHelper();
}
}
#if QT_CONFIG(qt3d_input)
// Set ourselves up as a source of input events for the input aspect
Qt3DInput::QInputSettings *inputSettings = m_entity->findChild<Qt3DInput::QInputSettings *>();
if (inputSettings) {
inputSettings->setEventSource(this);
} else {
qCDebug(Scene3D) << "No Input Settings found, keyboard and mouse events won't be handled";
}
#endif
}
}
bool Scene3DItem::needsRender(QRenderAspect *renderAspect)
{
// We need the dirty flag which is connected to the change arbiter
// receiving updates to know whether something in the scene has changed
// Ideally we would use shouldRender() alone but given that it becomes true
// only after the arbiter has sync the changes and might be reset before
// process jobs is completed, we cannot fully rely on it. It would require
// splitting processFrame in 2 parts.
// We only use it for cases where Qt3D render may require several loops of
// the simulation to fully process a frame (e.g shaders are loaded in frame
// n and we can only build render commands for the new shader at frame n +
// This is where renderer->shouldRender() comes into play as it knows
// whether some states remain dirty or not (even after processFrame is
// called)
auto renderAspectPriv = static_cast<QRenderAspectPrivate*>(QRenderAspectPrivate::get(renderAspect));
const bool dirty = m_dirty
|| (renderAspectPriv
&& renderAspectPriv->m_renderer
&& renderAspectPriv->m_renderer->shouldRender());
if (m_dirty) {
--m_framesToRender;
if (m_framesToRender <= 0)
m_dirty = false;
}
return dirty || m_framesToRender > 0;
}
// This function is triggered in the context of the Main Thread
// when afterAnimating is emitted
// The QtQuick SG proceeds like indicated below:
// afterAnimating (Main Thread)
// beforeSynchronizing (SG Thread and MainThread locked)
// afterSynchronizing (SG Thread and MainThread locked)
// beforeRendering (SG Thread)
// Note: we connect to afterAnimating rather than beforeSynchronizing as a
// direct connection on beforeSynchronizing is executed within the SG Render
// Thread context. This is executed before the RenderThread is asked to
// synchronize and render
// Note: we might still not be done rendering when this is called but
// processFrame will block and wait for renderer to have been finished
bool Scene3DItem::prepareQt3DFrame()
{
static bool dontRenderWhenHidden = !qgetenv("QT3D_SCENE3D_STOP_RENDER_HIDDEN").isEmpty();
// If we are not visible, don't processFrame changes as we would end up
// waiting forever for the scene to be rendered which won't happen
// if the Scene3D item is not visible
if (!isVisible() && dontRenderWhenHidden)
return false;
if (!m_aspectEngine)
return false;
Q_ASSERT(QThread::currentThread() == thread());
// Since we are in manual mode, trigger jobs for the next frame
Qt3DCore::QAspectEnginePrivate *aspectEnginePriv = static_cast<Qt3DCore::QAspectEnginePrivate *>(QObjectPrivate::get(m_aspectEngine));
if (!aspectEnginePriv->m_initialized)
return false;
Q_ASSERT(m_aspectEngine->runMode() == Qt3DCore::QAspectEngine::Manual);
m_aspectEngine->processFrame();
// The above essentially sets the number of RV for the RenderQueue and
// processes the jobs for the frame (it's blocking) When
// Scene3DRender::updatePaintNode is called, following this step, we know
// that the RenderQueue target count has been set and that everything
// should be ready for rendering
// processFrame() must absolutely be followed by a single call to
// render
// At startup, we have no garantee that the QtQuick Render Thread doesn't
// start rendering before this function has been called
// We add in a safety to skip such frames as this could otherwise
// make Qt3D enter a locked state
// Note: it's too early to request an update at this point as
// beforeSync() triggered by afterAnimating is considered
// to be as being part of the current frame update
return true;
}
void Scene3DItem::requestUpdate()
{
// When using the FBO mode, only the QQuickItem needs to be updated
// When using the Underlay mode, the whole windows needs updating
const bool usesFBO = m_compositingMode == FBO;
if (usesFBO) {
QQuickItem::update();
} else {
window()->update();
}
}
void Scene3DItem::updateWindowSurface()
{
if (!m_entity)
return;
Qt3DRender::QRenderSurfaceSelector *surfaceSelector =
Qt3DRender::QRenderSurfaceSelectorPrivate::find(entity());
if (surfaceSelector) {
if (QWindow *rw = QQuickRenderControl::renderWindowFor(this->window())) {
surfaceSelector->setSurface(rw);
}
}
}
void Scene3DItem::setWindowSurface(QObject *rootObject)
{
Qt3DRender::QRenderSurfaceSelector *surfaceSelector = Qt3DRender::QRenderSurfaceSelectorPrivate::find(rootObject);
// Set the item's window surface if it appears
// the surface wasn't set on the surfaceSelector
if (surfaceSelector && !surfaceSelector->surface()) {
// We may not have a real, exposed QQuickWindow when the Quick rendering
// is redirected via QQuickRenderControl (f.ex. QQuickWidget).
if (QWindow *rw = QQuickRenderControl::renderWindowFor(this->window())) {
surfaceSelector->setSurface(rw);
} else {
surfaceSelector->setSurface(this->window());
}
}
}
/*!
\qmlmethod void Scene3D::setItemAreaAndDevicePixelRatio(size area, real devicePixelRatio)
Sets the item area to \a area and the pixel ratio to \a devicePixelRatio.
*/
void Scene3DItem::setItemAreaAndDevicePixelRatio(QSize area, qreal devicePixelRatio)
{
Qt3DCore::QEntity *rootEntity = entity();
if (!rootEntity) {
return;
}
Qt3DRender::QRenderSurfaceSelector *surfaceSelector = Qt3DRender::QRenderSurfaceSelectorPrivate::find(rootEntity);
if (surfaceSelector) {
surfaceSelector->setExternalRenderTargetSize(area);
surfaceSelector->setSurfacePixelRatio(devicePixelRatio);
}
}
/*!
\qmlproperty bool Scene3D::hoverEnabled
\c true if hover events are accepted.
*/
bool Scene3DItem::isHoverEnabled() const
{
return acceptHoverEvents();
}
void Scene3DItem::setCameraAspectModeHelper()
{
if (m_compositingMode == FBO) {
switch (m_cameraAspectRatioMode) {
case AutomaticAspectRatio:
connect(this, &Scene3DItem::widthChanged, this, &Scene3DItem::updateCameraAspectRatio);
connect(this, &Scene3DItem::heightChanged, this, &Scene3DItem::updateCameraAspectRatio);
// Update the aspect ratio the first time the surface is set
updateCameraAspectRatio();
break;
case UserAspectRatio:
disconnect(this, &Scene3DItem::widthChanged, this, &Scene3DItem::updateCameraAspectRatio);
disconnect(this, &Scene3DItem::heightChanged, this, &Scene3DItem::updateCameraAspectRatio);
break;
}
} else {
// In Underlay mode, we rely on the window for aspect ratio and not the size of the Scene3DItem
switch (m_cameraAspectRatioMode) {
case AutomaticAspectRatio:
connect(window(), &QWindow::widthChanged, this, &Scene3DItem::updateCameraAspectRatio);
connect(window(), &QWindow::heightChanged, this, &Scene3DItem::updateCameraAspectRatio);
// Update the aspect ratio the first time the surface is set
updateCameraAspectRatio();
break;
case UserAspectRatio:
disconnect(window(), &QWindow::widthChanged, this, &Scene3DItem::updateCameraAspectRatio);
disconnect(window(), &QWindow::heightChanged, this, &Scene3DItem::updateCameraAspectRatio);
break;
}
}
}
void Scene3DItem::updateCameraAspectRatio()
{
if (m_camera) {
if (m_compositingMode == FBO)
m_camera->setAspectRatio(static_cast<float>(width()) /
static_cast<float>(height()));
else
m_camera->setAspectRatio(static_cast<float>(window()->width()) /
static_cast<float>(window()->height()));
}
}
/*!
\qmlproperty bool Scene3D::multisample
\c true if a multisample render buffer is requested.
By default multisampling is enabled. If the OpenGL implementation has no
support for multisample renderbuffers or framebuffer blits, the request to
use multisampling is ignored.
\note Refrain from changing the value frequently as it involves expensive
and potentially slow initialization of framebuffers and other OpenGL
resources.
*/
bool Scene3DItem::multisample() const
{
return m_multisample;
}
void Scene3DItem::setMultisample(bool enable)
{
if (m_multisample != enable) {
m_multisample = enable;
emit multisampleChanged();
update();
}
}
// We want to tie the Scene3DRenderer's lifetime to the QSGNode associated with
// Scene3DItem. This ensures that when the SceneGraph tree gets destroyed, we
// also shutdown Qt3D properly
// Everything this class does happens in the QSGRenderThread
class Scene3DManagerNode : public QSGNode
{
public:
explicit Scene3DManagerNode(Qt3DCore::QAspectEngine *aspectEngine,
AspectEngineDestroyer *destroyer)
: m_aspectEngine(aspectEngine)
, m_destroyer(destroyer)
, m_renderAspect(new QRenderAspect(QRenderAspect::Manual))
, m_renderer(new Scene3DRenderer())
{
m_destroyer->setSGNodeAlive(true);
}
~Scene3DManagerNode()
{
// Stop the Qt3D Simulation Loop
auto engineD = Qt3DCore::QAspectEnginePrivate::get(m_aspectEngine);
engineD->exitSimulationLoop();
// Shutdown renderer
delete m_renderer;
m_destroyer->setSGNodeAlive(false);
// Allow AspectEngine destruction
m_destroyer->allowRelease();
}
void init()
{
m_aspectEngine->registerAspect(m_renderAspect);
m_renderer->init(m_aspectEngine, m_renderAspect);
m_wasInitialized = true;
}
inline bool isInitialized() const { return m_wasInitialized; }
inline QRenderAspect *renderAspect() const { return m_renderAspect; }
inline Scene3DRenderer *renderer() const { return m_renderer; }
private:
Qt3DCore::QAspectEngine *m_aspectEngine;
AspectEngineDestroyer *m_destroyer;
QRenderAspect *m_renderAspect;
Scene3DRenderer *m_renderer;
bool m_wasInitialized = false;
};
// QtQuick SG
// beforeSynchronize // SG Thread (main thread blocked)
// updatePaintNode (-> Scene3DRenderer::beforeSynchronize) // SG Thread (main thread blocked)
// beforeRenderering (-> Scene3DRenderer::beforeSynchronize) // SG Thread (main thread unblocked)
// afterRenderering // SG Thread (main thread unblocked)
// afterAnimating (-> Scene3DItem::synchronize()) // Main Thread (SG Thread is not yet at beforeSynchronize )
// main thread (afterAnimating)
void Scene3DItem::synchronize()
{
// Request updates for the next frame
requestUpdate();
if (!window() || !m_wasSGUpdated ||
(!m_aspectEngineDestroyer || !m_aspectEngineDestroyer->sgNodeAlive())) {
m_wasFrameProcessed = false;
return;
}
// Set root Entity on the aspectEngine
applyRootEntityChange();
// Update size of the QSurfaceSelector if needed
setItemAreaAndDevicePixelRatio(boundingRect().size().toSize(),
window()->effectiveDevicePixelRatio());
// Let Qt3D process the frame and launch jobs
m_wasFrameProcessed = prepareQt3DFrame();
m_wasSGUpdated = false;
}
// The synchronization point between the main thread and the render thread
// before any rendering
QSGNode *Scene3DItem::updatePaintNode(QSGNode *node, QQuickItem::UpdatePaintNodeData *)
{
Scene3DManagerNode *managerNode = static_cast<Scene3DManagerNode *>(node);
QSGRendererInterface::GraphicsApi windowApi = window()->rendererInterface()->graphicsApi();
// In case we have no GL context, return early
// m_wasSGUpdated will not be set to true and nothing will take place
if ((windowApi == QSGRendererInterface::OpenGLRhi ||
windowApi == QSGRendererInterface::OpenGL) && !QOpenGLContext::currentContext()) {
QQuickItem::update();
return node;
}
// Scene3DManagerNode gets automatically destroyed on Window changed, SceneGraph invalidation
if (!managerNode) {
// Did we have a Scene3DManagerNode in the past?
if (m_lastManagerNode != nullptr) {
// If so we need to recreate a new AspectEngine as node was destroyed by sceneGraph
qCWarning(Scene3D) << "Renderer for Scene3DItem has requested a reset due to the item "
"moving to another window";
QObject::disconnect(m_windowConnection);
// We are in the Render thread, and the m_aspectEngineDestroyer lives in the Main
// thread, so we must avoid sending ChildRemoved or ChildAdded events to it with a
// QObject::setParent(). QCoreApplication::sendEvent() would fail with "Cannot
// send events to objects owned by a different thread."
QQml_setParent_noEvent(m_aspectEngine, nullptr);
// Note: AspectEngine can only be deleted once we have set the root
// entity on the new instance
m_aspectToDelete = m_aspectEngine;
m_aspectEngine = nullptr;
}
// Create or Recreate AspectEngine
if (m_aspectEngine == nullptr) {
// Use manual drive mode when using Scene3D
delete m_aspectEngineDestroyer;
m_aspectEngineDestroyer = new AspectEngineDestroyer();
m_aspectEngine = new Qt3DCore::QAspectEngine(m_aspectEngineDestroyer);
m_aspectEngine->setRunMode(Qt3DCore::QAspectEngine::Manual);
applyAspects();
// Needs to belong in the same thread as the item which is the same as
// the original QAspectEngine
m_aspectEngineDestroyer->moveToThread(thread());
m_aspectEngine->moveToThread(thread());
// To destroy AspectEngine
m_aspectEngineDestroyer->reset(2);
}
// Create new instance and record a pointer (which should only be used
// to check if we have had a previous manager node)
managerNode = new Scene3DManagerNode(m_aspectEngine,
m_aspectEngineDestroyer);
m_lastManagerNode = managerNode;
// Before Synchronizing is in the SG Thread, we want synchronize to be triggered
// in the context of the main thread so we use afterAnimating instead
m_windowConnection = QObject::connect(window(), &QQuickWindow::afterAnimating,
this, &Scene3DItem::synchronize, Qt::DirectConnection);
}
Scene3DRenderer *renderer = managerNode->renderer();
QRenderAspect *renderAspect = managerNode->renderAspect();
renderer->setBoundingSize(boundingRect().size().toSize());
renderer->setMultisample(m_multisample);
// Ensure Renderer is working on current window
renderer->setWindow(window());
// Set compositing mode on renderer
renderer->setCompositingMode(m_compositingMode);
// If the render aspect wasn't created yet, do so now
if (!managerNode->isInitialized()) {
auto *rw = QQuickRenderControl::renderWindowFor(window());
auto renderAspectPriv = static_cast<QRenderAspectPrivate*>(QRenderAspectPrivate::get(renderAspect));
renderAspectPriv->m_screen = (rw ? rw->screen() : window()->screen());
updateWindowSurface();
#if !QT_CONFIG(qt3d_rhi_renderer)
QSGRendererInterface::GraphicsApi windowApi = window()->rendererInterface()->graphicsApi();
if (windowApi != QSGRendererInterface::OpenGLRhi &&
windowApi != QSGRendererInterface::OpenGL) {
qFatal("Qt3D's RHI Renderer is not enabled, please configure RHI to use the OpenGL backend "
"by calling qputenv(\"QSG_RHI_BACKEND\", \"opengl\")");
}
#endif
managerNode->init();
// Note: ChangeArbiter is only set after aspect was registered
QObject::connect(
renderAspectPriv->m_aspectManager->changeArbiter(),
&Qt3DCore::QChangeArbiter::receivedChange, this,
[this] {
m_dirty = true;
m_framesToRender = ms_framesNeededToFlushPipeline;
},
Qt::DirectConnection);
// Give the window a nudge to trigger an update.
QMetaObject::invokeMethod(window(), "requestUpdate", Qt::QueuedConnection);
}
const bool usesFBO = m_compositingMode == FBO;
Scene3DSGNode *fboNode = static_cast<Scene3DSGNode *>(managerNode->firstChild());
// When using Scene3D in Underlay mode
// we shouldn't be managing a Scene3DSGNode
if (!usesFBO) {
if (fboNode != nullptr) {
managerNode->removeChildNode(fboNode);
delete fboNode;
fboNode = nullptr;
}
} else {
// Regular Scene3D only case
// Create SGNode if using FBO and no Scene3DViews
fboNode = renderer->sgNode();
if (fboNode) {
if (!fboNode->parent())
managerNode->appendChildNode(fboNode);
// Depending on the backend in use, we might or might not have
// to flip content
fboNode->setRect(boundingRect(), !renderer->isYUp());
}
}
// Set whether we want the Renderer to be allowed to render or not
const bool skipFrame = !needsRender(renderAspect);
renderer->setSkipFrame(skipFrame);
renderer->allowRender();
// Let the renderer prepare anything it needs to prior to the rendering
if (m_wasFrameProcessed)
renderer->beforeSynchronize();
// Force window->beforeRendering to be triggered
managerNode->markDirty(QSGNode::DirtyForceUpdate);
m_wasSGUpdated = true;
return managerNode;
}
void Scene3DItem::mousePressEvent(QMouseEvent *event)
{
Q_UNUSED(event);
//Prevent subsequent move and release events being disregarded my the default event->ignore() from QQuickItem
}
} // namespace Qt3DRender
QT_END_NAMESPACE
#include "moc_scene3ditem_p.cpp"
#include "scene3ditem.moc"