Scene2D cleanup - register pick events when scene is initialized

The current model where mouseGrab is connected to picker signal
doesn't work. The pressed event is not sent to scene2d item, because it is
already lost when scene2d gets the grabMouse message where it registers to
the picker events. This breaks the mouse event sequence
(press-move-release) for the quick item.

Instead hook to setScene of the node to message scene2d when the scene gets
initialized and always register to the picker events.

Task-number: QTBUG-58876
Change-Id: Ic9ca4b0899a030336ef20ff2cffbe10b567c36f5
Reviewed-by: Antti Määttä <antti.maatta@qt.io>

11 files changed, 167 insertions, 114 deletions

diff --git a/src/core/aspects/qaspectengine.cpp b/src/core/aspects/qaspectengine.cpp
index a3fda90b0..b9c9d2283 100644
--- a/src/core/aspects/qaspectengine.cpp
+++ b/src/core/aspects/qaspectengine.cpp
@@ -103,8 +103,8 @@ QAspectEnginePrivate::~QAspectEnginePrivate()
  */
 void QAspectEnginePrivate::initNode(QNode *node)
 {
-    QNodePrivate::get(node)->setScene(m_scene);
     m_scene->addObservable(node);
+    QNodePrivate::get(node)->setScene(m_scene);
 }
 
 void QAspectEnginePrivate::initEntity(QEntity *entity)
diff --git a/src/quick3d/quick3dscene2d/items/qscene2d.cpp b/src/quick3d/quick3dscene2d/items/qscene2d.cpp
index cc8c0b4fe..c96509252 100644
--- a/src/quick3d/quick3dscene2d/items/qscene2d.cpp
+++ b/src/quick3d/quick3dscene2d/items/qscene2d.cpp
@@ -95,6 +95,15 @@ namespace Quick {
     Holds the render policy of this Scene2D.
  */
 
+/*!
+    \qmlproperty bool Qt3D.Render::Scene2D::mouseEnabled
+    Holds whether mouse events are enabled for the rendered item. The mouse events are
+    generated from object picking events of the entities added to the QScene2D.
+    Mouse is enabled by default.
+
+    \note Events are delayed by one frame due to object picking happening in the backend.
+ */
+
 QScene2DPrivate::QScene2DPrivate()
     : Qt3DCore::QNodePrivate()
     , m_renderManager(new Scene2DManager(this))
@@ -108,6 +117,15 @@ QScene2DPrivate::~QScene2DPrivate()
     delete m_renderManager;
 }
 
