Update QLevelOfDetail to use direct sync

Change-Id: I7ef8ae7cd9509939f85280abc6eefe8210dc556d
Reviewed-by: Paul Lemire <paul.lemire@kdab.com>

4 files changed, 56 insertions, 53 deletions

diff --git a/src/render/backend/levelofdetail.cpp b/src/render/backend/levelofdetail.cpp
index 157bfc004..08410edf9 100644
--- a/src/render/backend/levelofdetail.cpp
+++ b/src/render/backend/levelofdetail.cpp
@@ -42,6 +42,7 @@
 #include <Qt3DRender/private/qlevelofdetail_p.h>
 #include <Qt3DRender/private/stringtoint_p.h>
 #include <Qt3DCore/qpropertyupdatedchange.h>
+#include <Qt3DRender/QCamera>
 #include <QVariant>
 
 QT_BEGIN_NAMESPACE
@@ -64,41 +65,48 @@ LevelOfDetail::~LevelOfDetail()
     cleanup();
 }
 
-void LevelOfDetail::initializeFromPeer(const QNodeCreatedChangeBasePtr &change)
+void LevelOfDetail::syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime)
 {
-    const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QLevelOfDetailData>>(change);
-    const auto &data = typedChange->data;
-    m_camera = data.camera;
-    m_currentIndex = data.currentIndex;
-    m_thresholdType = data.thresholdType;
-    m_thresholds = data.thresholds;
-    m_volumeOverride = data.volumeOverride;
-}
+    const QLevelOfDetail *node = qobject_cast<const QLevelOfDetail *>(frontEnd);
+    if (!node)
+        return;
 
-void LevelOfDetail::cleanup()
-{
-    QBackendNode::setEnabled(false);
-}
+    const bool oldEnabled = isEnabled();
+    BackendNode::syncFromFrontEnd(frontEnd, firstTime);
 
-void LevelOfDetail::sceneChangeEvent(const QSceneChangePtr &e)
-{
-    if (e->type() == PropertyUpdated) {
-        const QPropertyUpdatedChangePtr &propertyChange = qSharedPointerCast<QPropertyUpdatedChange>(e);
-        if (propertyChange->propertyName() == QByteArrayLiteral("currentIndex"))
-            m_currentIndex = propertyChange->value().value<int>();
-        else if (propertyChange->propertyName() == QByteArrayLiteral("camera"))
-            m_camera = propertyChange->value().value<Qt3DCore::QNodeId>();
-        else if (propertyChange->propertyName() == QByteArrayLiteral("thresholdType"))
-            m_thresholdType = propertyChange->value().value<QLevelOfDetail::ThresholdType>();
-        else if (propertyChange->propertyName() == QByteArrayLiteral("thresholds"))
-            m_thresholds = propertyChange->value().value<QVector<qreal>>();
-        else if (propertyChange->propertyName() == QByteArrayLiteral("volumeOverride"))
-            m_volumeOverride = propertyChange->value().value<Qt3DRender::QLevelOfDetailBoundingSphere>();
+    const Qt3DCore::QNodeId cameraId = Qt3DCore::qIdForNode(node->camera());
+    if (cameraId != m_camera) {
+        m_camera = cameraId;
+        markDirty(AbstractRenderer::GeometryDirty);
+    }
+
+    if (node->currentIndex() != m_currentIndex) {
+        m_currentIndex = node->currentIndex();
+        markDirty(AbstractRenderer::GeometryDirty);
+    }
+
+    if (node->thresholdType() != m_thresholdType) {
+        m_thresholdType = node->thresholdType();
+        markDirty(AbstractRenderer::GeometryDirty);
     }
 
-    markDirty(AbstractRenderer::GeometryDirty);
+    if (node->thresholds() != m_thresholds) {
+        m_thresholds = node->thresholds();
+        markDirty(AbstractRenderer::GeometryDirty);
+    }
 
-    BackendNode::sceneChangeEvent(e);
+    if (node->volumeOverride() != m_volumeOverride) {
+        m_volumeOverride = node->volumeOverride();
+        markDirty(AbstractRenderer::GeometryDirty);
+    }
+
+    if (isEnabled() != oldEnabled || firstTime)
+        markDirty(AbstractRenderer::LayersDirty);
+}
+
+void LevelOfDetail::cleanup()
+{
+    QBackendNode::setEnabled(false);
 }
 
 void LevelOfDetail::setCurrentIndex(int currentIndex)
diff --git a/src/render/backend/levelofdetail_p.h b/src/render/backend/levelofdetail_p.h
index 4cf835d9b..8399e19b7 100644
--- a/src/render/backend/levelofdetail_p.h
+++ b/src/render/backend/levelofdetail_p.h
@@ -73,7 +73,7 @@ public:
     LevelOfDetail();
     ~LevelOfDetail();
     void cleanup();
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) final;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
 
     Qt3DCore::QNodeId camera() const { return m_camera; }
     int currentIndex() const { return m_currentIndex; }
@@ -86,7 +86,6 @@ public:
     void setCurrentIndex(int currentIndex);
 
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
     Qt3DCore::QNodeId m_camera;
     int m_currentIndex;
     QLevelOfDetail::ThresholdType m_thresholdType;
diff --git a/src/render/frontend/qrenderaspect.cpp b/src/render/frontend/qrenderaspect.cpp
index da775ce49..d4d285c37 100644
--- a/src/render/frontend/qrenderaspect.cpp
+++ b/src/render/frontend/qrenderaspect.cpp
@@ -257,7 +257,7 @@ void QRenderAspectPrivate::registerBackendTypes()
 
     q->registerBackendType<Qt3DRender::QCameraLens, true>(QSharedPointer<Render::CameraLensFunctor>::create(m_renderer, q));
     q->registerBackendType<QLayer, true>(QSharedPointer<Render::NodeFunctor<Render::Layer, Render::LayerManager> >::create(m_renderer));
