Update QRenderState to use direct sync

Change-Id: Id38fd035701c86d126851fbde245ebba93e26f34
Reviewed-by: Mike Krus <mike.krus@kdab.com>

12 files changed, 216 insertions, 229 deletions

diff --git a/src/render/frontend/qrenderaspect.cpp b/src/render/frontend/qrenderaspect.cpp
index afe9cb1df..575e2c70e 100644
--- a/src/render/frontend/qrenderaspect.cpp
+++ b/src/render/frontend/qrenderaspect.cpp
@@ -263,7 +263,7 @@ void QRenderAspectPrivate::registerBackendTypes()
     q->registerBackendType<QRenderTarget, true>(QSharedPointer<Render::NodeFunctor<Render::RenderTarget, Render::RenderTargetManager> >::create(m_renderer));
     q->registerBackendType<QRenderTargetOutput, true>(QSharedPointer<Render::NodeFunctor<Render::RenderTargetOutput, Render::AttachmentManager> >::create(m_renderer));
     q->registerBackendType<QRenderSettings, true>(QSharedPointer<Render::RenderSettingsFunctor>::create(m_renderer));
-    q->registerBackendType<QRenderState>(QSharedPointer<Render::NodeFunctor<Render::RenderStateNode, Render::RenderStateManager> >::create(m_renderer));
+    q->registerBackendType<QRenderState, true>(QSharedPointer<Render::NodeFunctor<Render::RenderStateNode, Render::RenderStateManager> >::create(m_renderer));
 
     // Geometry + Compute
     q->registerBackendType<QAttribute, true>(QSharedPointer<Render::NodeFunctor<Render::Attribute, Render::AttributeManager> >::create(m_renderer));
diff --git a/src/render/renderstates/genericstate_p.h b/src/render/renderstates/genericstate_p.h
index b07487d65..e3ece36f5 100644
--- a/src/render/renderstates/genericstate_p.h
+++ b/src/render/renderstates/genericstate_p.h
@@ -80,7 +80,7 @@ public:
 
     virtual StateMask mask() const = 0;
     virtual bool equalTo(const RenderStateImpl &renderState) const = 0;
-    virtual void updateProperty(const char *name, const QVariant &value);
+    virtual void updateProperties(const QRenderState *);
 };
 
 template <class StateSetImpl, StateMask stateMask, typename ... T>
diff --git a/src/render/renderstates/qstenciloperation.cpp b/src/render/renderstates/qstenciloperation.cpp
index af7e014f5..86b4c706b 100644
--- a/src/render/renderstates/qstenciloperation.cpp
+++ b/src/render/renderstates/qstenciloperation.cpp
@@ -106,7 +106,7 @@ QStencilOperation::QStencilOperation(QNode *parent)
 {
     Q_D(QStencilOperation);
 
-    const auto resend = [d]() { d->resendArguments(); };
+    const auto resend = [d]() { d->update(); };
 
     (void) connect(d->m_front, &QStencilOperationArguments::allTestsPassOperationChanged, resend);
     (void) connect(d->m_front, &QStencilOperationArguments::depthTestFailureOperationChanged, resend);
@@ -125,17 +125,6 @@ QStencilOperation::~QStencilOperation()
 }
 
 /*! \internal */
-void QStencilOperationPrivate::resendArguments()
-{
-    auto e = Qt3DCore::QPropertyUpdatedChangePtr::create(m_id);
-    QStencilOperationData data;
-    fillData(data);
-    e->setPropertyName("arguments");
-    e->setValue(QVariant::fromValue(data));
-    notifyObservers(e);
-}
-
-/*! \internal */
 void QStencilOperationPrivate::fillData(QStencilOperationData &data) const
 {
     data.front.face = m_front->faceMode();
diff --git a/src/render/renderstates/qstenciloperation_p.h b/src/render/renderstates/qstenciloperation_p.h
index a1c0cda4a..d38abf0d7 100644
--- a/src/render/renderstates/qstenciloperation_p.h
+++ b/src/render/renderstates/qstenciloperation_p.h
@@ -76,7 +76,6 @@ public:
     QStencilOperationArguments *m_front;
     QStencilOperationArguments *m_back;
 
-    void resendArguments();
     void fillData(QStencilOperationData &data) const;
 };
 
diff --git a/src/render/renderstates/qstenciltest.cpp b/src/render/renderstates/qstenciltest.cpp
index a364c3b88..8f6738e54 100644
--- a/src/render/renderstates/qstenciltest.cpp
+++ b/src/render/renderstates/qstenciltest.cpp
@@ -109,7 +109,7 @@ QStencilTest::QStencilTest(QNode *parent)
 {
     Q_D(QStencilTest);
 
-    const auto resend = [d]() { d->resendArguments(); };
+    const auto resend = [d]() { d->update(); };
 
     (void) connect(d->m_front, &QStencilTestArguments::comparisonMaskChanged, resend);
     (void) connect(d->m_front, &QStencilTestArguments::faceModeChanged, resend);
@@ -128,17 +128,6 @@ QStencilTest::~QStencilTest()
 }
 
 /*! \internal */
-void QStencilTestPrivate::resendArguments()
-{
-    auto e = Qt3DCore::QPropertyUpdatedChangePtr::create(m_id);
-    QStencilTestData data;
-    fillData(data);
-    e->setPropertyName("arguments");
-    e->setValue(QVariant::fromValue(data));
-    notifyObservers(e);
-}
-
-/*! \internal */
 void QStencilTestPrivate::fillData(QStencilTestData &data) const
 {
     data.front.face = m_front->faceMode();
diff --git a/src/render/renderstates/qstenciltest_p.h b/src/render/renderstates/qstenciltest_p.h
index 328e34878..9ddfc6e33 100644
--- a/src/render/renderstates/qstenciltest_p.h
+++ b/src/render/renderstates/qstenciltest_p.h
@@ -78,7 +78,6 @@ public:
     QStencilTestArguments *m_front;
     QStencilTestArguments *m_back;
 
-    void resendArguments();
     void fillData(QStencilTestData &data) const;
 };
 