+void QScene2DPrivate::setScene(Qt3DCore::QScene *scene)
+{
+    Q_Q(QScene2D);
+    QNodePrivate::setScene(scene);
+    const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(q->id());
+    change->setPropertyName("sceneInitialized");
+    notifyObservers(change);
+}
+
 
 /*!
     The constructor creates a new QScene2D instance with the specified \a parent.
@@ -190,20 +208,14 @@ Qt3DCore::QNodeCreatedChangeBasePtr QScene2D::createNodeCreationChange() const
     data.output = d->m_output ? d->m_output->id() : Qt3DCore::QNodeId();
     for (Qt3DCore::QEntity *e : d->m_entities)
         data.entityIds.append(e->id());
+    data.mouseEnabled = d->m_renderManager->m_mouseEnabled;
     return creationChange;
 }
 
-bool QScene2D::event(QEvent *event)
-{
-    Q_D(QScene2D);
-    d->m_renderManager->forwardEvent(event);
-    return true;
-}
-
-bool QScene2D::isGrabMouseEnabled() const
+bool QScene2D::isMouseEnabled() const
 {
     Q_D(const QScene2D);
-    return d->m_renderManager->m_grabMouse;
+    return d->m_renderManager->m_mouseEnabled;
 }
 
 QVector<Qt3DCore::QEntity*> QScene2D::entities()
@@ -244,12 +256,20 @@ void QScene2D::removeEntity(Qt3DCore::QEntity *entity)
     }
 }
 
-void QScene2D::setGrabMouseEnabled(bool grab)
+/*!
+    \property QScene2D::mouseEnabled
+    Holds whether mouse events are enabled for the rendered item. The mouse events are
+    generated from object picking events of the entities added to the QScene2D.
+    Mouse is enabled by default.
+
+    \note Events are delayed by one frame due to object picking happening in the backend.
+ */
+void QScene2D::setMouseEnabled(bool enabled)
 {
     Q_D(QScene2D);
-    if (d->m_renderManager->m_grabMouse != grab) {
-        d->m_renderManager->m_grabMouse = grab;
-        emit grabMouseChanged(grab);
+    if (d->m_renderManager->m_mouseEnabled != enabled) {
+        d->m_renderManager->m_mouseEnabled = enabled;
+        emit mouseEnabledChanged(enabled);
     }
 }
 
diff --git a/src/quick3d/quick3dscene2d/items/qscene2d.h b/src/quick3d/quick3dscene2d/items/qscene2d.h
index b40cff536..73322a9e9 100644
--- a/src/quick3d/quick3dscene2d/items/qscene2d.h
+++ b/src/quick3d/quick3dscene2d/items/qscene2d.h
@@ -62,7 +62,7 @@ class QT3DQUICKSCENE2DSHARED_EXPORT QScene2D : public Qt3DCore::QNode
     Q_PROPERTY(Qt3DRender::QRenderTargetOutput *output READ output WRITE setOutput NOTIFY outputChanged)
     Q_PROPERTY(QScene2D::RenderPolicy renderPolicy READ renderPolicy WRITE setRenderPolicy NOTIFY renderPolicyChanged)
     Q_PROPERTY(QQuickItem *item READ item WRITE setItem NOTIFY itemChanged)
-    Q_PROPERTY(bool grabMouse READ isGrabMouseEnabled WRITE setGrabMouseEnabled NOTIFY grabMouseChanged)
+    Q_PROPERTY(bool mouseEnabled READ isMouseEnabled WRITE setMouseEnabled NOTIFY mouseEnabledChanged)
 
     Q_CLASSINFO("DefaultProperty", "item")
 
@@ -79,9 +79,7 @@ public:
     Qt3DRender::QRenderTargetOutput *output() const;
     QScene2D::RenderPolicy renderPolicy() const;
     QQuickItem *item() const;
-    bool isGrabMouseEnabled() const;
-
-    bool event(QEvent *event) Q_DECL_OVERRIDE;
+    bool isMouseEnabled() const;
 
     QVector<Qt3DCore::QEntity *> entities();
     void addEntity(Qt3DCore::QEntity *entity);
@@ -91,13 +89,13 @@ public Q_SLOTS:
     void setOutput(Qt3DRender::QRenderTargetOutput *output);
     void setRenderPolicy(QScene2D::RenderPolicy policy);
     void setItem(QQuickItem *item);
-    void setGrabMouseEnabled(bool grab);
+    void setMouseEnabled(bool enabled);
 
 Q_SIGNALS:
     void outputChanged(Qt3DRender::QRenderTargetOutput *output);
     void renderPolicyChanged(QScene2D::RenderPolicy policy);
     void itemChanged(QQuickItem *item);
-    void grabMouseChanged(bool grab);
+    void mouseEnabledChanged(bool enabled);
 
 protected:
     Q_DECLARE_PRIVATE(QScene2D)
diff --git a/src/quick3d/quick3dscene2d/items/qscene2d_p.h b/src/quick3d/quick3dscene2d/items/qscene2d_p.h
index e40d3d6a9..217058f5c 100644
--- a/src/quick3d/quick3dscene2d/items/qscene2d_p.h
+++ b/src/quick3d/quick3dscene2d/items/qscene2d_p.h
@@ -55,6 +55,10 @@
 
 QT_BEGIN_NAMESPACE
 
+namespace Qt3DCore {
+class QScene;
+}
+
 namespace Qt3DRender {
 
 namespace Quick {
@@ -70,6 +74,8 @@ public:
     QScene2DPrivate();
     ~QScene2DPrivate();
 
+    void setScene(Qt3DCore::QScene *scene) Q_DECL_OVERRIDE;
+
     Scene2DManager *m_renderManager;
     QMetaObject::Connection m_textureDestroyedConnection;
     Qt3DRender::QRenderTargetOutput *m_output;
@@ -82,6 +88,7 @@ struct QScene2DData
     Scene2DSharedObjectPtr sharedObject;
     Qt3DCore::QNodeId output;
     QVector<Qt3DCore::QNodeId> entityIds;
+    bool mouseEnabled;
 };
 
 } // namespace Quick
diff --git a/src/quick3d/quick3dscene2d/items/scene2d.cpp b/src/quick3d/quick3dscene2d/items/scene2d.cpp
index 88b4d9e86..b0c58c6c5 100644
--- a/src/quick3d/quick3dscene2d/items/scene2d.cpp
+++ b/src/quick3d/quick3dscene2d/items/scene2d.cpp
@@ -118,6 +118,7 @@ Scene2D::Scene2D()
     , m_rbo(0)
     , m_initialized(false)
     , m_renderInitialized(false)
+    , m_mouseEnabled(true)
     , m_renderPolicy(Qt3DRender::Quick::QScene2D::Continuous)
 {
     renderThreadClientCount->fetchAndAddAcquire(1);
@@ -125,12 +126,7 @@ Scene2D::Scene2D()
 
 Scene2D::~Scene2D()
 {
-    // this gets called from aspect thread. Wait for the render thread then delete it.
-    // TODO: render thread deletion
-//     if (m_renderThread) {
-//        m_renderThread->wait(1000);
-//        delete m_renderThread;
-//    }
+    stopGrabbing();
 }
 
 void Scene2D::setOutput(Qt3DCore::QNodeId outputId)
@@ -177,6 +173,7 @@ void Scene2D::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &chan
     setSharedObject(data.sharedObject);
     setOutput(data.output);
     m_entities = data.entityIds;
+    m_mouseEnabled = data.mouseEnabled;
 }
 
 void Scene2D::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
@@ -192,49 +189,42 @@ void Scene2D::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
         } else if (propertyChange->propertyName() == QByteArrayLiteral("output")) {
             Qt3DCore::QNodeId outputId = propertyChange->value().value<Qt3DCore::QNodeId>();
             setOutput(outputId);
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("sharedObject")) {
-            const Scene2DSharedObjectPtr sharedObject
-                    = propertyChange->value().value<Scene2DSharedObjectPtr>();
-            setSharedObject(sharedObject);
         } else if (propertyChange->propertyName() == QByteArrayLiteral("pressed")) {
             QPickEventPtr ev = propertyChange->value().value<QPickEventPtr>();
             handlePickEvent(QEvent::MouseButtonPress, ev);
         } else if (propertyChange->propertyName() == QByteArrayLiteral("released")) {
             QPickEventPtr ev = propertyChange->value().value<QPickEventPtr>();
             handlePickEvent(QEvent::MouseButtonRelease, ev);
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("clicked")) {
-            QPickEventPtr ev = propertyChange->value().value<QPickEventPtr>();
-            handlePickEvent(QEvent::MouseButtonDblClick, ev);
         } else if (propertyChange->propertyName() == QByteArrayLiteral("moved")) {
             QPickEventPtr ev = propertyChange->value().value<QPickEventPtr>();
             handlePickEvent(QEvent::MouseMove, ev);
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("grabMouse")) {
-            if (propertyChange->value().toBool()) {
-                startGrabbing();
-            } else {
-                stopGrabbing();
+        } else if (propertyChange->propertyName() == QByteArrayLiteral("mouseEnabled")) {
+            m_mouseEnabled = propertyChange->value().toBool();
+            if (m_mouseEnabled && !m_cachedPickEvent.isNull()) {
+                handlePickEvent(QEvent::MouseButtonPress, m_cachedPickEvent);
+                m_cachedPickEvent.clear();
             }
+        } else if (propertyChange->propertyName() == QByteArrayLiteral("sceneInitialized")) {
+            startGrabbing();
         }
-        /* TODO: handle these?
-          else if (propertyChange->propertyName() == QByteArrayLiteral("entered")) {
-
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("exited")) {
-
-        }*/
         break;
     }
 
     case Qt3DCore::PropertyValueAdded: {
         const auto change = qSharedPointerCast<Qt3DCore::QPropertyNodeAddedChange>(e);
-        if (change->propertyName() == QByteArrayLiteral("entities"))
+        if (change->propertyName() == QByteArrayLiteral("entities")) {
             m_entities.push_back(change->addedNodeId());
+            registerObjectPickerEvents(change->addedNodeId());
+        }
         break;
     }
 
     case Qt3DCore::PropertyValueRemoved: {
         const auto change = qSharedPointerCast<Qt3DCore::QPropertyNodeRemovedChange>(e);
-        if (change->propertyName() == QByteArrayLiteral("entities"))
+        if (change->propertyName() == QByteArrayLiteral("entities")) {
             m_entities.removeOne(change->removedNodeId());
+            unregisterObjectPickerEvents(change->removedNodeId());
+        }
         break;
     }
 