-    q->registerBackendType<QLevelOfDetail>(QSharedPointer<Render::NodeFunctor<Render::LevelOfDetail, Render::LevelOfDetailManager> >::create(m_renderer));
+    q->registerBackendType<QLevelOfDetail, true>(QSharedPointer<Render::NodeFunctor<Render::LevelOfDetail, Render::LevelOfDetailManager> >::create(m_renderer));
     q->registerBackendType<QLevelOfDetailSwitch>(QSharedPointer<Render::NodeFunctor<Render::LevelOfDetail, Render::LevelOfDetailManager> >::create(m_renderer));
     q->registerBackendType<QSceneLoader>(QSharedPointer<Render::RenderSceneFunctor>::create(m_renderer, m_nodeManagers->sceneManager()));
     q->registerBackendType<QRenderTarget>(QSharedPointer<Render::NodeFunctor<Render::RenderTarget, Render::RenderTargetManager> >::create(m_renderer));
diff --git a/tests/auto/render/levelofdetail/tst_levelofdetail.cpp b/tests/auto/render/levelofdetail/tst_levelofdetail.cpp
index 148c54e58..2285cc5ff 100644
--- a/tests/auto/render/levelofdetail/tst_levelofdetail.cpp
+++ b/tests/auto/render/levelofdetail/tst_levelofdetail.cpp
@@ -45,11 +45,13 @@ private Q_SLOTS:
     void checkPeerPropertyMirroring()
     {
         // GIVEN
+        TestRenderer renderer;
         Qt3DRender::Render::LevelOfDetail renderLod;
         Qt3DRender::QLevelOfDetail lod;
 
         // WHEN
-        simulateInitialization(&lod, &renderLod);
+        renderLod.setRenderer(&renderer);
+        simulateInitializationSync(&lod, &renderLod);
 
         // THEN
         QCOMPARE(renderLod.peerId(), lod.id());
@@ -82,7 +84,7 @@ private Q_SLOTS:
 
         // WHEN
         renderLod.setRenderer(&renderer);
-        simulateInitialization(&lod, &renderLod);
+        simulateInitializationSync(&lod, &renderLod);
 
         // THEN
         QCOMPARE(renderLod.thresholdType(), lod.thresholdType());
@@ -92,8 +94,10 @@ private Q_SLOTS:
     {
         // GIVEN
         TestRenderer renderer;
+        Qt3DRender::QLevelOfDetail lod;
         Qt3DRender::Render::LevelOfDetail renderLod;
         renderLod.setRenderer(&renderer);
+        simulateInitializationSync(&lod, &renderLod);
 
         // THEN
         QVERIFY(renderLod.thresholdType() != Qt3DRender::QLevelOfDetail::ProjectedScreenPixelSizeThreshold);
@@ -101,38 +105,30 @@ private Q_SLOTS:
 
         {
             // WHEN
-            Qt3DCore::QPropertyUpdatedChangePtr updateChange(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId()));
-            updateChange->setValue(static_cast<int>(Qt3DRender::QLevelOfDetail::ProjectedScreenPixelSizeThreshold));
-            updateChange->setPropertyName("thresholdType");
-            renderLod.sceneChangeEvent(updateChange);
+            lod.setThresholdType(Qt3DRender::QLevelOfDetail::ProjectedScreenPixelSizeThreshold);
+            renderLod.syncFromFrontEnd(&lod, false);
 
             // THEN
             QCOMPARE(renderLod.thresholdType(), Qt3DRender::QLevelOfDetail::ProjectedScreenPixelSizeThreshold);
-            QVERIFY(renderer.dirtyBits() != 0);
-        }
+            QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::GeometryDirty);
+            renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);        }
 
         {
-            QVector<qreal> thresholds = {20.f, 30.f, 40.f};
-            QVariant v;
-            v.setValue<decltype(thresholds)>(thresholds);
+            const QVector<qreal> thresholds = {20.f, 30.f, 40.f};
 
             // WHEN
-            Qt3DCore::QPropertyUpdatedChangePtr updateChange(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId()));
-            updateChange->setValue(v);
-            updateChange->setPropertyName("thresholds");
-            renderLod.sceneChangeEvent(updateChange);
-
+            lod.setThresholds(thresholds);
+            renderLod.syncFromFrontEnd(&lod, false);
             // THEN
             QCOMPARE(renderLod.thresholds(), thresholds);
         }
 
         {
             // WHEN
-            Qt3DCore::QPropertyUpdatedChangePtr updateChange(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId()));
-            Qt3DRender::QLevelOfDetailBoundingSphere sphere(QVector3D(1.0f, 2.0f, 3.0f), 1.0f);
-            updateChange->setValue(QVariant::fromValue(sphere));
-            updateChange->setPropertyName("volumeOverride");
-            renderLod.sceneChangeEvent(updateChange);
+            const Qt3DRender::QLevelOfDetailBoundingSphere sphere(QVector3D(1.0f, 2.0f, 3.0f), 1.0f);
+            // WHEN
+            lod.setVolumeOverride(sphere);
+            renderLod.syncFromFrontEnd(&lod, false);
 
             // THEN
             QCOMPARE(renderLod.center(), QVector3D(1., 2., 3.));