diff --git a/src/render/renderstates/renderstatenode.cpp b/src/render/renderstates/renderstatenode.cpp
index f83640154..bd218c803 100644
--- a/src/render/renderstates/renderstatenode.cpp
+++ b/src/render/renderstates/renderstatenode.cpp
@@ -90,118 +90,105 @@ namespace Render {
 
 namespace {
 
-StateVariant createStateImplementation(const Qt3DRender::QRenderStateCreatedChangeBasePtr renderStateChange)
+StateVariant createStateImplementation(const QRenderState *node)
 {
-    switch (renderStateChange->renderStateType()) {
+    const QRenderStatePrivate *d = static_cast<const QRenderStatePrivate *>(Qt3DCore::QNodePrivate::get(node));
+    switch (d->m_type) {
 
     case AlphaCoverageStateMask: {
         return StateVariant::createState<AlphaCoverage>();
     }
 
     case AlphaTestMask: {
-        const auto typedChange = qSharedPointerCast<Qt3DRender::QRenderStateCreatedChange<QAlphaTestData>>(renderStateChange);
-        const auto &data = typedChange->data;
-        return StateVariant::createState<AlphaFunc>(data.alphaFunction, data.referenceValue);
+        const QAlphaTest *alphaTest = static_cast<const QAlphaTest *>(node);
+        return StateVariant::createState<AlphaFunc>(alphaTest->alphaFunction(), alphaTest->referenceValue());
     }
 
     case BlendStateMask: {
-        const auto typedChange = qSharedPointerCast<Qt3DRender::QRenderStateCreatedChange<QBlendEquationData>>(renderStateChange);
-        const auto &data = typedChange->data;
-        return StateVariant::createState<BlendEquation>(data.blendFunction);
+        const QBlendEquation *blendEquation = static_cast<const QBlendEquation *>(node);
+        return StateVariant::createState<BlendEquation>(blendEquation->blendFunction());
     }
 
     case BlendEquationArgumentsMask: {
-        const auto typedChange = qSharedPointerCast<Qt3DRender::QRenderStateCreatedChange<QBlendEquationArgumentsData>>(renderStateChange);
-        const auto &data = typedChange->data;
+        const QBlendEquationArguments *blendArgs = static_cast<const QBlendEquationArguments *>(node);
         return StateVariant::createState<BlendEquationArguments>(
-                    data.sourceRgb, data.destinationRgb,
-                    data.sourceAlpha, data.destinationAlpha,
-                    renderStateChange->isNodeEnabled(),
-                    data.bufferIndex);
+                    blendArgs->sourceRgb(), blendArgs->destinationRgb(),
+                    blendArgs->sourceAlpha(), blendArgs->destinationAlpha(),
+                    blendArgs->isEnabled(),
+                    blendArgs->bufferIndex());
     }
 
     case MSAAEnabledStateMask: {
-        return StateVariant::createState<MSAAEnabled>(renderStateChange->isNodeEnabled());
+        return StateVariant::createState<MSAAEnabled>(node->isEnabled());
     }
 
     case CullFaceStateMask: {
-        const auto typedChange = qSharedPointerCast<Qt3DRender::QRenderStateCreatedChange<QCullFaceData>>(renderStateChange);
-        const auto &data = typedChange->data;
-        return StateVariant::createState<CullFace>(data.mode);
+        const QCullFace *cullFace = static_cast<const QCullFace *>(node);
+        return StateVariant::createState<CullFace>(cullFace->mode());
     }
 
     case DepthRangeMask: {
-        const auto typedChange = qSharedPointerCast<Qt3DRender::QRenderStateCreatedChange<QDepthRangeData>>(renderStateChange);
-        const auto &data = typedChange->data;
-        return StateVariant::createState<DepthRange>(data.nearValue, data.farValue);
+        const QDepthRange *depthRange = static_cast<const QDepthRange *>(node);
+        return StateVariant::createState<DepthRange>(depthRange->nearValue(), depthRange->farValue());
     }
 
     case DepthWriteStateMask: {
-        return StateVariant::createState<NoDepthMask>(false);
+        return StateVariant::createState<NoDepthMask>(!node->isEnabled());
     }
 
     case DepthTestStateMask: {
-        const auto typedChange = qSharedPointerCast<Qt3DRender::QRenderStateCreatedChange<QDepthTestData>>(renderStateChange);
-        const auto &data = typedChange->data;
-        return StateVariant::createState<DepthTest>(data.depthFunction);
+        const QDepthTest *depthTest = static_cast<const QDepthTest *>(node);
+        return StateVariant::createState<DepthTest>(depthTest->depthFunction());
     }
 
     case RasterModeMask: {
-        const auto typedChange = qSharedPointerCast<Qt3DRender::QRenderStateCreatedChange<QRasterModeData>>(renderStateChange);
-        const auto &data = typedChange->data;
-        return StateVariant::createState<RasterMode>(data.faceMode, data.rasterMode);
+        const QRasterMode *rasterMode = static_cast<const QRasterMode *>(node);
+        return StateVariant::createState<RasterMode>(rasterMode->faceMode(), rasterMode->rasterMode());
     }
 
     case FrontFaceStateMask: {
-        const auto typedChange = qSharedPointerCast<Qt3DRender::QRenderStateCreatedChange<QFrontFaceData>>(renderStateChange);
-        const auto &data = typedChange->data;
-        return StateVariant::createState<FrontFace>(data.direction);
+        const QFrontFace *frontFace = static_cast<const QFrontFace *>(node);
+        return StateVariant::createState<FrontFace>(frontFace->direction());
     }
 
     case ScissorStateMask: {
-        const auto typedChange = qSharedPointerCast<Qt3DRender::QRenderStateCreatedChange<QScissorTestData>>(renderStateChange);
-        const auto &data = typedChange->data;
-        return StateVariant::createState<ScissorTest>(data.left, data.bottom,
-                                                      data.width, data.height);
+        const QScissorTest *scissorTest = static_cast<const QScissorTest *>(node);
+        return StateVariant::createState<ScissorTest>(scissorTest->left(), scissorTest->bottom(),
+                                                      scissorTest->width(), scissorTest->height());
     }
 
     case StencilTestStateMask: {
-        const auto typedChange = qSharedPointerCast<Qt3DRender::QRenderStateCreatedChange<QStencilTestData>>(renderStateChange);
-        const auto &data = typedChange->data;
-        return StateVariant::createState<StencilTest>(data.front.stencilFunction,
-                                                      data.front.referenceValue,
-                                                      data.front.comparisonMask,
-                                                      data.back.stencilFunction,
-                                                      data.back.referenceValue,
-                                                      data.back.comparisonMask);
+        const QStencilTest *stencilTest = static_cast<const QStencilTest *>(node);
+        return StateVariant::createState<StencilTest>(stencilTest->front()->stencilFunction(),
+                                                      stencilTest->front()->referenceValue(),
+                                                      stencilTest->front()->comparisonMask(),
+                                                      stencilTest->back()->stencilFunction(),
+                                                      stencilTest->back()->referenceValue(),
+                                                      stencilTest->back()->comparisonMask());
     }
 
     case PointSizeMask: {
-        const auto typedChange = qSharedPointerCast<Qt3DRender::QRenderStateCreatedChange<QPointSizeData>>(renderStateChange);
-        const auto &data = typedChange->data;
-        const bool isProgrammable = (data.sizeMode == QPointSize::Programmable);
-        return StateVariant::createState<PointSize>(isProgrammable, data.value);
+        const QPointSize *pointSize = static_cast<const QPointSize *>(node);
+        const bool isProgrammable = (pointSize->sizeMode() == QPointSize::Programmable);
+        return StateVariant::createState<PointSize>(isProgrammable, pointSize->value());
     }
 
     case PolygonOffsetStateMask: {
-        const auto typedChange = qSharedPointerCast<Qt3DRender::QRenderStateCreatedChange<QPolygonOffsetData>>(renderStateChange);
-        const auto &data = typedChange->data;
-        return StateVariant::createState<PolygonOffset>(data.scaleFactor, data.depthSteps);
+        const QPolygonOffset *offset = static_cast<const QPolygonOffset *>(node);
+        return StateVariant::createState<PolygonOffset>(offset->scaleFactor(), offset->depthSteps());
     }
 
     case ColorStateMask: {
-        const auto typedChange = qSharedPointerCast<Qt3DRender::QRenderStateCreatedChange<QColorMaskData>>(renderStateChange);
-        const auto &data = typedChange->data;
-        return StateVariant::createState<ColorMask>(data.redMasked, data.greenMasked,
-                                                    data.blueMasked, data.alphaMasked);
+        const QColorMask *colorMask = static_cast<const QColorMask *>(node);
+        return StateVariant::createState<ColorMask>(colorMask->isRedMasked(), colorMask->isGreenMasked(),
+                                                    colorMask->isBlueMasked(), colorMask->isAlphaMasked());
     }
 
     case ClipPlaneMask: {
-        const auto typedChange = qSharedPointerCast<Qt3DRender::QRenderStateCreatedChange<QClipPlaneData>>(renderStateChange);
-        const auto &data = typedChange->data;
-        return StateVariant::createState<ClipPlane>(data.planeIndex,
-                                                    data.normal,
-                                                    data.distance);
+        const QClipPlane *clipPlane = static_cast<const QClipPlane *>(node);
+        return StateVariant::createState<ClipPlane>(clipPlane->planeIndex(),
+                                                    clipPlane->normal(),
+                                                    clipPlane->distance());
     }
 
     case SeamlessCubemapMask: {
@@ -209,21 +196,19 @@ StateVariant createStateImplementation(const Qt3DRender::QRenderStateCreatedChan
     }
 
     case StencilOpMask: {
-        const auto typedChange = qSharedPointerCast<Qt3DRender::QRenderStateCreatedChange<QStencilOperationData>>(renderStateChange);
-        const auto &data = typedChange->data;
-        return StateVariant::createState<StencilOp>(data.front.stencilTestFailureOperation,
-                                                    data.front.depthTestFailureOperation,
-                                                    data.front.allTestsPassOperation,
-                                                    data.back.stencilTestFailureOperation,
-                                                    data.back.depthTestFailureOperation,
-                                                    data.back.allTestsPassOperation);
+        const QStencilOperation *stencilOp = static_cast<const QStencilOperation *>(node);
+        return StateVariant::createState<StencilOp>(stencilOp->front()->stencilTestFailureOperation(),
+                                                    stencilOp->front()->depthTestFailureOperation(),
+                                                    stencilOp->front()->allTestsPassOperation(),
+                                                    stencilOp->back()->stencilTestFailureOperation(),
+                                                    stencilOp->back()->depthTestFailureOperation(),
+                                                    stencilOp->back()->allTestsPassOperation());
     }
 
     case StencilWriteStateMask: {
-        const auto typedChange = qSharedPointerCast<Qt3DRender::QRenderStateCreatedChange<QStencilMaskData>>(renderStateChange);
-        const auto &data = typedChange->data;
-        return StateVariant::createState<StencilMask>(data.frontOutputMask,
-                                                      data.backOutputMask);
+        const QStencilMask *stencilMask = static_cast<const QStencilMask *>(node);
+        return StateVariant::createState<StencilMask>(stencilMask->frontOutputMask(),
+                                                      stencilMask->backOutputMask());
     }
 
     case DitheringStateMask: {
@@ -231,9 +216,8 @@ StateVariant createStateImplementation(const Qt3DRender::QRenderStateCreatedChan
     }
 
     case LineWidthMask: {
-        const auto typedChange = qSharedPointerCast<Qt3DRender::QRenderStateCreatedChange<QLineWidthData>>(renderStateChange);
-        const auto &data = typedChange->data;
-        return StateVariant::createState<LineWidth>(data.value, data.smooth);
+        const QLineWidth *lineWidth = static_cast<const QLineWidth *>(node);
+        return StateVariant::createState<LineWidth>(lineWidth->value(), lineWidth->smooth());
     }
 
     default:
@@ -258,21 +242,19 @@ void RenderStateNode::cleanup()
 {
 }
 
-void RenderStateNode::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &chang3)
+void RenderStateNode::syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime)
 {
-    cleanup();
-    const auto renderStateChange = qSharedPointerCast<Qt3DRender::QRenderStateCreatedChangeBase>(chang3);
-    m_impl = createStateImplementation(renderStateChange);
-}
+    const QRenderState *node = qobject_cast<const QRenderState *>(frontEnd);
+    if (!node)
+        return;
 
-void RenderStateNode::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
-{
-    if (e->type() == Qt3DCore::PropertyUpdated) {
-        Qt3DCore::QPropertyUpdatedChangePtr propertyChange = qSharedPointerCast<Qt3DCore::QPropertyUpdatedChange>(e);
-        m_impl.state()->updateProperty(propertyChange->propertyName(), propertyChange->value());
-        markDirty(AbstractRenderer::AllDirty);
-    }
-    BackendNode::sceneChangeEvent(e);
+    BackendNode::syncFromFrontEnd(frontEnd, firstTime);
+
+    if (firstTime)
+        m_impl = createStateImplementation(node);
+
+    m_impl.state()->updateProperties(node);
+    markDirty(AbstractRenderer::AllDirty);
 }
 
 } // namespace Render
diff --git a/src/render/renderstates/renderstatenode_p.h b/src/render/renderstates/renderstatenode_p.h
index 277b8a7c8..e0258112f 100644
--- a/src/render/renderstates/renderstatenode_p.h
+++ b/src/render/renderstates/renderstatenode_p.h
@@ -63,8 +63,7 @@ public:
     RenderStateNode();
     virtual ~RenderStateNode();
 
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
-
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
     StateMask type() const { return m_impl.type; }
     StateVariant impl() const { return m_impl; }
 
@@ -72,7 +71,6 @@ protected:
     void cleanup();
 
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
 
     StateVariant m_impl;
 };
diff --git a/src/render/renderstates/renderstates.cpp b/src/render/renderstates/renderstates.cpp
index 77143ecd3..bd4a209a1 100644
--- a/src/render/renderstates/renderstates.cpp
+++ b/src/render/renderstates/renderstates.cpp
@@ -48,152 +48,181 @@
 #include <Qt3DRender/private/graphicscontext_p.h>
 #include <Qt3DRender/private/qstenciloperation_p.h>
 #include <Qt3DRender/private/qstenciltest_p.h>
+#include <Qt3DRender/qblendequationarguments.h>
+#include <Qt3DRender/qblendequation.h>
+#include <Qt3DRender/qalphatest.h>
+#include <Qt3DRender/qdepthrange.h>
+#include <Qt3DRender/qdepthtest.h>
+#include <Qt3DRender/qrastermode.h>
+#include <Qt3DRender/qfrontface.h>
+#include <Qt3DRender/qscissortest.h>
+#include <Qt3DRender/qpolygonoffset.h>
+#include <Qt3DRender/qcolormask.h>
+#include <Qt3DRender/qclipplane.h>
+#include <Qt3DRender/qstencilmask.h>
+#include <Qt3DRender/qlinewidth.h>
 
 QT_BEGIN_NAMESPACE
 
 namespace Qt3DRender {
 namespace Render {
 
-void RenderStateImpl::updateProperty(const char *name, const QVariant &value)
+void RenderStateImpl::updateProperties(const QRenderState *)
 {
-    Q_UNUSED(name);
-    Q_UNUSED(value);
 }
 
-void BlendEquationArguments::updateProperty(const char *name, const QVariant &value)
+void BlendEquationArguments::updateProperties(const QRenderState *node)
 {
-    if (name == QByteArrayLiteral("sourceRgb")) std::get<0>(m_values) = value.toInt();
-    else if (name == QByteArrayLiteral("destinationRgb")) std::get<1>(m_values) = value.toInt();
-    else if (name == QByteArrayLiteral("sourceAlpha")) std::get<2>(m_values) = value.toInt();
-    else if (name == QByteArrayLiteral("destinationAlpha")) std::get<3>(m_values) = value.toInt();
-    else if (name == QByteArrayLiteral("enabled")) std::get<4>(m_values) = value.toBool();
-    else if (name == QByteArrayLiteral("bufferIndex")) std::get<5>(m_values) = value.toInt();
+    const QBlendEquationArguments *args = static_cast<const QBlendEquationArguments *>(node);
+
+    std::get<0>(m_values) = args->sourceRgb();
+    std::get<1>(m_values) = args->destinationRgb();
+    std::get<2>(m_values) = args->sourceAlpha();
+    std::get<3>(m_values) = args->destinationAlpha();
+    std::get<4>(m_values) = args->isEnabled();
+    std::get<5>(m_values) = args->bufferIndex();
 }
 
-void BlendEquation::updateProperty(const char *name, const QVariant &value)
+void BlendEquation::updateProperties(const QRenderState *node)
 {
-    if (name == QByteArrayLiteral("blendFunction")) std::get<0>(m_values) = value.toInt();
+    const QBlendEquation *equation = static_cast<const QBlendEquation *>(node);
+    std::get<0>(m_values) = equation->blendFunction();
 }
 
-void AlphaFunc::updateProperty(const char *name, const QVariant &value)
+void AlphaFunc::updateProperties(const QRenderState *node)
 {
-    if (name == QByteArrayLiteral("alphaFunction"))
-        std::get<0>(m_values) = value.toInt();
-    if (name == QByteArrayLiteral("referenceValue"))
-        std::get<1>(m_values) = value.toFloat();
+    const QAlphaTest *alphaTest = static_cast<const QAlphaTest *>(node);
+    std::get<0>(m_values) = alphaTest->alphaFunction();
+    std::get<1>(m_values) = alphaTest->referenceValue();
 }
 
-void MSAAEnabled::updateProperty(const char *name, const QVariant &value)
+void MSAAEnabled::updateProperties(const QRenderState *node)
 {
-    if (name == QByteArrayLiteral("enabled"))
-        std::get<0>(m_values) = value.toBool();
+    std::get<0>(m_values) = node->isEnabled();
 }
 
-void DepthRange::updateProperty(const char *name, const QVariant &value)
+void DepthRange::updateProperties(const QRenderState *node)
 {
-    if (name == QByteArrayLiteral("nearValue")) std::get<0>(m_values) = value.toDouble();
-    else if (name == QByteArrayLiteral("farValue")) std::get<1>(m_values) = value.toDouble();
+    const QDepthRange *depthRange = static_cast<const QDepthRange *>(node);
+
+    std::get<0>(m_values) = depthRange->nearValue();
+    std::get<1>(m_values) = depthRange->farValue();
 }
 
-void DepthTest::updateProperty(const char *name, const QVariant &value)
+void DepthTest::updateProperties(const QRenderState *node)
 {
-    if (name == QByteArrayLiteral("depthFunction")) std::get<0>(m_values) = value.toInt();
+    const QDepthTest *depthTest = static_cast<const QDepthTest *>(node);
+
+    std::get<0>(m_values) = depthTest->depthFunction();
 }
 
-void RasterMode::updateProperty(const char *name, const QVariant &value)
+void RasterMode::updateProperties(const QRenderState *node)
 {
-    if (name == QByteArrayLiteral("rasterMode")) std::get<0>(m_values) = value.toInt();
-    if (name == QByteArrayLiteral("faceMode")) std::get<1>(m_values) = value.toInt();
+    const QRasterMode *rasterMode = static_cast<const QRasterMode *>(node);
+
+    std::get<0>(m_values) = rasterMode->faceMode();
+    std::get<1>(m_values) = rasterMode->rasterMode();
 }
 
-void CullFace::updateProperty(const char *name, const QVariant &value)
+void CullFace::updateProperties(const QRenderState *node)
 {
-    if (name == QByteArrayLiteral("mode")) std::get<0>(m_values) = value.toInt();
+    const QCullFace *cullFace = static_cast<const QCullFace *>(node);
+
+    std::get<0>(m_values) = cullFace->mode();
 }
 
-void FrontFace::updateProperty(const char *name, const QVariant &value)
+void FrontFace::updateProperties(const QRenderState *node)
 {
-    if (name == QByteArrayLiteral("direction")) std::get<0>(m_values) = value.toInt();
+    const QFrontFace *frontFace = static_cast<const QFrontFace *>(node);
+
+    std::get<0>(m_values) = frontFace->direction();
 }
 
-void NoDepthMask::updateProperty(const char *name, const QVariant &value)
+void NoDepthMask::updateProperties(const QRenderState *node)
 {
-    if (name == QByteArrayLiteral("mask")) std::get<0>(m_values) = value.toBool();
+    std::get<0>(m_values) = !node->isEnabled();
 }
 
-void ScissorTest::updateProperty(const char *name, const QVariant &value)
+void ScissorTest::updateProperties(const QRenderState *node)
 {
-    if (name == QByteArrayLiteral("left")) std::get<0>(m_values) = value.toInt();
-    else if (name == QByteArrayLiteral("bottom")) std::get<1>(m_values) = value.toInt();
-    else if (name == QByteArrayLiteral("width")) std::get<2>(m_values) = value.toInt();
-    else if (name == QByteArrayLiteral("height")) std::get<3>(m_values) = value.toInt();
+    const QScissorTest *scissorTest = static_cast<const QScissorTest *>(node);
+
+    std::get<0>(m_values) = scissorTest->left();
+    std::get<1>(m_values) = scissorTest->bottom();
+    std::get<2>(m_values) = scissorTest->width();
+    std::get<3>(m_values) = scissorTest->height();
 }
 
-void StencilTest::updateProperty(const char *name, const QVariant &value)
+void StencilTest::updateProperties(const QRenderState *node)
 {
-    if (name == QByteArrayLiteral("arguments")) {
-        const QStencilTestData data = value.value<QStencilTestData>();
-        std::get<0>(m_values) = data.front.stencilFunction;
-        std::get<1>(m_values) = data.front.referenceValue;
-        std::get<2>(m_values) = data.front.comparisonMask;
-        std::get<3>(m_values) = data.back.stencilFunction;
-        std::get<4>(m_values) = data.back.referenceValue;
-        std::get<5>(m_values) = data.back.comparisonMask;
-    }
+    const QStencilTest *stencilTest = static_cast<const QStencilTest *>(node);
+    std::get<0>(m_values) = stencilTest->front()->stencilFunction();
+    std::get<1>(m_values) = stencilTest->front()->referenceValue();
+    std::get<2>(m_values) = stencilTest->front()->comparisonMask();
+    std::get<3>(m_values) = stencilTest->back()->stencilFunction();
+    std::get<4>(m_values) = stencilTest->back()->referenceValue();
+    std::get<5>(m_values) = stencilTest->back()->comparisonMask();
 }
 
-void PointSize::updateProperty(const char *name, const QVariant &value)
+void PointSize::updateProperties(const QRenderState *node)
 {
-    if (name == QByteArrayLiteral("sizeMode")) std::get<0>(m_values) = (value.toInt() == QPointSize::Programmable);
-    else if (name == QByteArrayLiteral("value")) std::get<1>(m_values) = value.toFloat();
+    const QPointSize *pointSize = static_cast<const QPointSize *>(node);
+
+    std::get<0>(m_values) = (pointSize->sizeMode() == QPointSize::Programmable);
+    std::get<1>(m_values) = pointSize->value();
 }
 
-void PolygonOffset::updateProperty(const char *name, const QVariant &value)
+void PolygonOffset::updateProperties(const QRenderState *node)
 {
-    if (name == QByteArrayLiteral("scaleFactor")) std::get<0>(m_values) = value.toFloat();
-    else if (name == QByteArrayLiteral("depthSteps")) std::get<1>(m_values) = value.toFloat();
+    const QPolygonOffset *offset = static_cast<const QPolygonOffset *>(node);
+
+    std::get<0>(m_values) = offset->scaleFactor();
+    std::get<1>(m_values) = offset->depthSteps();
 }
 
-void ColorMask::updateProperty(const char *name, const QVariant &value)
+void ColorMask::updateProperties(const QRenderState *node)
 {
-    if (name == QByteArrayLiteral("redMasked")) std::get<0>(m_values) = value.toBool();
-    else if (name == QByteArrayLiteral("greenMasked")) std::get<1>(m_values) = value.toBool();
-    else if (name == QByteArrayLiteral("blueMasked")) std::get<2>(m_values) = value.toBool();
-    else if (name == QByteArrayLiteral("alphaMasked")) std::get<3>(m_values) = value.toBool();
+    const QColorMask *colorMask = static_cast<const QColorMask *>(node);
+
+    std::get<0>(m_values) = colorMask->isRedMasked();
+    std::get<1>(m_values) = colorMask->isGreenMasked();
+    std::get<2>(m_values) = colorMask->isBlueMasked();
+    std::get<3>(m_values) = colorMask->isAlphaMasked();
 }
 
-void ClipPlane::updateProperty(const char *name, const QVariant &value)
+void ClipPlane::updateProperties(const QRenderState *node)
 {
-    if (name == QByteArrayLiteral("planeIndex")) std::get<0>(m_values) = value.toInt();
-    else if (name == QByteArrayLiteral("normal")) std::get<1>(m_values) = value.value<QVector3D>();
-    else if (name == QByteArrayLiteral("distance")) std::get<2>(m_values) = value.toFloat();
+    const QClipPlane *clipPlane = static_cast<const QClipPlane *>(node);
+
+    std::get<0>(m_values) = clipPlane->planeIndex();
+    std::get<1>(m_values) = clipPlane->normal();
+    std::get<2>(m_values) = clipPlane->distance();
 }
 
-void StencilOp::updateProperty(const char *name, const QVariant &value)
+void StencilOp::updateProperties(const QRenderState *node)
 {
-    if (name == QByteArrayLiteral("arguments")) {
-        const QStencilOperationData data = value.value<QStencilOperationData>();
-        std::get<0>(m_values) = data.front.stencilTestFailureOperation;
-        std::get<1>(m_values) = data.front.depthTestFailureOperation;
-        std::get<2>(m_values) = data.front.allTestsPassOperation;
-        std::get<3>(m_values) = data.back.stencilTestFailureOperation;
-        std::get<4>(m_values) = data.back.depthTestFailureOperation;
-        std::get<5>(m_values) = data.back.allTestsPassOperation;
-    }
+    const QStencilOperation *stencilOp = static_cast<const QStencilOperation *>(node);
+
+    std::get<0>(m_values) = stencilOp->front()->stencilTestFailureOperation();
+    std::get<1>(m_values) = stencilOp->front()->depthTestFailureOperation();
+    std::get<2>(m_values) = stencilOp->front()->allTestsPassOperation();
+    std::get<3>(m_values) = stencilOp->back()->stencilTestFailureOperation();
+    std::get<4>(m_values) = stencilOp->back()->depthTestFailureOperation();
+    std::get<5>(m_values) = stencilOp->back()->allTestsPassOperation();
 }
 
-void StencilMask::updateProperty(const char *name, const QVariant &value)
+void StencilMask::updateProperties(const QRenderState *node)
 {
-    if (name == QByteArrayLiteral("frontOutputMask")) std::get<0>(m_values) = value.toInt();
-    else if (name == QByteArrayLiteral("backOutputMask")) std::get<1>(m_values) = value.toInt();
+    const QStencilMask *stencilMask = static_cast<const QStencilMask *>(node);
+    std::get<0>(m_values) = stencilMask->frontOutputMask();
+    std::get<1>(m_values) = stencilMask->backOutputMask();
 }
 
-void LineWidth::updateProperty(const char *name, const QVariant &value)
+void LineWidth::updateProperties(const QRenderState *node)
 {
-    if (name == QByteArrayLiteral("value"))
-        std::get<0>(m_values) = value.toFloat();
-    else if (name == QByteArrayLiteral("smooth"))
-        std::get<1>(m_values) = value.toBool();
+    const QLineWidth *lineWidth = static_cast<const QLineWidth *>(node);
+    std::get<0>(m_values) = lineWidth->value();
+    std::get<1>(m_values) = lineWidth->smooth();
 }
 
 } // namespace Render
diff --git a/src/render/renderstates/renderstates_p.h b/src/render/renderstates/renderstates_p.h
index 7c6dc4ebd..6c8e9d551 100644
--- a/src/render/renderstates/renderstates_p.h
+++ b/src/render/renderstates/renderstates_p.h
@@ -62,61 +62,61 @@ namespace Render {
 class Q_AUTOTEST_EXPORT BlendEquationArguments : public GenericState<BlendEquationArguments, BlendEquationArgumentsMask, GLenum, GLenum, GLenum, GLenum, bool, int>
 {
 public:
-    void updateProperty(const char *name, const QVariant &value) override;
+    void updateProperties(const QRenderState *node) override;
 };
 
 class Q_AUTOTEST_EXPORT BlendEquation : public GenericState<BlendEquation, BlendStateMask, GLenum>
 {
 public:
-    void updateProperty(const char *name, const QVariant &value) override;
+    void updateProperties(const QRenderState *node) override;
 };
 
 class Q_AUTOTEST_EXPORT AlphaFunc : public GenericState<AlphaFunc, AlphaTestMask, GLenum, GLclampf>
 {
 public:
-    void updateProperty(const char *name, const QVariant &value) override;
+    void updateProperties(const QRenderState *node) override;
 };
 
 class Q_AUTOTEST_EXPORT MSAAEnabled : public GenericState<MSAAEnabled, MSAAEnabledStateMask, GLboolean>
 {
 public:
-    void updateProperty(const char *name, const QVariant &value) override;
+    void updateProperties(const QRenderState *node) override;
 };
 
 class Q_AUTOTEST_EXPORT DepthRange : public GenericState<DepthRange, DepthRangeMask, double, double>
 {
 public:
-    void updateProperty(const char *name, const QVariant &value) override;
+    void updateProperties(const QRenderState *node) override;
 };
 
 class Q_AUTOTEST_EXPORT DepthTest : public GenericState<DepthTest, DepthTestStateMask, GLenum>
 {
 public:
-    void updateProperty(const char *name, const QVariant &value) override;
+    void updateProperties(const QRenderState *node) override;
 };
 
 class Q_AUTOTEST_EXPORT RasterMode : public GenericState<RasterMode, RasterModeMask, GLenum, GLenum>
 {
 public:
-    void updateProperty(const char *name, const QVariant &value) override;
+    void updateProperties(const QRenderState *node) override;
 };
 
 class Q_AUTOTEST_EXPORT NoDepthMask : public GenericState<NoDepthMask, DepthWriteStateMask, GLboolean>
 {
 public:
-    void updateProperty(const char *name, const QVariant &value) override;
+    void updateProperties(const QRenderState *node) override;
 };
 
 class Q_AUTOTEST_EXPORT CullFace : public GenericState<CullFace, CullFaceStateMask, GLenum>
 {
 public:
-    void updateProperty(const char *name, const QVariant &value) override;
+    void updateProperties(const QRenderState *node) override;
 };
 
 class Q_AUTOTEST_EXPORT FrontFace : public GenericState<FrontFace, FrontFaceStateMask, GLenum>
 {
 public:
-    void updateProperty(const char *name, const QVariant &value) override;
+    void updateProperties(const QRenderState *node) override;
 };
 
 class Q_AUTOTEST_EXPORT Dithering : public GenericState<Dithering, DitheringStateMask>
@@ -126,13 +126,13 @@ class Q_AUTOTEST_EXPORT Dithering : public GenericState<Dithering, DitheringStat
 class Q_AUTOTEST_EXPORT ScissorTest : public GenericState<ScissorTest, ScissorStateMask, int, int, int, int>
 {
 public:
-    void updateProperty(const char *name, const QVariant &value) override;
+    void updateProperties(const QRenderState *node) override;
 };
 
 class Q_AUTOTEST_EXPORT StencilTest : public GenericState<StencilTest, StencilTestStateMask, GLenum, int, uint, GLenum, int, uint>
 {
 public:
-    void updateProperty(const char *name, const QVariant &value) override;
+    void updateProperties(const QRenderState *node) override;
 };
 
 class Q_AUTOTEST_EXPORT AlphaCoverage : public GenericState<AlphaCoverage, AlphaCoverageStateMask>
@@ -142,26 +142,26 @@ class Q_AUTOTEST_EXPORT AlphaCoverage : public GenericState<AlphaCoverage, Alpha
 class Q_AUTOTEST_EXPORT PointSize : public GenericState<PointSize, PointSizeMask, bool, GLfloat>
 {
 public:
-    void updateProperty(const char *name, const QVariant &value) override;
+    void updateProperties(const QRenderState *node) override;
 };
 
 class Q_AUTOTEST_EXPORT PolygonOffset : public GenericState<PolygonOffset, PolygonOffsetStateMask, GLfloat, GLfloat>
 {
 public:
 
-    void updateProperty(const char *name, const QVariant &value) override;
+    void updateProperties(const QRenderState *node) override;
 };
 
 class Q_AUTOTEST_EXPORT ColorMask : public GenericState<ColorMask, ColorStateMask, GLboolean, GLboolean, GLboolean, GLboolean>
 {
 public:
-    void updateProperty(const char *name, const QVariant &value) override;
+    void updateProperties(const QRenderState *node) override;
 };
 
 class Q_AUTOTEST_EXPORT ClipPlane : public GenericState<ClipPlane, ClipPlaneMask, int, QVector3D, float>
 {
 public:
-    void updateProperty(const char *name, const QVariant &value) override;
+    void updateProperties(const QRenderState *node) override;
 };
 
 class Q_AUTOTEST_EXPORT SeamlessCubemap : public GenericState<SeamlessCubemap, SeamlessCubemapMask>
@@ -171,19 +171,19 @@ class Q_AUTOTEST_EXPORT SeamlessCubemap : public GenericState<SeamlessCubemap, S
 class Q_AUTOTEST_EXPORT StencilOp : public GenericState<StencilOp, StencilOpMask, GLenum, GLenum, GLenum, GLenum, GLenum, GLenum>
 {
 public:
-    void updateProperty(const char *name, const QVariant &value) override;
+    void updateProperties(const QRenderState *node) override;
 };
 
 class Q_AUTOTEST_EXPORT StencilMask : public GenericState<StencilMask, StencilWriteStateMask, uint, uint>
 {
 public:
-    void updateProperty(const char *name, const QVariant &value) override;
+    void updateProperties(const QRenderState *node) override;
 };
 
 class Q_AUTOTEST_EXPORT LineWidth : public GenericState<LineWidth, LineWidthMask, GLfloat, bool>
 {
 public:
-    void updateProperty(const char *name, const QVariant &value) override;
+    void updateProperties(const QRenderState *node) override;
 };
 
 } // namespace Render
diff --git a/tests/auto/render/qrenderstate/tst_qrenderstate.cpp b/tests/auto/render/qrenderstate/tst_qrenderstate.cpp
index 63319b42c..fb212bc8f 100644
--- a/tests/auto/render/qrenderstate/tst_qrenderstate.cpp
+++ b/tests/auto/render/qrenderstate/tst_qrenderstate.cpp
@@ -75,8 +75,8 @@ private:
     RenderStateNode* createBackendNode(QRenderState *frontend)
     {
         RenderStateNode *backend = m_renderStateManager.getOrCreateResource(frontend->id());
-        simulateInitialization(frontend, backend);
         backend->setRenderer(&m_renderer);
+        simulateInitializationSync(frontend, backend);
         return backend;
     }
 
@@ -187,6 +187,7 @@ private Q_SLOTS:
         // THEN
         RenderStateNode *backend1 = createBackendNode(frontend1);
         RenderStateNode *backend2 = createBackendNode(frontend2);
+
         QVERIFY(backend1->type() == mask);
         QVERIFY(backend2->type() == mask);
         QVERIFY(backend1->impl() != backend2->impl());
@@ -204,12 +205,11 @@ private Q_SLOTS:
         QCOMPARE(arbiter.dirtyNodes.size(), 1);
         QCOMPARE(arbiter.dirtyNodes.front(), frontend1);
 
-        // TODOSYNC update when syncFromFrontendNode is implemented
-//        // WHEN
-//        backend1->sceneChangeEvent(change.staticCast<QSceneChange>());
+        // WHEN
+        backend1->syncFromFrontEnd(frontend1, false);
 
-//        // THEN
-//        QVERIFY(backend1->impl() == backend2->impl());
+        // THEN
+        QVERIFY(backend1->impl() == backend2->impl());
 
         arbiter.dirtyNodes.clear();
     }
@@ -285,12 +285,12 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        QPropertyUpdatedChangePtr change = arbiter.events.first().staticCast<QPropertyUpdatedChange>();
-        QCOMPARE(change->subjectId(), frontend1->id());
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), frontend1);
 
         // WHEN
-        backend1->sceneChangeEvent(change.staticCast<QSceneChange>());
+        backend1->syncFromFrontEnd(frontend1, false);
 
         // THEN
         QVERIFY(backend1->impl() == backend2->impl());
diff --git a/tests/auto/render/renderpass/tst_renderpass.cpp b/tests/auto/render/renderpass/tst_renderpass.cpp
index 7be741936..136e2755d 100644
--- a/tests/auto/render/renderpass/tst_renderpass.cpp
+++ b/tests/auto/render/renderpass/tst_renderpass.cpp
@@ -148,6 +148,7 @@ private slots:
         backend.setRenderer(&renderer);
 
         RenderStateNode *backendState = m_renderStateManager->getOrCreateResource(frontendState->id());
+        backendState->setRenderer(&renderer);
         simulateInitializationSync(frontendState, backendState);
 
         // WHEN
@@ -262,6 +263,7 @@ private slots:
         backend.setRenderer(&renderer);
 
         RenderStateNode *backendState = m_renderStateManager->getOrCreateResource(frontendState->id());
+        backendState->setRenderer(&renderer);
         simulateInitializationSync(frontendState, backendState);
 
         QRenderPass frontend;