@@ -468,34 +458,42 @@ void Scene2D::unregisterObjectPickerEvents(Qt3DCore::QNodeId entityId)
 
 void Scene2D::handlePickEvent(int type, const Qt3DRender::QPickEventPtr &ev)
 {
-    QPickTriangleEvent *pickTriangle = static_cast<QPickTriangleEvent *>(ev.data());
-    Entity *entity = nullptr;
-    if (!resourceAccessor()->accessResource(RenderBackendResourceAccessor::EntityHandle,
-                                            QPickEventPrivate::get(pickTriangle)->m_entity,
-                                            (void**)&entity, nullptr)) {
+    if (!isEnabled())
         return;
-    }
-    CoordinateReader reader(renderer()->nodeManagers());
-    if (reader.setGeometry(entity->renderComponent<GeometryRenderer>(),
-                           QAttribute::defaultTextureCoordinateAttributeName())) {
-        QVector4D c0 = reader.getCoordinate(pickTriangle->vertex1Index());
-        QVector4D c1 = reader.getCoordinate(pickTriangle->vertex2Index());
-        QVector4D c2 = reader.getCoordinate(pickTriangle->vertex3Index());
-        QVector4D ci = c0 * pickTriangle->uvw().x()
-                       + c1 * pickTriangle->uvw().y() + c2 * pickTriangle->uvw().z();
-        ci.setW(1.0f);
-
-        const QSize size = m_sharedObject->m_quickWindow->size();
-        QPointF pos = QPointF(ci.x() * size.width(), (1.0f - ci.y()) * size.height());
-        QMouseEvent *mouseEvent
-                = new QMouseEvent(static_cast<QEvent::Type>(type),
-                                  pos, pos, pos,
-                                  static_cast<Qt::MouseButton>(pickTriangle->button()),
-                                  static_cast<Qt::MouseButtons>(pickTriangle->buttons()),
-                                  static_cast<Qt::KeyboardModifiers>(pickTriangle->modifiers()),
-                                  Qt::MouseEventSynthesizedByApplication);
-
-        QCoreApplication::postEvent(m_sharedObject->m_quickWindow, mouseEvent);
+    if (m_mouseEnabled) {
+        QPickTriangleEvent *pickTriangle = static_cast<QPickTriangleEvent *>(ev.data());
+        Entity *entity = nullptr;
+        if (!resourceAccessor()->accessResource(RenderBackendResourceAccessor::EntityHandle,
+                                                QPickEventPrivate::get(pickTriangle)->m_entity,
+                                                (void**)&entity, nullptr)) {
+            return;
+        }
+        CoordinateReader reader(renderer()->nodeManagers());
+        if (reader.setGeometry(entity->renderComponent<GeometryRenderer>(),
+                               QAttribute::defaultTextureCoordinateAttributeName())) {
+            QVector4D c0 = reader.getCoordinate(pickTriangle->vertex1Index());
+            QVector4D c1 = reader.getCoordinate(pickTriangle->vertex2Index());
+            QVector4D c2 = reader.getCoordinate(pickTriangle->vertex3Index());
+            QVector4D ci = c0 * pickTriangle->uvw().x()
+                           + c1 * pickTriangle->uvw().y() + c2 * pickTriangle->uvw().z();
+            ci.setW(1.0f);
+
+            const QSize size = m_sharedObject->m_quickWindow->size();
+            QPointF pos = QPointF(ci.x() * size.width(), (1.0f - ci.y()) * size.height());
+            QMouseEvent *mouseEvent
+                    = new QMouseEvent(static_cast<QEvent::Type>(type),
+                                      pos, pos, pos,
+                                      static_cast<Qt::MouseButton>(pickTriangle->button()),
+                                      static_cast<Qt::MouseButtons>(pickTriangle->buttons()),
+                                      static_cast<Qt::KeyboardModifiers>(pickTriangle->modifiers()),
+                                      Qt::MouseEventSynthesizedByApplication);
+
+            QCoreApplication::postEvent(m_sharedObject->m_quickWindow, mouseEvent);
+        }
+    } else if (type == QEvent::MouseButtonPress) {
+        m_cachedPickEvent = ev;
+    } else {
+        m_cachedPickEvent.clear();
     }
 }
 
diff --git a/src/quick3d/quick3dscene2d/items/scene2d_p.h b/src/quick3d/quick3dscene2d/items/scene2d_p.h
index d2845d847..b42089306 100644
--- a/src/quick3d/quick3dscene2d/items/scene2d_p.h
+++ b/src/quick3d/quick3dscene2d/items/scene2d_p.h
@@ -119,8 +119,10 @@ public:
 
     bool m_initialized;
     bool m_renderInitialized;
+    bool m_mouseEnabled;
     Qt3DRender::Quick::QScene2D::RenderPolicy m_renderPolicy;
     QVector<Qt3DCore::QNodeId> m_entities;
+    Qt3DRender::QPickEventPtr m_cachedPickEvent;
 };
 
 } // Quick
