Merge remote-tracking branch 'origin/5.15' into dev

Change-Id: Ifbf6091cf4bf41b282caee6eaf8d9c4adb6cca89

45 files changed, 378 insertions, 603 deletions

diff --git a/src/render/framegraph/blitframebuffer.cpp b/src/render/framegraph/blitframebuffer.cpp
index 342594baf..c45d3fdbc 100644
--- a/src/render/framegraph/blitframebuffer.cpp
+++ b/src/render/framegraph/blitframebuffer.cpp
@@ -60,48 +60,44 @@ BlitFramebuffer::BlitFramebuffer()
 {
 }
 
-void BlitFramebuffer::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
+void BlitFramebuffer::syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime)
 {
-    if (e->type() == PropertyUpdated) {
-        QPropertyUpdatedChangePtr propertyChange = qSharedPointerCast<QPropertyUpdatedChange>(e);
-        if (propertyChange->propertyName() == QByteArrayLiteral("sourceRenderTarget")) {
-            m_sourceRenderTargetId = propertyChange->value().value<QNodeId>();
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("destinationRenderTarget")) {
-            m_destinationRenderTargetId = propertyChange->value().value<QNodeId>();
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("sourceRect")) {
-            m_sourceRect = propertyChange->value().toRect();
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("destinationRect")) {
-            m_destinationRect = propertyChange->value().toRect();
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("sourceAttachmentPoint")) {
-            m_sourceAttachmentPoint = propertyChange->value().value<Qt3DRender::QRenderTargetOutput::AttachmentPoint>();
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("destinationAttachmentPoint")) {
-            m_destinationAttachmentPoint = propertyChange->value().value<Qt3DRender::QRenderTargetOutput::AttachmentPoint>();
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("interpolationMethod")) {
-            m_interpolationMethod = propertyChange->value().value<QBlitFramebuffer::InterpolationMethod>();
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        }
-    }
-    FrameGraphNode::sceneChangeEvent(e);
-}
+    const QBlitFramebuffer *node = qobject_cast<const QBlitFramebuffer *>(frontEnd);
+    if (!node)
+        return;
 