diff --git a/src/quick3d/quick3dscene2d/items/scene2dmanager.cpp b/src/quick3d/quick3dscene2d/items/scene2dmanager.cpp
index 3a83a36fd..20c080dec 100644
--- a/src/quick3d/quick3dscene2d/items/scene2dmanager.cpp
+++ b/src/quick3d/quick3dscene2d/items/scene2dmanager.cpp
@@ -81,7 +81,7 @@ Scene2DManager::Scene2DManager(QScene2DPrivate *priv)
     , m_initialized(false)
     , m_renderSyncRequested(false)
     , m_backendInitialized(false)
-    , m_grabMouse(false)
+    , m_mouseEnabled(true)
 {
     m_sharedObject->m_surface = new QOffscreenSurface;
     m_sharedObject->m_surface->setFormat(QSurfaceFormat::defaultFormat());
@@ -225,33 +225,6 @@ bool Scene2DManager::event(QEvent *e)
     return QObject::event(e);
 }
 
-bool Scene2DManager::forwardEvent(QEvent *event)
-{
-    switch (event->type()) {
-
-    case QEvent::MouseMove:
-    case QEvent::MouseButtonDblClick:
-    case QEvent::MouseButtonPress:
-    case QEvent::MouseButtonRelease: {
-        QMouseEvent* me = static_cast<QMouseEvent *>(event);
-        QPointF pos = me->localPos();
-        pos = QPointF(pos.x() * m_rootItem->width(), pos.y() * m_rootItem->height());
-        QMouseEvent nme = QMouseEvent(me->type(), pos, pos, pos, me->button(), me->buttons(),
-                                      me->modifiers(), Qt::MouseEventSynthesizedByApplication);
-        QCoreApplication::sendEvent(m_sharedObject->m_quickWindow, &nme);
-    } break;
-
-    case QEvent::KeyPress:
-    case QEvent::KeyRelease: {
-        QCoreApplication::sendEvent(m_sharedObject->m_quickWindow, event);
-    } break;
-
-    default:
-        break;
-    }
-    return false;
-}
-
 void Scene2DManager::doRenderSync()
 {
     QMutexLocker lock(&m_sharedObject->m_mutex);
diff --git a/src/quick3d/quick3dscene2d/items/scene2dmanager_p.h b/src/quick3d/quick3dscene2d/items/scene2dmanager_p.h
index 5f199969e..821616f47 100644
--- a/src/quick3d/quick3dscene2d/items/scene2dmanager_p.h
+++ b/src/quick3d/quick3dscene2d/items/scene2dmanager_p.h
@@ -88,7 +88,7 @@ public:
     bool m_initialized;
     bool m_renderSyncRequested;
     bool m_backendInitialized;
-    bool m_grabMouse;
+    bool m_mouseEnabled;
 
     void requestRender();
     void requestRenderSync();
@@ -100,7 +100,6 @@ public:
     void setItem(QQuickItem *item);
 
     bool event(QEvent *e) Q_DECL_OVERRIDE;
-    bool forwardEvent(QEvent *event);
 
     void cleanup();
 };
diff --git a/tests/auto/render/qscene2d/tst_qscene2d.cpp b/tests/auto/render/qscene2d/tst_qscene2d.cpp
index 61ac893e4..846207456 100644
--- a/tests/auto/render/qscene2d/tst_qscene2d.cpp
+++ b/tests/auto/render/qscene2d/tst_qscene2d.cpp
@@ -60,6 +60,7 @@ private Q_SLOTS:
         QCOMPARE(scene2d.output(), nullptr);
         QCOMPARE(scene2d.renderPolicy(), QScene2D::Continuous);
         QCOMPARE(scene2d.item(), nullptr);
+        QCOMPARE(scene2d.isMouseEnabled(), true);
     }
 
     void checkPropertyChanges()
@@ -126,6 +127,26 @@ private Q_SLOTS:
             QCOMPARE(scene2d.item(), newValue);
             QCOMPARE(spy.count(), 0);
         }
+
+        {
+            // WHEN
+            QSignalSpy spy(&scene2d, SIGNAL(mouseEnabledChanged(bool)));
+            bool newValue = false;
+            scene2d.setMouseEnabled(newValue);
+
+            // THEN
+            QVERIFY(spy.isValid());
+            QCOMPARE(scene2d.isMouseEnabled(), newValue);
+            QCOMPARE(spy.count(), 1);
+
+            // WHEN
+            spy.clear();
+            scene2d.setMouseEnabled(newValue);
+
+            // THEN
+            QCOMPARE(scene2d.isMouseEnabled(), newValue);
+            QCOMPARE(spy.count(), 0);
+        }
     }
 
     void checkCreationData()