-void BlitFramebuffer::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
-{
-    FrameGraphNode::initializeFromPeer(change);
-    const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QBlitFramebufferData> >(change);
-    const auto &data = typedChange->data;
-    m_sourceRect = data.m_sourceRect;
-    m_destinationRect = data.m_destinationRect;
-    m_sourceRenderTargetId = data.m_sourceRenderTargetId;
-    m_destinationRenderTargetId = data.m_destinationRenderTargetId;
-    m_sourceAttachmentPoint = data.m_sourceAttachmentPoint;
-    m_destinationAttachmentPoint = data.m_destinationAttachmentPoint;
-    m_interpolationMethod = data.m_interpolationMethod;
+    FrameGraphNode::syncFromFrontEnd(frontEnd, firstTime);
+
+    if (node->sourceRect().toRect() != m_sourceRect) {
+        m_sourceRect = node->sourceRect().toRect();
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
+    if (node->destinationRect().toRect() != m_destinationRect) {
+        m_destinationRect = node->destinationRect().toRect();
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
+    if (node->sourceAttachmentPoint() != m_sourceAttachmentPoint) {
+        m_sourceAttachmentPoint = node->sourceAttachmentPoint();
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
+    if (node->destinationAttachmentPoint() != m_destinationAttachmentPoint) {
+        m_destinationAttachmentPoint = node->destinationAttachmentPoint();
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
+    if (node->interpolationMethod() != m_interpolationMethod) {
+        m_interpolationMethod = node->interpolationMethod();
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
+    const QNodeId destinationNodeId = qIdForNode(node->destination());
+    if (destinationNodeId != m_destinationRenderTargetId) {
+        m_destinationRenderTargetId = destinationNodeId;
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
+    const QNodeId sourceNodeId = qIdForNode(node->source());
+    if (sourceNodeId != m_sourceRenderTargetId) {
+        m_sourceRenderTargetId = sourceNodeId;
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
 }
 
 Qt3DRender::QRenderTargetOutput::AttachmentPoint BlitFramebuffer::destinationAttachmentPoint() const
diff --git a/src/render/framegraph/blitframebuffer_p.h b/src/render/framegraph/blitframebuffer_p.h
index 796c223ca..fa9ddacd9 100644
--- a/src/render/framegraph/blitframebuffer_p.h
+++ b/src/render/framegraph/blitframebuffer_p.h
@@ -65,7 +65,7 @@ class Q_AUTOTEST_EXPORT BlitFramebuffer : public FrameGraphNode
 public:
     BlitFramebuffer();
 
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
 
     Qt3DCore::QNodeId sourceRenderTargetId() const;
 
@@ -82,8 +82,6 @@ public:
     QBlitFramebuffer::InterpolationMethod interpolationMethod() const;
 
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
-
     Qt3DCore::QNodeId m_sourceRenderTargetId;
     Qt3DCore::QNodeId m_destinationRenderTargetId;
     QRect m_sourceRect;
diff --git a/src/render/framegraph/cameraselectornode.cpp b/src/render/framegraph/cameraselectornode.cpp
index 357611c7c..482429b00 100644
--- a/src/render/framegraph/cameraselectornode.cpp
+++ b/src/render/framegraph/cameraselectornode.cpp
@@ -57,25 +57,19 @@ CameraSelector::CameraSelector()
 {
 }
 
-void CameraSelector::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
+void CameraSelector::syncFromFrontEnd(const QNode *frontEnd, bool firstTime)
 {
-    FrameGraphNode::initializeFromPeer(change);
-    const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QCameraSelectorData>>(change);
-    const auto &data = typedChange->data;
-    m_cameraUuid = data.cameraId;
-}
+    const QCameraSelector *node = qobject_cast<const QCameraSelector *>(frontEnd);
+    if (!node)
+        return;
 
-void CameraSelector::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
-{
-    qCDebug(Render::Framegraph) << Q_FUNC_INFO;
-    if (e->type() == PropertyUpdated) {
-        QPropertyUpdatedChangePtr propertyChange = qSharedPointerCast<QPropertyUpdatedChange>(e);
-        if (propertyChange->propertyName() == QByteArrayLiteral("camera")) {
-            m_cameraUuid = propertyChange->value().value<QNodeId>();
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        }
+    FrameGraphNode::syncFromFrontEnd(frontEnd, firstTime);
+
+    const QNodeId cameraId = qIdForNode(node->camera());
+    if (m_cameraUuid != cameraId) {
+        m_cameraUuid = cameraId;
+        markDirty(AbstractRenderer::FrameGraphDirty);
     }
-    FrameGraphNode::sceneChangeEvent(e);
 }
 
 QNodeId CameraSelector::cameraUuid() const
diff --git a/src/render/framegraph/cameraselectornode_p.h b/src/render/framegraph/cameraselectornode_p.h
index 0e532d68f..dd7e050d0 100644
--- a/src/render/framegraph/cameraselectornode_p.h
+++ b/src/render/framegraph/cameraselectornode_p.h
@@ -69,12 +69,11 @@ class CameraSelector : public FrameGraphNode
 public:
     CameraSelector();
 
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
     Qt3DCore::QNodeId cameraUuid() const;
 
-private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
 
+private:
     Qt3DCore::QNodeId m_cameraUuid;
 };
 
diff --git a/src/render/framegraph/clearbuffers.cpp b/src/render/framegraph/clearbuffers.cpp
index ab6225a4b..98de30906 100644
--- a/src/render/framegraph/clearbuffers.cpp
+++ b/src/render/framegraph/clearbuffers.cpp
@@ -61,42 +61,40 @@ ClearBuffers::ClearBuffers()
 {
 }
 
-void ClearBuffers::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
+void ClearBuffers::syncFromFrontEnd(const QNode *frontEnd, bool firstTime)
 {
-    FrameGraphNode::initializeFromPeer(change);
-    const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QClearBuffersData>>(change);
-    const auto &data = typedChange->data;
-    m_type = data.buffersType;
-    m_clearColorAsColor = data.clearColor;
-    m_clearColor = vec4dFromColor(m_clearColorAsColor);
-    m_clearDepthValue = data.clearDepthValue;
-    m_clearStencilValue = data.clearStencilValue;
-    m_colorBufferId = data.bufferId;
-}
+    const QClearBuffers *node = qobject_cast<const QClearBuffers *>(frontEnd);
+    if (!node)
+        return;
 
-void ClearBuffers::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
-{
-    if (e->type() == PropertyUpdated) {
-        QPropertyUpdatedChangePtr propertyChange = qSharedPointerCast<QPropertyUpdatedChange>(e);
-        if (propertyChange->propertyName() == QByteArrayLiteral("buffers")) {
-            m_type = static_cast<QClearBuffers::BufferType>(propertyChange->value().toInt());
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("clearColor")) {
-            m_clearColorAsColor = propertyChange->value().value<QColor>();
-            m_clearColor = vec4dFromColor(m_clearColorAsColor);
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("clearDepthValue")) {
-            m_clearDepthValue = propertyChange->value().toFloat();
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("clearStencilValue")) {
-            m_clearStencilValue = propertyChange->value().toInt();
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("colorBuffer")) {
-            m_colorBufferId = propertyChange->value().value<QNodeId>();
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        }
+    FrameGraphNode::syncFromFrontEnd(frontEnd, firstTime);
+
+    if (m_clearColorAsColor != node->clearColor()) {
+        m_clearColorAsColor = node->clearColor();
+        m_clearColor = vec4dFromColor(node->clearColor());
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
+
+    if (m_clearDepthValue != node->clearDepthValue()) {
+        m_clearDepthValue = node->clearDepthValue();
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
+
+    if (m_clearStencilValue != node->clearStencilValue()) {
+        m_clearStencilValue = node->clearStencilValue();
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
+
+    const QNodeId colorBufferId = qIdForNode(node->colorBuffer());
+    if (m_colorBufferId != colorBufferId) {
+        m_colorBufferId = colorBufferId;
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
+
+    if (m_type != node->buffers()) {
+        m_type = node->buffers();
+        markDirty(AbstractRenderer::FrameGraphDirty);
     }
-    FrameGraphNode::sceneChangeEvent(e);
 }
 
 QClearBuffers::BufferType ClearBuffers::type() const
diff --git a/src/render/framegraph/clearbuffers_p.h b/src/render/framegraph/clearbuffers_p.h
index e3c56c165..ca55d2a98 100644
--- a/src/render/framegraph/clearbuffers_p.h
+++ b/src/render/framegraph/clearbuffers_p.h
@@ -67,8 +67,6 @@ class ClearBuffers : public FrameGraphNode
 public:
     ClearBuffers();
 
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
-
     QClearBuffers::BufferType type() const;
     float clearDepthValue() const;
     int clearStencilValue() const;
@@ -85,10 +83,9 @@ public:
     QColor clearColorAsColor() const;
 
     bool clearsAllColorBuffers() const;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
 
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
-
     QClearBuffers::BufferType m_type;
     QVector4D m_clearColor;
     QColor m_clearColorAsColor;
diff --git a/src/render/framegraph/dispatchcompute.cpp b/src/render/framegraph/dispatchcompute.cpp
index f7e9dcff4..5eae75bc6 100644
--- a/src/render/framegraph/dispatchcompute.cpp
+++ b/src/render/framegraph/dispatchcompute.cpp
@@ -66,32 +66,26 @@ void DispatchCompute::cleanup()
     m_workGroups[2] = 1;
 }
 
-void DispatchCompute::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
+void DispatchCompute::syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime)
 {
-    FrameGraphNode::initializeFromPeer(change);
-    const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QDispatchComputeData>>(change);
-    const auto &data = typedChange->data;
-    m_workGroups[0] = data.workGroupX;
-    m_workGroups[1] = data.workGroupY;
-    m_workGroups[2] = data.workGroupZ;
-}
+    const QDispatchCompute *node = qobject_cast<const QDispatchCompute *>(frontEnd);
+    if (!node)
+        return;
 
-void DispatchCompute::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
-{
-    if (e->type() == Qt3DCore::PropertyUpdated) {
-        Qt3DCore::QPropertyUpdatedChangePtr propertyChange = qSharedPointerCast<Qt3DCore::QPropertyUpdatedChange>(e);
-        if (propertyChange->propertyName() == QByteArrayLiteral("workGroupX")) {
-            m_workGroups[0] = propertyChange->value().toInt();
-            markDirty(AbstractRenderer::FrameGraphDirty|AbstractRenderer::ComputeDirty);
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("workGroupY")) {
-            m_workGroups[1] = propertyChange->value().toInt();
-            markDirty(AbstractRenderer::FrameGraphDirty|AbstractRenderer::ComputeDirty);
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("workGroupZ")) {
-            m_workGroups[2] = propertyChange->value().toInt();
-            markDirty(AbstractRenderer::FrameGraphDirty|AbstractRenderer::ComputeDirty);
-        }
+    FrameGraphNode::syncFromFrontEnd(frontEnd, firstTime);
+
+    if (m_workGroups[0] != node->workGroupX()) {
+        m_workGroups[0] = node->workGroupX();
+        markDirty(AbstractRenderer::FrameGraphDirty|AbstractRenderer::ComputeDirty);
+    }
+    if (m_workGroups[1] != node->workGroupY()) {
+        m_workGroups[1] = node->workGroupY();
+        markDirty(AbstractRenderer::FrameGraphDirty|AbstractRenderer::ComputeDirty);
+    }
+    if (m_workGroups[2] != node->workGroupZ()) {
+        m_workGroups[2] = node->workGroupZ();
+        markDirty(AbstractRenderer::FrameGraphDirty|AbstractRenderer::ComputeDirty);
     }
-    FrameGraphNode::sceneChangeEvent(e);
 }
 
 } // Render
diff --git a/src/render/framegraph/dispatchcompute_p.h b/src/render/framegraph/dispatchcompute_p.h
index aa88a35c5..24a641938 100644
--- a/src/render/framegraph/dispatchcompute_p.h
+++ b/src/render/framegraph/dispatchcompute_p.h
@@ -68,13 +68,13 @@ public:
 
     void cleanup();
 
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
     inline int x() const Q_DECL_NOTHROW { return m_workGroups[0]; }
     inline int y() const Q_DECL_NOTHROW { return m_workGroups[1]; }
     inline int z() const Q_DECL_NOTHROW { return m_workGroups[2]; }
 
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
+
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
 
     int m_workGroups[3];
 };
diff --git a/src/render/framegraph/framegraphnode.cpp b/src/render/framegraph/framegraphnode.cpp
index 458d96d4b..93531fd7d 100644
--- a/src/render/framegraph/framegraphnode.cpp
+++ b/src/render/framegraph/framegraphnode.cpp
@@ -66,14 +66,6 @@ FrameGraphNode::~FrameGraphNode()
 {
 }
 
-void FrameGraphNode::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
-{
-    // Set up the parent child relationship and enabled state
-    const auto creationChange = qSharedPointerCast<QFrameGraphNodeCreatedChangeBase>(change);
-    setParentId(creationChange->parentFrameGraphNodeId());
-    markDirty(AbstractRenderer::FrameGraphDirty);
-}
-
 void FrameGraphNode::setFrameGraphManager(FrameGraphManager *manager)
 {
     if (m_manager != manager)
@@ -129,34 +121,33 @@ QVector<FrameGraphNode *> FrameGraphNode::children() const
     return children;
 }
 
-void FrameGraphNode::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
+void FrameGraphNode::cleanup()
 {
-    switch (e->type()) {
-
-    case Qt3DCore::PropertyUpdated: {
-        Qt3DCore::QPropertyUpdatedChangePtr propertyChange = qSharedPointerCast<Qt3DCore::QPropertyUpdatedChange>(e);
-        if (propertyChange->propertyName() == QByteArrayLiteral("enabled")) {
-            d_func()->m_enabled = propertyChange->value().toBool();
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("parentFrameGraphUpdated")) {
-            auto newParent = propertyChange->value().value<Qt3DCore::QNodeId>();
-            setParentId(newParent);
-            markDirty(AbstractRenderer::AllDirty);
-        }
-        break;
-    }
-    default:
-        markDirty(AbstractRenderer::AllDirty);
-        break;
-    }
+    setParentId({});
 }
 
-void FrameGraphNode::cleanup()
+void FrameGraphNode::syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime)
 {
-    setParentId({});
+    const QFrameGraphNode *node = qobject_cast<const QFrameGraphNode *>(frontEnd);
+
+    const auto parentId = Qt3DCore::qIdForNode(node->parentFrameGraphNode());
+    if (parentId != m_parentId) {
+        setParentId(parentId);
+        // TO DO: Check if FrameGraphDirty wouldn't be enough here
+        markDirty(AbstractRenderer::AllDirty);
+    }
+
+    if (node->isEnabled() != d_func()->m_enabled) {
+        d_func()->m_enabled = node->isEnabled();
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
+
+    if (firstTime)
+        markDirty(AbstractRenderer::FrameGraphDirty);
 }
 
 
+
 } // namespace Render
 } // namespace Qt3DRender
 
diff --git a/src/render/framegraph/framegraphnode_p.h b/src/render/framegraph/framegraphnode_p.h
index 3edd4f57d..846dc8060 100644
--- a/src/render/framegraph/framegraphnode_p.h
+++ b/src/render/framegraph/framegraphnode_p.h
@@ -121,11 +121,10 @@ public:
 
     void cleanup();
 
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
 
 protected:
     FrameGraphNode(FrameGraphNodeType nodeType, QBackendNode::Mode mode = QBackendNode::ReadOnly);
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) override;
 
 private:
     FrameGraphNodeType m_nodeType;
diff --git a/src/render/framegraph/layerfilternode.cpp b/src/render/framegraph/layerfilternode.cpp
index f9881be0d..5c53fa681 100644
--- a/src/render/framegraph/layerfilternode.cpp
+++ b/src/render/framegraph/layerfilternode.cpp
@@ -43,6 +43,7 @@
 #include <Qt3DCore/qpropertyupdatedchange.h>
 #include <Qt3DCore/qpropertynodeaddedchange.h>
 #include <Qt3DCore/qpropertynoderemovedchange.h>
+#include <algorithm>
 
 QT_BEGIN_NAMESPACE
 
@@ -57,48 +58,25 @@ LayerFilterNode::LayerFilterNode()
 {
 }
 
-void LayerFilterNode::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
+void LayerFilterNode::syncFromFrontEnd(const QNode *frontEnd, bool firstTime)
 {
-    FrameGraphNode::initializeFromPeer(change);
-    const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QLayerFilterData>>(change);
-    const auto &data = typedChange->data;
-    setLayerIds(data.layerIds);
-    m_filterMode = data.filterMode;
-}
+    const QLayerFilter *node = qobject_cast<const QLayerFilter *>(frontEnd);
+    if (!node)
+        return;
 
-void LayerFilterNode::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
-{
-    switch (e->type()) {
-    case PropertyValueAdded: {
-        const auto change = qSharedPointerCast<QPropertyNodeAddedChange>(e);
-        if (change->propertyName() == QByteArrayLiteral("layer"))
-            m_layerIds.append(change->addedNodeId());
-        markDirty(AbstractRenderer::FrameGraphDirty|AbstractRenderer::LayersDirty);
-        break;
-    }
+    FrameGraphNode::syncFromFrontEnd(frontEnd, firstTime);
 
-    case PropertyValueRemoved: {
-        const auto change = qSharedPointerCast<QPropertyNodeRemovedChange>(e);
-        if (change->propertyName() == QByteArrayLiteral("layer"))
-            m_layerIds.removeOne(change->removedNodeId());
+    if (m_filterMode != node->filterMode()) {
+        m_filterMode = node->filterMode();
         markDirty(AbstractRenderer::FrameGraphDirty|AbstractRenderer::LayersDirty);
-        break;
     }
 
-    case PropertyUpdated: {
-        const auto change = qSharedPointerCast<QPropertyUpdatedChange>(e);
-        if (change->propertyName() == QByteArrayLiteral("filterMode")) {
-            m_filterMode = static_cast<QLayerFilter::FilterMode>(change->value().value<int>());
-            markDirty(AbstractRenderer::FrameGraphDirty|AbstractRenderer::LayersDirty);
-            break;
-        }
-    }
-
-    default:
-        break;
+    auto layerIds = qIdsForNodes(node->layers());
+    std::sort(std::begin(layerIds), std::end(layerIds));
+    if (m_layerIds != layerIds) {
+        m_layerIds = layerIds;
+        markDirty(AbstractRenderer::FrameGraphDirty|AbstractRenderer::LayersDirty);
     }
-
-    FrameGraphNode::sceneChangeEvent(e);
 }
 
 QNodeIdVector LayerFilterNode::layerIds() const
diff --git a/src/render/framegraph/layerfilternode_p.h b/src/render/framegraph/layerfilternode_p.h
index 18ba4ee7a..27cdc49d3 100644
--- a/src/render/framegraph/layerfilternode_p.h
+++ b/src/render/framegraph/layerfilternode_p.h
@@ -53,6 +53,7 @@
 
 #include <Qt3DRender/private/framegraphnode_p.h>
 #include <Qt3DRender/QLayerFilter>
+#include <Qt3DRender/QLayer>
 #include <QStringList>
 
 QT_BEGIN_NAMESPACE
@@ -68,15 +69,14 @@ class LayerFilterNode : public FrameGraphNode
 public:
     LayerFilterNode();
 
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
+
     Qt3DCore::QNodeIdVector layerIds() const;
     void setLayerIds(const Qt3DCore::QNodeIdVector &list);
 
     QLayerFilter::FilterMode filterMode() const;
 
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
-
     Qt3DCore::QNodeIdVector m_layerIds;
     QLayerFilter::FilterMode m_filterMode;
 };
diff --git a/src/render/framegraph/memorybarrier.cpp b/src/render/framegraph/memorybarrier.cpp
index 59b3071ab..6bfaedda7 100644
--- a/src/render/framegraph/memorybarrier.cpp
+++ b/src/render/framegraph/memorybarrier.cpp
@@ -62,24 +62,18 @@ QMemoryBarrier::Operations MemoryBarrier::waitOperations() const
     return m_waitOperations;
 }
 
-void MemoryBarrier::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
+void MemoryBarrier::syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime)
 {
-    if (e->type() == Qt3DCore::PropertyUpdated) {
-        Qt3DCore::QPropertyUpdatedChangePtr propertyChange = qSharedPointerCast<Qt3DCore::QPropertyUpdatedChange>(e);
-        if (propertyChange->propertyName() == QByteArrayLiteral("waitOperations")) {
-            m_waitOperations = propertyChange->value().value<QMemoryBarrier::Operations>();
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        }
-    }
-    FrameGraphNode::sceneChangeEvent(e);
-}
+    const QMemoryBarrier *node = qobject_cast<const QMemoryBarrier *>(frontEnd);
+    if (!node)
+        return;
 
-void MemoryBarrier::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
-{
-    FrameGraphNode::initializeFromPeer(change);
-    const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QMemoryBarrierData>>(change);
-    const QMemoryBarrierData &data = typedChange->data;
-    m_waitOperations = data.waitOperations;
+    FrameGraphNode::syncFromFrontEnd(frontEnd, firstTime);
+
+    if (node->waitOperations() != m_waitOperations) {
+        m_waitOperations = node->waitOperations();
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
 }
 
 } // Render
diff --git a/src/render/framegraph/memorybarrier_p.h b/src/render/framegraph/memorybarrier_p.h
index e0fd3e9cd..ce545cd09 100644
--- a/src/render/framegraph/memorybarrier_p.h
+++ b/src/render/framegraph/memorybarrier_p.h
@@ -67,10 +67,9 @@ public:
     ~MemoryBarrier();
 
     QMemoryBarrier::Operations waitOperations() const;
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
 
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
     QMemoryBarrier::Operations m_waitOperations;
 };
 
diff --git a/src/render/framegraph/proximityfilter.cpp b/src/render/framegraph/proximityfilter.cpp
index cdfd7e51e..593e541bc 100644
--- a/src/render/framegraph/proximityfilter.cpp
+++ b/src/render/framegraph/proximityfilter.cpp
@@ -53,29 +53,24 @@ ProximityFilter::ProximityFilter()
 {
 }
 
-void ProximityFilter::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
+void ProximityFilter::syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime)
 {
-    FrameGraphNode::initializeFromPeer(change);
-    const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QProximityFilterData>>(change);
-    const QProximityFilterData &data = typedChange->data;
-    m_entityId = data.entityId;
-    m_distanceThreshold = data.distanceThreshold;
-}
+    const QProximityFilter *node = qobject_cast<const QProximityFilter *>(frontEnd);
+    if (!node)
+        return;
 
-void ProximityFilter::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
-{
-    qCDebug(Render::Framegraph) << Q_FUNC_INFO;
-    if (e->type() == Qt3DCore::PropertyUpdated) {
-        Qt3DCore::QPropertyUpdatedChangePtr propertyChange = qSharedPointerCast<Qt3DCore::QPropertyUpdatedChange>(e);
-        if (propertyChange->propertyName() == QByteArrayLiteral("entity")) {
-            m_entityId = propertyChange->value().value<Qt3DCore::QNodeId>();
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("distanceThreshold")) {
-            m_distanceThreshold = propertyChange->value().toFloat();
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        }
+    FrameGraphNode::syncFromFrontEnd(frontEnd, firstTime);
+
+    const auto entityId = Qt3DCore::qIdForNode(node->entity());
+    if (entityId != m_entityId) {
+        m_entityId = entityId;
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
+
+    if (node->distanceThreshold() != m_distanceThreshold) {
+        m_distanceThreshold = node->distanceThreshold();
+        markDirty(AbstractRenderer::FrameGraphDirty);
     }
-    FrameGraphNode::sceneChangeEvent(e);
 }
 
 } // namespace Render
diff --git a/src/render/framegraph/proximityfilter_p.h b/src/render/framegraph/proximityfilter_p.h
index e57b53dea..5c2f7ad66 100644
--- a/src/render/framegraph/proximityfilter_p.h
+++ b/src/render/framegraph/proximityfilter_p.h
@@ -64,7 +64,7 @@ class Q_AUTOTEST_EXPORT ProximityFilter : public FrameGraphNode
 public:
     ProximityFilter();
 
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
 
     float distanceThreshold() const { return m_distanceThreshold; }
     Qt3DCore::QNodeId entityId() const { return m_entityId; }
@@ -76,8 +76,6 @@ public:
 #endif
 
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
-
     float m_distanceThreshold;
     Qt3DCore::QNodeId m_entityId;
 };
diff --git a/src/render/framegraph/qblitframebuffer.cpp b/src/render/framegraph/qblitframebuffer.cpp
index d0e1bdbf3..bf9e547cb 100644
--- a/src/render/framegraph/qblitframebuffer.cpp
+++ b/src/render/framegraph/qblitframebuffer.cpp
@@ -364,6 +364,7 @@ void QBlitFramebuffer::setDestination(QRenderTarget *destination)
     }
 }
 
+// TO DO Qt6: convert QRectF to QRect
 /*!
     Sets the source rectangle to \a inputRect. The coordinates are assumed to
     follow the normal Qt coordinate system, meaning Y runs from top to bottom.
diff --git a/src/render/framegraph/qframegraphnode.cpp b/src/render/framegraph/qframegraphnode.cpp
index d52b728a8..1ef81a081 100644
--- a/src/render/framegraph/qframegraphnode.cpp
+++ b/src/render/framegraph/qframegraphnode.cpp
@@ -258,13 +258,9 @@ Qt3DCore::QNodeCreatedChangeBasePtr QFrameGraphNode::createNodeCreationChange()
 
 void QFrameGraphNode::onParentChanged(QObject *)
 {
-    const auto parentID = parentFrameGraphNode() ? parentFrameGraphNode()->id() : Qt3DCore::QNodeId();
-    auto parentChange = Qt3DCore::QPropertyUpdatedChangePtr::create(id());
-    parentChange->setPropertyName("parentFrameGraphUpdated");
-    parentChange->setValue(QVariant::fromValue(parentID));
-    const bool blocked = blockNotifications(false);
-    notifyObservers(parentChange);
-    blockNotifications(blocked);
+    // Direct sync update request
+    Q_D(QFrameGraphNode);
+    d->update();
 }
 
 } // namespace Qt3DRender
diff --git a/src/render/framegraph/qlayerfilter.cpp b/src/render/framegraph/qlayerfilter.cpp
index 04ebca572..8b0dd5669 100644
--- a/src/render/framegraph/qlayerfilter.cpp
+++ b/src/render/framegraph/qlayerfilter.cpp
@@ -206,11 +206,7 @@ void QLayerFilter::addLayer(QLayer *layer)
         if (!layer->parent())
             layer->setParent(this);
 
-        if (d->m_changeArbiter != nullptr) {
-            const auto change = Qt3DCore::QPropertyNodeAddedChangePtr::create(id(), layer);
-            change->setPropertyName("layer");
-            d->notifyObservers(change);
-        }
+        d->update();
     }
 }
 
@@ -221,11 +217,7 @@ void QLayerFilter::removeLayer(QLayer *layer)
 {
     Q_ASSERT(layer);
     Q_D(QLayerFilter);
-    if (d->m_changeArbiter != nullptr) {
-        const auto change = Qt3DCore::QPropertyNodeRemovedChangePtr::create(id(), layer);
-        change->setPropertyName("layer");
-        d->notifyObservers(change);
-    }
+    d->update();
     d->m_layers.removeOne(layer);
     // Remove bookkeeping connection
     d->unregisterDestructionHelper(layer);
diff --git a/src/render/framegraph/qrendercapture.cpp b/src/render/framegraph/qrendercapture.cpp
index 21eee51f6..cc74553b2 100644
--- a/src/render/framegraph/qrendercapture.cpp
+++ b/src/render/framegraph/qrendercapture.cpp
@@ -330,11 +330,9 @@ QRenderCaptureReply *QRenderCapture::requestCapture(int captureId)
         d->replyDestroyed(reply);
     });
 
-    Qt3DCore::QPropertyUpdatedChangePtr change(new Qt3DCore::QPropertyUpdatedChange(id()));
-    change->setPropertyName(QByteArrayLiteral("renderCaptureRequest"));
     const QRenderCaptureRequest request = { captureId, QRect() };
-    change->setValue(QVariant::fromValue(request));
-    d->notifyObservers(change);
+    d->m_pendingRequests.push_back(request);
+    d->update();
 
     return reply;
 }
@@ -355,11 +353,9 @@ QRenderCaptureReply *QRenderCapture::requestCapture(const QRect &rect)
         d->replyDestroyed(reply);
     });
 
-    Qt3DCore::QPropertyUpdatedChangePtr change(new Qt3DCore::QPropertyUpdatedChange(id()));
-    change->setPropertyName(QByteArrayLiteral("renderCaptureRequest"));
     const QRenderCaptureRequest request = { captureId, rect };
-    change->setValue(QVariant::fromValue(request));
-    d->notifyObservers(change);
+    d->m_pendingRequests.push_back(request);
+    d->update();
 
     captureId++;
 
diff --git a/src/render/framegraph/qrendercapture_p.h b/src/render/framegraph/qrendercapture_p.h
index 4e509cc59..3dec4d280 100644
--- a/src/render/framegraph/qrendercapture_p.h
+++ b/src/render/framegraph/qrendercapture_p.h
@@ -57,6 +57,12 @@ QT_BEGIN_NAMESPACE
 
 namespace Qt3DRender {
 
+struct QRenderCaptureRequest
+{
+    int captureId;
+    QRect rect;
+};
+
 class QRenderCapturePrivate : public QFrameGraphNodePrivate
 {
 public:
@@ -64,6 +70,7 @@ public:
     ~QRenderCapturePrivate();
     QVector<QRenderCaptureReply *> m_waitingReplies;
     QMutex m_mutex;
+    mutable QVector<QRenderCaptureRequest> m_pendingRequests;
 
     QRenderCaptureReply *createReply(int captureId);
     QRenderCaptureReply *takeReply(int captureId);
@@ -82,6 +89,7 @@ public:
     int m_captureId;
     bool m_complete;
 
+
     Q_DECLARE_PUBLIC(QRenderCaptureReply)
 };
 
@@ -100,12 +108,6 @@ struct RenderCaptureData
 
 typedef QSharedPointer<RenderCaptureData> RenderCaptureDataPtr;
 
-struct QRenderCaptureRequest
-{
-    int captureId;
-    QRect rect;
-};
-
 } // Qt3DRender
 
 QT_END_NAMESPACE
diff --git a/src/render/framegraph/qrenderpassfilter.cpp b/src/render/framegraph/qrenderpassfilter.cpp
index 56c229d9c..4ef7e6d2d 100644
--- a/src/render/framegraph/qrenderpassfilter.cpp
+++ b/src/render/framegraph/qrenderpassfilter.cpp
@@ -142,11 +142,7 @@ void QRenderPassFilter::addMatch(QFilterKey *filterKey)
         if (!filterKey->parent())
             filterKey->setParent(this);
 
-        if (d->m_changeArbiter != nullptr) {
-            const auto change = QPropertyNodeAddedChangePtr::create(id(), filterKey);
-            change->setPropertyName("match");
-            d->notifyObservers(change);
-        }
+        d->update();
     }
 }
 
@@ -158,11 +154,7 @@ void QRenderPassFilter::removeMatch(QFilterKey *filterKey)
     Q_ASSERT(filterKey);
     Q_D(QRenderPassFilter);
 
-    if (d->m_changeArbiter != nullptr) {
-        const auto change = QPropertyNodeRemovedChangePtr::create(id(), filterKey);
-        change->setPropertyName("match");
-        d->notifyObservers(change);
-    }
+    d->update();
     d->m_matchList.removeOne(filterKey);
     // Remove bookkeeping connection
     d->unregisterDestructionHelper(filterKey);
@@ -188,11 +180,7 @@ void QRenderPassFilter::addParameter(QParameter *parameter)
         if (!parameter->parent())
             parameter->setParent(this);
 
-        if (d->m_changeArbiter != nullptr) {
-            const auto change = QPropertyNodeAddedChangePtr::create(id(), parameter);
-            change->setPropertyName("parameter");
-            d->notifyObservers(change);
-        }
+        d->update();
     }
 }
 
@@ -204,11 +192,7 @@ void QRenderPassFilter::removeParameter(QParameter *parameter)
     Q_ASSERT(parameter);
     Q_D(QRenderPassFilter);
 
-    if (d->m_changeArbiter != nullptr) {
-        const auto change = QPropertyNodeRemovedChangePtr::create(id(), parameter);
-        change->setPropertyName("parameter");
-        d->notifyObservers(change);
-    }
+    d->update();
     d->m_parameters.removeOne(parameter);
     // Remove bookkeeping connection
     d->unregisterDestructionHelper(parameter);
diff --git a/src/render/framegraph/qrenderstateset.cpp b/src/render/framegraph/qrenderstateset.cpp
index 6f70456ab..d558a939e 100644
--- a/src/render/framegraph/qrenderstateset.cpp
+++ b/src/render/framegraph/qrenderstateset.cpp
@@ -194,11 +194,7 @@ void QRenderStateSet::addRenderState(QRenderState *state)
         if (!state->parent())
             state->setParent(this);
 
-        if (d->m_changeArbiter != nullptr) {
-            const auto change = QPropertyNodeAddedChangePtr::create(id(), state);
-            change->setPropertyName("renderState");
-            d->notifyObservers(change);
-        }
+        d->update();
     }
 }
 
@@ -210,11 +206,7 @@ void QRenderStateSet::removeRenderState(QRenderState *state)
     Q_ASSERT(state);
     Q_D(QRenderStateSet);
 
-    if (d->m_changeArbiter != nullptr) {
-        const auto change = QPropertyNodeRemovedChangePtr::create(id(), state);
-        change->setPropertyName("renderState");
-        d->notifyObservers(change);
-    }
+    d->update();
     d->m_renderStates.removeOne(state);
     // Remove bookkeeping connection
     d->unregisterDestructionHelper(state);
diff --git a/src/render/framegraph/qrendersurfaceselector.cpp b/src/render/framegraph/qrendersurfaceselector.cpp
index 848d86f53..765aa1824 100644
--- a/src/render/framegraph/qrendersurfaceselector.cpp
+++ b/src/render/framegraph/qrendersurfaceselector.cpp
@@ -253,24 +253,10 @@ void QRenderSurfaceSelector::setSurface(QObject *surfaceObject)
 
             if (window) {
                 d->m_widthConn = QObject::connect(window, &QWindow::widthChanged, [=] (int width) {
-                    if (d->m_changeArbiter != nullptr) {
-                        Qt3DCore::QPropertyUpdatedChangePtr change(
-                                    new Qt3DCore::QPropertyUpdatedChange(id()));
-
-                        change->setPropertyName("width");
-                        change->setValue(QVariant::fromValue(width));
-                        d->notifyObservers(change);
-                    }
+                    d->update();
                 });
                 d->m_heightConn = QObject::connect(window, &QWindow::heightChanged, [=] (int height) {
-                    if (d->m_changeArbiter != nullptr) {
-                        Qt3DCore::QPropertyUpdatedChangePtr change(
-                                    new Qt3DCore::QPropertyUpdatedChange(id()));
-
-                        change->setPropertyName("height");
-                        change->setValue(QVariant::fromValue(height));
-                        d->notifyObservers(change);
-                    }
+                    d->update();
                 });
                 d->m_screenConn = QObject::connect(window, &QWindow::screenChanged, [=] (QScreen *screen) {
                     if (screen && surfacePixelRatio() != screen->devicePixelRatio())
diff --git a/src/render/framegraph/qrendertargetselector.cpp b/src/render/framegraph/qrendertargetselector.cpp
index 1b4afc7e6..f4d95d507 100644
--- a/src/render/framegraph/qrendertargetselector.cpp
+++ b/src/render/framegraph/qrendertargetselector.cpp
@@ -153,13 +153,7 @@ void QRenderTargetSelector::setOutputs(const QVector<QRenderTargetOutput::Attach
     Q_D(QRenderTargetSelector);
     if (buffers != d->m_outputs) {
         d->m_outputs = buffers;
-
-        if (d->m_changeArbiter) {
-            auto change = QPropertyUpdatedChangePtr::create(d->m_id);
-            change->setPropertyName("outputs");
-            change->setValue(QVariant::fromValue(d->m_outputs));
-            d->notifyObservers(change);
-        }
+        d->update();
     }
 }
 
diff --git a/src/render/framegraph/qsortpolicy.cpp b/src/render/framegraph/qsortpolicy.cpp
index 6f852afbd..c8e3d23c5 100644
--- a/src/render/framegraph/qsortpolicy.cpp
+++ b/src/render/framegraph/qsortpolicy.cpp
@@ -178,7 +178,10 @@ void QSortPolicy::setSortTypes(const QVector<SortType> &sortTypes)
     if (sortTypes != d->m_sortTypes) {
         d->m_sortTypes = sortTypes;
         emit sortTypesChanged(sortTypes);
+
+        const bool wasBlocked = blockNotifications(true);
         emit sortTypesChanged(sortTypesInt());
+        blockNotifications(wasBlocked);
     }
 }
 
diff --git a/src/render/framegraph/qtechniquefilter.cpp b/src/render/framegraph/qtechniquefilter.cpp
index 404ad6991..28b151fc7 100644
--- a/src/render/framegraph/qtechniquefilter.cpp
+++ b/src/render/framegraph/qtechniquefilter.cpp
@@ -147,11 +147,7 @@ void QTechniqueFilter::addMatch(QFilterKey *filterKey)
         if (!filterKey->parent())
             filterKey->setParent(this);
 
-        if (d->m_changeArbiter != nullptr) {
-            const auto change = QPropertyNodeAddedChangePtr::create(id(), filterKey);
-            change->setPropertyName("matchAll");
-            d->notifyObservers(change);
-        }
+        d->update();
     }
 }
 
@@ -162,11 +158,7 @@ void QTechniqueFilter::removeMatch(QFilterKey *filterKey)
 {
     Q_ASSERT(filterKey);
     Q_D(QTechniqueFilter);
-    if (d->m_changeArbiter != nullptr) {
-        const auto change = QPropertyNodeRemovedChangePtr::create(id(), filterKey);
-        change->setPropertyName("matchAll");
-        d->notifyObservers(change);
-    }
+    d->update();
     d->m_matchList.removeOne(filterKey);
     // Remove bookkeeping connection
     d->unregisterDestructionHelper(filterKey);
@@ -192,11 +184,7 @@ void QTechniqueFilter::addParameter(QParameter *parameter)
         if (!parameter->parent())
             parameter->setParent(this);
 
-        if (d->m_changeArbiter != nullptr) {
-            const auto change = QPropertyNodeAddedChangePtr::create(id(), parameter);
-            change->setPropertyName("parameter");
-            d->notifyObservers(change);
-        }
+        d->update();
     }
 }
 
@@ -207,11 +195,7 @@ void QTechniqueFilter::removeParameter(QParameter *parameter)
 {
     Q_ASSERT(parameter);
     Q_D(QTechniqueFilter);
-    if (d->m_changeArbiter != nullptr) {
-        const auto change = QPropertyNodeRemovedChangePtr::create(id(), parameter);
-        change->setPropertyName("parameter");
-        d->notifyObservers(change);
-    }
+    d->update();
     d->m_parameters.removeOne(parameter);
     // Remove bookkeeping connection
     d->unregisterDestructionHelper(parameter);
diff --git a/src/render/framegraph/rendercapture.cpp b/src/render/framegraph/rendercapture.cpp
index 166294889..68d62b6a5 100644
--- a/src/render/framegraph/rendercapture.cpp
+++ b/src/render/framegraph/rendercapture.cpp
@@ -70,16 +70,23 @@ QRenderCaptureRequest RenderCapture::takeCaptureRequest()
     return m_requestedCaptures.takeFirst();
 }
 
-void RenderCapture::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
+void RenderCapture::syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime)
 {
-    if (e->type() == Qt3DCore::PropertyUpdated) {
-        Qt3DCore::QPropertyUpdatedChangePtr propertyChange = qSharedPointerCast<Qt3DCore::QPropertyUpdatedChange>(e);
-        if (propertyChange->propertyName() == QByteArrayLiteral("renderCaptureRequest")) {
-            requestCapture(propertyChange->value().value<QRenderCaptureRequest>());
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        }
+    const QRenderCapture *node = qobject_cast<const QRenderCapture *>(frontEnd);
+    if (!node)
+        return;
+
+    FrameGraphNode::syncFromFrontEnd(frontEnd, firstTime);
+
+    const QRenderCapturePrivate *d = static_cast<const QRenderCapturePrivate *>(QFrameGraphNodePrivate::get(node));
+    const auto newPendingsCaptures = std::move(d->m_pendingRequests);
+    if (newPendingsCaptures.size() > 0) {
+        m_requestedCaptures.append(newPendingsCaptures);
+        markDirty(AbstractRenderer::FrameGraphDirty);
     }
-    FrameGraphNode::sceneChangeEvent(e);
+
+    if (firstTime)
+        markDirty(AbstractRenderer::FrameGraphDirty);
 }
 
 // called by render thread
diff --git a/src/render/framegraph/rendercapture_p.h b/src/render/framegraph/rendercapture_p.h
index 71fa01ec1..4560c525d 100644
--- a/src/render/framegraph/rendercapture_p.h
+++ b/src/render/framegraph/rendercapture_p.h
@@ -68,8 +68,7 @@ public:
     void addRenderCapture(int captureId, const QImage &image);
     void sendRenderCaptures();
 
-protected:
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) final;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
 
 private:
 
diff --git a/src/render/framegraph/renderpassfilternode.cpp b/src/render/framegraph/renderpassfilternode.cpp
index e3da1e36d..afc49a563 100644
--- a/src/render/framegraph/renderpassfilternode.cpp
+++ b/src/render/framegraph/renderpassfilternode.cpp
@@ -58,16 +58,33 @@ RenderPassFilter::RenderPassFilter()
 {
 }
 
-void RenderPassFilter::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
+void RenderPassFilter::syncFromFrontEnd(const QNode *frontEnd, bool firstTime)
 {
-    FrameGraphNode::initializeFromPeer(change);
-    const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QRenderPassFilterData>>(change);
-    const auto &data = typedChange->data;
-    m_filters = data.matchIds;
-    m_parameterPack.clear();
-    m_parameterPack.setParameters(data.parameterIds);
+    const QRenderPassFilter *node = qobject_cast<const QRenderPassFilter *>(frontEnd);
+    if (!node)
+        return;
+
+    FrameGraphNode::syncFromFrontEnd(frontEnd, firstTime);
+
+    if (firstTime)
+        m_parameterPack.clear();
+
+    auto parameters = qIdsForNodes(node->parameters());
+    std::sort(std::begin(parameters), std::end(parameters));
+    if (m_parameterPack.parameters() != parameters) {
+        m_parameterPack.setParameters(parameters);
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
+
+    auto filterIds = qIdsForNodes(node->matchAny());
+    std::sort(std::begin(filterIds), std::end(filterIds));
+    if (m_filters != filterIds) {
+        m_filters = filterIds;
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
 }
 
+
 QVector<Qt3DCore::QNodeId> RenderPassFilter::filters() const
 {
     return m_filters;
@@ -89,40 +106,6 @@ QVector<Qt3DCore::QNodeId> RenderPassFilter::parameters() const
     return m_parameterPack.parameters();
 }
 
-void RenderPassFilter::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
-{
-
-    switch (e->type()) {
-    case PropertyValueAdded: {
-        const auto change = qSharedPointerCast<QPropertyNodeAddedChange>(e);
-        if (change->propertyName() == QByteArrayLiteral("match")) {
-            appendFilter(change->addedNodeId());
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        } else if (change->propertyName() == QByteArrayLiteral("parameter")) {
-            m_parameterPack.appendParameter(change->addedNodeId());
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        }
-        break;
-    }
-
-    case PropertyValueRemoved: {
-        const auto change = qSharedPointerCast<QPropertyNodeRemovedChange>(e);
-        if (change->propertyName() == QByteArrayLiteral("match")) {
-            removeFilter(change->removedNodeId());
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        } else if (change->propertyName() == QByteArrayLiteral("parameter")) {
-            m_parameterPack.removeParameter(change->removedNodeId());
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        }
-        break;
-    }
-
-    default:
-        break;
-    }
-    FrameGraphNode::sceneChangeEvent(e);
-}
-
 } // namespace Render
 } // namespace Qt3DRender
 
diff --git a/src/render/framegraph/renderpassfilternode_p.h b/src/render/framegraph/renderpassfilternode_p.h
index 398d42049..157a162bb 100644
--- a/src/render/framegraph/renderpassfilternode_p.h
+++ b/src/render/framegraph/renderpassfilternode_p.h
@@ -76,11 +76,9 @@ public:
     QVector<Qt3DCore::QNodeId> parameters() const;
     void appendFilter(Qt3DCore::QNodeId criterionId);
     void removeFilter(Qt3DCore::QNodeId criterionId);
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
 
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
-
     QVector<Qt3DCore::QNodeId> m_filters;
     ParameterPack m_parameterPack;
 };
diff --git a/src/render/framegraph/rendersurfaceselector.cpp b/src/render/framegraph/rendersurfaceselector.cpp
index 16a1199b5..173da77d6 100644
--- a/src/render/framegraph/rendersurfaceselector.cpp
+++ b/src/render/framegraph/rendersurfaceselector.cpp
@@ -73,6 +73,7 @@ namespace Render {
 
 RenderSurfaceSelector::RenderSurfaceSelector()
     : FrameGraphNode(FrameGraphNode::Surface)
+    , m_surfaceObj(nullptr)
     , m_surface(nullptr)
     , m_width(0)
     , m_height(0)
@@ -80,45 +81,41 @@ RenderSurfaceSelector::RenderSurfaceSelector()
 {
 }
 
-void RenderSurfaceSelector::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
+void RenderSurfaceSelector::syncFromFrontEnd(const QNode *frontEnd, bool firstTime)
 {
-    FrameGraphNode::initializeFromPeer(change);
-    const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QRenderSurfaceSelectorData>>(change);
-    const auto &data = typedChange->data;
-    m_surface = surfaceFromQObject(data.surface);
-    m_renderTargetSize = data.externalRenderTargetSize;
-    m_devicePixelRatio = data.surfacePixelRatio;
+    const QRenderSurfaceSelector *node = qobject_cast<const QRenderSurfaceSelector *>(frontEnd);
+    if (!node)
+        return;
 
-    if (m_surface && m_surface->surfaceClass() == QSurface::Window) {
-        QWindow *window = static_cast<QWindow *>(m_surface);
-        m_width = window->width();
-        m_height = window->height();
+    FrameGraphNode::syncFromFrontEnd(frontEnd, firstTime);
+
+    if (node->surface() != m_surfaceObj) {
+        m_surfaceObj = node->surface();
+        m_surface = surfaceFromQObject(m_surfaceObj);
+        markDirty(AbstractRenderer::FrameGraphDirty);
     }
-}
 
-void RenderSurfaceSelector::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
-{
-    qCDebug(Render::Framegraph) << Q_FUNC_INFO;
-    if (e->type() == PropertyUpdated) {
-        QPropertyUpdatedChangePtr propertyChange = qSharedPointerCast<QPropertyUpdatedChange>(e);
-        if (propertyChange->propertyName() == QByteArrayLiteral("surface")) {
-            m_surface = surfaceFromQObject(propertyChange->value().value<QObject *>());
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("externalRenderTargetSize")) {
-            setRenderTargetSize(propertyChange->value().toSize());
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("width")) {
-            m_width = propertyChange->value().toInt();
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("height")) {
-            m_height = propertyChange->value().toInt();
+    if (m_surface && m_surface->surfaceClass() == QSurface::Window) {
+        QWindow *window = static_cast<QWindow *>(m_surface);
+        if (window->width() != m_width) {
+            m_width = window->width();
             markDirty(AbstractRenderer::FrameGraphDirty);
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("surfacePixelRatio")) {
-            m_devicePixelRatio = propertyChange->value().toFloat();
+        }
+        if (window->height() != m_height) {
+            m_height = window->height();
             markDirty(AbstractRenderer::FrameGraphDirty);
         }
     }
-    FrameGraphNode::sceneChangeEvent(e);
+
+    if (node->externalRenderTargetSize() != m_renderTargetSize) {
+        m_renderTargetSize = node->externalRenderTargetSize();
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
+
+    if (node->surfacePixelRatio() != m_devicePixelRatio) {
+        m_devicePixelRatio = node->surfacePixelRatio();
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
 }
 
 QSize RenderSurfaceSelector::renderTargetSize() const
diff --git a/src/render/framegraph/rendersurfaceselector_p.h b/src/render/framegraph/rendersurfaceselector_p.h
index 74863aa36..f1a139e84 100644
--- a/src/render/framegraph/rendersurfaceselector_p.h
+++ b/src/render/framegraph/rendersurfaceselector_p.h
@@ -68,7 +68,7 @@ public:
     QSize renderTargetSize() const;
     void setRenderTargetSize(const QSize &size) { m_renderTargetSize = size; }
 
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
 
     QSurface *surface() const { return m_surface; }
     inline int width() const Q_DECL_NOTHROW { return m_width; }
@@ -76,8 +76,7 @@ public:
     inline float devicePixelRatio() const Q_DECL_NOTHROW { return m_devicePixelRatio; }
 
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
-
+    QObject *m_surfaceObj;
     QSurface *m_surface;
     QSize m_renderTargetSize;
     int m_width;
diff --git a/src/render/framegraph/rendertargetselectornode.cpp b/src/render/framegraph/rendertargetselectornode.cpp
index 615608bd2..871a00154 100644
--- a/src/render/framegraph/rendertargetselectornode.cpp
+++ b/src/render/framegraph/rendertargetselectornode.cpp
@@ -59,29 +59,24 @@ RenderTargetSelector::RenderTargetSelector() :
 {
 }
 
-void RenderTargetSelector::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
+void RenderTargetSelector::syncFromFrontEnd(const QNode *frontEnd, bool firstTime)
 {
-    FrameGraphNode::initializeFromPeer(change);
-    const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QRenderTargetSelectorData>>(change);
-    const auto &data = typedChange->data;
-    m_renderTargetUuid = data.targetId;
-    m_outputs = data.outputs;
-}
+    const QRenderTargetSelector *node = qobject_cast<const QRenderTargetSelector *>(frontEnd);
+    if (!node)
+        return;
 
-void RenderTargetSelector::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
-{
-    qCDebug(Render::Framegraph) << Q_FUNC_INFO;
-    if (e->type() == PropertyUpdated) {
-        QPropertyUpdatedChangePtr propertyChange = qSharedPointerCast<QPropertyUpdatedChange>(e);
-        if (propertyChange->propertyName() == QByteArrayLiteral("target")) {
-            m_renderTargetUuid = propertyChange->value().value<QNodeId>();
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("outputs")) {
-            m_outputs = propertyChange->value().value<QVector<Qt3DRender::QRenderTargetOutput::AttachmentPoint> >();
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        }
+    FrameGraphNode::syncFromFrontEnd(frontEnd, firstTime);
+
+    const QNodeId renderTargetId = qIdForNode(node->target());
+    if (renderTargetId != m_renderTargetUuid) {
+        m_renderTargetUuid = renderTargetId;
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
+
+    if (node->outputs() != m_outputs) {
+        m_outputs = node->outputs();
+        markDirty(AbstractRenderer::FrameGraphDirty);
     }
-    FrameGraphNode::sceneChangeEvent(e);
 }
 
 } // namespace Render
diff --git a/src/render/framegraph/rendertargetselectornode_p.h b/src/render/framegraph/rendertargetselectornode_p.h
index 81ac8a3d3..232ee9ecc 100644
--- a/src/render/framegraph/rendertargetselectornode_p.h
+++ b/src/render/framegraph/rendertargetselectornode_p.h
@@ -66,14 +66,12 @@ class RenderTargetSelector : public FrameGraphNode
 public:
     RenderTargetSelector();
 
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
 
     Qt3DCore::QNodeId renderTargetUuid() const { return m_renderTargetUuid; }
     QVector<QRenderTargetOutput::AttachmentPoint> outputs() const { return m_outputs; }
 
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
-
     Qt3DCore::QNodeId m_renderTargetUuid;
     QVector<QRenderTargetOutput::AttachmentPoint> m_outputs;
 };
diff --git a/src/render/framegraph/sortpolicy.cpp b/src/render/framegraph/sortpolicy.cpp
index b81d1f6cb..3c7975945 100644
--- a/src/render/framegraph/sortpolicy.cpp
+++ b/src/render/framegraph/sortpolicy.cpp
@@ -53,18 +53,19 @@ SortPolicy::SortPolicy()
 {
 }
 
-void SortPolicy::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
+void SortPolicy::syncFromFrontEnd(const QNode *frontEnd, bool firstTime)
 {
-    if (e->type() == Qt3DCore::PropertyUpdated) {
-        Qt3DCore::QPropertyUpdatedChangePtr propertyChange = qSharedPointerCast<Qt3DCore::QPropertyUpdatedChange>(e);
-        if (propertyChange->propertyName() == QByteArrayLiteral("sortTypes")) {
-            auto sortTypesInt = propertyChange->value().value<QVector<int>>();
-            m_sortTypes.clear();
-            transformVector(sortTypesInt, m_sortTypes);
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        }
+    const QSortPolicy *node = qobject_cast<const QSortPolicy *>(frontEnd);
+    if (!node)
+        return;
+
+    FrameGraphNode::syncFromFrontEnd(frontEnd, firstTime);
+
+    const auto sortTypes = node->sortTypes();
+    if (sortTypes != m_sortTypes) {
+        m_sortTypes = sortTypes;
+        markDirty(AbstractRenderer::FrameGraphDirty);
     }
-    FrameGraphNode::sceneChangeEvent(e);
 }
 
 QVector<QSortPolicy::SortType> SortPolicy::sortTypes() const
@@ -72,14 +73,6 @@ QVector<QSortPolicy::SortType> SortPolicy::sortTypes() const
     return m_sortTypes;
 }
 
-void SortPolicy::initializeFromPeer(const QNodeCreatedChangeBasePtr &change)
-{
-    FrameGraphNode::initializeFromPeer(change);
-    const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QSortPolicyData>>(change);
-    const QSortPolicyData &data = typedChange->data;
-    m_sortTypes = data.sortTypes;
-}
-
 } // namepace Render
 } // namespace Qt3DRender
 
diff --git a/src/render/framegraph/sortpolicy_p.h b/src/render/framegraph/sortpolicy_p.h
index ef928af7b..8d572ead7 100644
--- a/src/render/framegraph/sortpolicy_p.h
+++ b/src/render/framegraph/sortpolicy_p.h
@@ -65,13 +65,11 @@ class Q_AUTOTEST_EXPORT SortPolicy : public FrameGraphNode
 public:
     SortPolicy();
 
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
 
     QVector<Qt3DRender::QSortPolicy::SortType> sortTypes() const;
 
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
-
     QVector<Qt3DRender::QSortPolicy::SortType> m_sortTypes;
 };
 
diff --git a/src/render/framegraph/statesetnode.cpp b/src/render/framegraph/statesetnode.cpp
index 96551684e..32ac5e569 100644
--- a/src/render/framegraph/statesetnode.cpp
+++ b/src/render/framegraph/statesetnode.cpp
@@ -68,40 +68,20 @@ QVector<QNodeId> StateSetNode::renderStates() const
     return m_renderStates;
 }
 
-void StateSetNode::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
+void StateSetNode::syncFromFrontEnd(const QNode *frontEnd, bool firstTime)
 {
-    FrameGraphNode::initializeFromPeer(change);
-    const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QRenderStateSetData>>(change);
-    const auto &data = typedChange->data;
-    for (const auto &stateId : qAsConst(data.renderStateIds))
-        addRenderState(stateId);
-}
+    const QRenderStateSet *node = qobject_cast<const QRenderStateSet *>(frontEnd);
+    if (!node)
+        return;
 
-void StateSetNode::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
-{
-    switch (e->type()) {
-    case PropertyValueAdded: {
-        const auto change = qSharedPointerCast<QPropertyNodeAddedChange>(e);
-        if (change->propertyName() == QByteArrayLiteral("renderState")) {
-            addRenderState(change->addedNodeId());
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        }
-        break;
-    }
-
-    case PropertyValueRemoved: {
-        const auto propertyChange = qSharedPointerCast<QPropertyNodeRemovedChange>(e);
-        if (propertyChange->propertyName() == QByteArrayLiteral("renderState")) {
-            removeRenderState(propertyChange->removedNodeId());
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        }
-        break;
-    }
+    FrameGraphNode::syncFromFrontEnd(frontEnd, firstTime);
 
-    default:
-        break;
+    auto stateIds = qIdsForNodes(node->renderStates());
+    std::sort(std::begin(stateIds), std::end(stateIds));
+    if (m_renderStates != stateIds) {
+        m_renderStates = stateIds;
+        markDirty(AbstractRenderer::FrameGraphDirty);
     }
-    FrameGraphNode::sceneChangeEvent(e);
 }
 
 void StateSetNode::addRenderState(QNodeId renderStateId)
diff --git a/src/render/framegraph/statesetnode_p.h b/src/render/framegraph/statesetnode_p.h
index d33e118cb..5081f3215 100644
--- a/src/render/framegraph/statesetnode_p.h
+++ b/src/render/framegraph/statesetnode_p.h
@@ -68,13 +68,13 @@ public:
     inline bool hasRenderStates() const { return !m_renderStates.empty(); }
     QVector<Qt3DCore::QNodeId> renderStates() const;
 
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
+
 protected:
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
     void addRenderState(Qt3DCore::QNodeId renderStateId);
     void removeRenderState(Qt3DCore::QNodeId renderStateId);
 
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
     QVector<Qt3DCore::QNodeId> m_renderStates;
 };
 
diff --git a/src/render/framegraph/techniquefilternode.cpp b/src/render/framegraph/techniquefilternode.cpp
index 8816984ee..8739143e6 100644
--- a/src/render/framegraph/techniquefilternode.cpp
+++ b/src/render/framegraph/techniquefilternode.cpp
@@ -59,13 +59,30 @@ TechniqueFilter::TechniqueFilter()
 {
 }
 
-void TechniqueFilter::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
+void TechniqueFilter::syncFromFrontEnd(const QNode *frontEnd, bool firstTime)
 {
-    FrameGraphNode::initializeFromPeer(change);
-    const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QTechniqueFilterData>>(change);
-    const auto &data = typedChange->data;
-    m_filters = data.matchIds;
-    m_parameterPack.setParameters(data.parameterIds);
+    const QTechniqueFilter *node = qobject_cast<const QTechniqueFilter *>(frontEnd);
+    if (!node)
+        return;
+
+    FrameGraphNode::syncFromFrontEnd(frontEnd, firstTime);
+
+    if (firstTime)
+        m_parameterPack.clear();
+
+    auto parameters = qIdsForNodes(node->parameters());
+    std::sort(std::begin(parameters), std::end(parameters));
+    if (m_parameterPack.parameters() != parameters) {
+        m_parameterPack.setParameters(parameters);
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
+
+    auto filterIds = qIdsForNodes(node->matchAll());
+    std::sort(std::begin(filterIds), std::end(filterIds));
+    if (m_filters != filterIds) {
+        m_filters = filterIds;
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
 }
 
 QVector<Qt3DCore::QNodeId> TechniqueFilter::parameters() const
@@ -89,39 +106,6 @@ void TechniqueFilter::removeFilter(Qt3DCore::QNodeId criterionId)
     m_filters.removeOne(criterionId);
 }
 
-void TechniqueFilter::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
-{
-    switch (e->type()) {
-    case PropertyValueAdded: {
-        const auto change = qSharedPointerCast<QPropertyNodeAddedChange>(e);
-        if (change->propertyName() == QByteArrayLiteral("matchAll")) {
-            appendFilter(change->addedNodeId());
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        } else if (change->propertyName() == QByteArrayLiteral("parameter")) {
-            m_parameterPack.appendParameter(change->addedNodeId());
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        }
-        break;
-    }
-
-    case PropertyValueRemoved: {
-        const auto change = qSharedPointerCast<QPropertyNodeRemovedChange>(e);
-        if (change->propertyName() == QByteArrayLiteral("matchAll")) {
-            removeFilter(change->removedNodeId());
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        } else if (change->propertyName() == QByteArrayLiteral("parameter")) {
-            m_parameterPack.removeParameter(change->removedNodeId());
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        }
-        break;
-    }
-
-    default:
-        break;
-    }
-    FrameGraphNode::sceneChangeEvent(e);
-}
-
 } // namespace Render
 } // namespace Qt3DRender
 
diff --git a/src/render/framegraph/techniquefilternode_p.h b/src/render/framegraph/techniquefilternode_p.h
index d7e6c1508..e424e37e5 100644
--- a/src/render/framegraph/techniquefilternode_p.h
+++ b/src/render/framegraph/techniquefilternode_p.h
@@ -79,11 +79,9 @@ public:
     QVector<Qt3DCore::QNodeId> parameters() const;
 
     QVector<Qt3DCore::QNodeId> filters() const;
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
 
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
-
     void appendFilter(Qt3DCore::QNodeId criterionId);
     void removeFilter(Qt3DCore::QNodeId criterionId);
 
diff --git a/src/render/framegraph/viewportnode.cpp b/src/render/framegraph/viewportnode.cpp
index b3b53b0f9..c37278817 100644
--- a/src/render/framegraph/viewportnode.cpp
+++ b/src/render/framegraph/viewportnode.cpp
@@ -59,16 +59,28 @@ ViewportNode::ViewportNode()
 {
 }
 
-void ViewportNode::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
+
+void ViewportNode::syncFromFrontEnd(const QNode *frontEnd, bool firstTime)
 {
-    FrameGraphNode::initializeFromPeer(change);
-    const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QViewportData>>(change);
-    const auto &data = typedChange->data;
-    m_xMin = data.normalizedRect.x();
-    m_xMax = data.normalizedRect.width();
-    m_yMin = data.normalizedRect.y();
-    m_yMax = data.normalizedRect.height();
-    m_gamma = data.gamma;
+    const QViewport *node = qobject_cast<const QViewport *>(frontEnd);
+    if (!node)
+        return;
+
+    FrameGraphNode::syncFromFrontEnd(frontEnd, firstTime);
+
+    const QRectF oldRect(m_xMin, m_yMin, m_xMax, m_yMax);
+    if (oldRect != node->normalizedRect()) {
+        m_xMin = node->normalizedRect().x();
+        m_yMin = node->normalizedRect().y();
+        m_xMax = node->normalizedRect().width();
+        m_yMax = node->normalizedRect().height();
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
+
+    if (node->gamma() != m_gamma) {
+        m_gamma = node->gamma();
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
 }
 
 float ViewportNode::xMin() const
@@ -118,25 +130,6 @@ void ViewportNode::setGamma(float gamma)
     m_gamma = gamma;
 }
 
-void ViewportNode::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
-{
-    if (e->type() == PropertyUpdated) {
-        QPropertyUpdatedChangePtr propertyChange = qSharedPointerCast<QPropertyUpdatedChange>(e);
-        if (propertyChange->propertyName() == QByteArrayLiteral("normalizedRect")) {
-            QRectF normalizedRect = propertyChange->value().toRectF();
-            setXMin(normalizedRect.x());
-            setYMin(normalizedRect.y());
-            setXMax(normalizedRect.width());
-            setYMax(normalizedRect.height());
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("gamma")) {
-            setGamma(propertyChange->value().toFloat());
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        }
-    }
-    FrameGraphNode::sceneChangeEvent(e);
-}
-
 QRectF ViewportNode::computeViewport(const QRectF &childViewport, const ViewportNode *parentViewport)
 {
     QRectF vp(parentViewport->xMin(),
diff --git a/src/render/framegraph/viewportnode_p.h b/src/render/framegraph/viewportnode_p.h
index 799b9b3dc..3e291a9da 100644
--- a/src/render/framegraph/viewportnode_p.h
+++ b/src/render/framegraph/viewportnode_p.h
@@ -84,13 +84,11 @@ public:
     float gamma() const;
     void setGamma(float gamma);
 
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
 
     static QRectF computeViewport(const QRectF &childViewport, const ViewportNode *parentViewport);
 
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
-
     float m_xMin;
     float m_yMin;
     float m_xMax;
diff --git a/src/render/framegraph/waitfence.cpp b/src/render/framegraph/waitfence.cpp
index 9480fb7a0..68ddda3d7 100644
--- a/src/render/framegraph/waitfence.cpp
+++ b/src/render/framegraph/waitfence.cpp
@@ -71,33 +71,30 @@ WaitFence::~WaitFence()
 {
 }
 
-void WaitFence::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
+void WaitFence::syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime)
 {
-    if (e->type() == Qt3DCore::PropertyUpdated) {
-        Qt3DCore::QPropertyUpdatedChangePtr propertyChange = qSharedPointerCast<Qt3DCore::QPropertyUpdatedChange>(e);
-        if (propertyChange->propertyName() == QByteArrayLiteral("handle")) {
-            m_data.handle = propertyChange->value();
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("handleType")) {
-            m_data.handleType = static_cast<QWaitFence::HandleType>(propertyChange->value().toInt());
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("timeout")) {
-            m_data.timeout = propertyChange->value().value<quint64>();
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("waitOnCPU")) {
-            m_data.waitOnCPU = propertyChange->value().toBool();
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        }
-    }
-    FrameGraphNode::sceneChangeEvent(e);
-}
+    const QWaitFence *node = qobject_cast<const QWaitFence *>(frontEnd);
+    if (!node)
+        return;
 
-void WaitFence::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
-{
-    FrameGraphNode::initializeFromPeer(change);
-    const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QWaitFenceData>>(change);
-    const QWaitFenceData &data = typedChange->data;
-    m_data = data;
+    FrameGraphNode::syncFromFrontEnd(frontEnd, firstTime);
+
+    if (node->handleType() != m_data.handleType) {
+        m_data.handleType = node->handleType();
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
+    if (node->handle() != m_data.handle) {
+        m_data.handle = node->handle();
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
+    if (node->timeout() != m_data.timeout) {
+        m_data.timeout = node->timeout();
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
+    if (node->waitOnCPU() != m_data.waitOnCPU) {
+        m_data.waitOnCPU = node->waitOnCPU();
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
 }
 
 } // namespace Render
diff --git a/src/render/framegraph/waitfence_p.h b/src/render/framegraph/waitfence_p.h
index dd48e0efa..811fc80a2 100644
--- a/src/render/framegraph/waitfence_p.h
+++ b/src/render/framegraph/waitfence_p.h
@@ -68,11 +68,9 @@ public:
     ~WaitFence();
 
     inline QWaitFenceData data() const { return m_data; }
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
 
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) override;
-
     QWaitFenceData m_data;
 };