@@ -159,6 +180,7 @@ private Q_SLOTS:
             QCOMPARE(scene2d.isEnabled(), true);
             QCOMPARE(scene2d.isEnabled(), creationChangeData->isNodeEnabled());
             QCOMPARE(scene2d.metaObject(), creationChangeData->metaObject());
+            QCOMPARE(scene2d.isMouseEnabled(), cloneData.mouseEnabled);
         }
 
         // WHEN
@@ -254,6 +276,39 @@ private Q_SLOTS:
 
     }
 
+    void checkMouseEnabledUpdate()
+    {
+        // GIVEN
+        TestArbiter arbiter;
+        Qt3DRender::Quick::QScene2D scene2d;
+        arbiter.setArbiterOnNode(&scene2d);
+
+        {
+            // WHEN
+            scene2d.setMouseEnabled(false);
+            QCoreApplication::processEvents();
+
+            // THEN
+            QCOMPARE(arbiter.events.size(), 1);
+            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
+            QCOMPARE(change->propertyName(), "mouseEnabled");
+            QCOMPARE(change->value().toBool(), scene2d.isMouseEnabled());
+            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+
+            arbiter.events.clear();
+        }
+
+        {
+            // WHEN
+            scene2d.setMouseEnabled(false);
+            QCoreApplication::processEvents();
+
+            // THEN
+            QCOMPARE(arbiter.events.size(), 0);
+        }
+
+    }
+
 };
 
 QTEST_MAIN(tst_QScene2D)
diff --git a/tests/auto/render/scene2d/tst_scene2d.cpp b/tests/auto/render/scene2d/tst_scene2d.cpp
index a4810ce66..a78ed0ab1 100644
--- a/tests/auto/render/scene2d/tst_scene2d.cpp
+++ b/tests/auto/render/scene2d/tst_scene2d.cpp
@@ -114,6 +114,7 @@ private Q_SLOTS:
         QCOMPARE(backendScene2d.m_initialized, false);
         QCOMPARE(backendScene2d.m_renderInitialized, false);
         QCOMPARE(backendScene2d.m_renderPolicy, QScene2D::Continuous);
+        QCOMPARE(backendScene2d.m_mouseEnabled, true);
         backendScene2d.cleanup();
     }
 
@@ -135,6 +136,7 @@ private Q_SLOTS:
             QCOMPARE(backendScene2d->m_outputId, Qt3DCore::QNodeId());
             QVERIFY(backendScene2d->m_sharedObject.data() != nullptr);
             QCOMPARE(backendScene2d->m_renderPolicy, QScene2D::Continuous);
+            QCOMPARE(backendScene2d->m_mouseEnabled, true);
             backendScene2d->cleanup();
         }
         {
@@ -183,28 +185,25 @@ private Q_SLOTS:
         }
         {
              // WHEN
-             const QSharedPointer<Qt3DRender::Quick::Scene2DSharedObject> newValue
-                     = QSharedPointer<Qt3DRender::Quick::Scene2DSharedObject>(
-                         new Qt3DRender::Quick::Scene2DSharedObject(nullptr));
+             const QScene2D::RenderPolicy newValue = QScene2D::SingleShot;
              const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-             change->setPropertyName("sharedObject");
+             change->setPropertyName("renderPolicy");
              change->setValue(QVariant::fromValue(newValue));
              backendScene2d->sceneChangeEvent(change);
 
              // THEN
-             QCOMPARE(backendScene2d->m_sharedObject, newValue);
-             QCOMPARE(backendScene2d->m_sharedObject.data(), newValue.data());
+            QCOMPARE(backendScene2d->m_renderPolicy, newValue);
         }
         {
              // WHEN
-             const QScene2D::RenderPolicy newValue = QScene2D::SingleShot;
+             const bool newValue = false;
              const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-             change->setPropertyName("renderPolicy");
-             change->setValue(QVariant::fromValue(newValue));
+             change->setPropertyName("mouseEnabled");
+             change->setValue(newValue);
              backendScene2d->sceneChangeEvent(change);
 
              // THEN
-            QCOMPARE(backendScene2d->m_renderPolicy, newValue);
+            QCOMPARE(backendScene2d->isEnabled(), newValue);
         }
 
         backendScene2d->cleanup();
@@ -228,6 +227,7 @@ private Q_SLOTS:
         TestRenderer renderer;
         renderer.setNodeManagers(nodeManagers.data());
         scene2d->setRenderer(&renderer);
+        scene2d->setEnabled(true);
         sharedObject->m_quickWindow = testWindow.data();
         scene2d->setSharedObject(sharedObject);
         testWindow->setGeometry(0,0,1024,1024);
diff --git a/tests/manual/render-qml-to-texture-qml/main.qml b/tests/manual/render-qml-to-texture-qml/main.qml
index 748e14f6e..65a0a8783 100644
--- a/tests/manual/render-qml-to-texture-qml/main.qml
+++ b/tests/manual/render-qml-to-texture-qml/main.qml
@@ -91,7 +91,8 @@ QQ2.Item {
                 }
 
                 entities: [plane1]
-                grabMouse: plane1.picker.pressed
+
+                mouseEnabled: plane1.picker.pressed
 
                 InteractiveGui {