Update QAxisAccumulator to use direct sync

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

5 files changed, 33 insertions, 55 deletions

diff --git a/src/input/backend/axisaccumulator.cpp b/src/input/backend/axisaccumulator.cpp
index edc282bec..fc66e02c9 100644
--- a/src/input/backend/axisaccumulator.cpp
+++ b/src/input/backend/axisaccumulator.cpp
@@ -40,7 +40,7 @@
 #include "axisaccumulator_p.h"
 
 #include <Qt3DCore/qpropertyupdatedchange.h>
-
+#include <Qt3DInput/qaxis.h>
 #include <Qt3DInput/private/inputmanagers_p.h>
 #include <Qt3DInput/private/qaxisaccumulator_p.h>
 
@@ -50,7 +50,7 @@ namespace Qt3DInput {
 namespace Input {
 
 AxisAccumulator::AxisAccumulator()
-    : Qt3DCore::QBackendNode(ReadWrite)
+    : BackendNode(ReadWrite)
     , m_sourceAxisId()
     , m_sourceAxisType(QAxisAccumulator::Velocity)
     , m_scale(1.0f)
@@ -59,17 +59,6 @@ AxisAccumulator::AxisAccumulator()
 {
 }
 
-void AxisAccumulator::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
-{
-    const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QAxisAccumulatorData>>(change);
-    const auto &data = typedChange->data;
-    m_sourceAxisId = data.sourceAxisId;
-    m_sourceAxisType = data.sourceAxisType;
-    m_scale = data.scale;
-    m_value = 0.0f;
-    m_velocity = 0.0f;
-}
-
 void AxisAccumulator::cleanup()
 {
     QBackendNode::setEnabled(false);
@@ -107,24 +96,21 @@ void AxisAccumulator::setVelocity(float velocity)
     }
 }
 
-void AxisAccumulator::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
+void AxisAccumulator::syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime)
 {
-    switch (e->type()) {
-    case Qt3DCore::PropertyUpdated: {
-        const auto change = qSharedPointerCast<Qt3DCore::QPropertyUpdatedChange>(e);
-        if (change->propertyName() == QByteArrayLiteral("sourceAxis"))
-            m_sourceAxisId = change->value().value<Qt3DCore::QNodeId>();
-        else if (change->propertyName() == QByteArrayLiteral("sourceAxisType"))
-            m_sourceAxisType = change->value().value<QAxisAccumulator::SourceAxisType>();
-        else if (change->propertyName() == QByteArrayLiteral("scale"))
-            m_scale = change->value().toFloat();
-        break;
-    }
+    BackendNode::syncFromFrontEnd(frontEnd, firstTime);
+    const QAxisAccumulator *node = qobject_cast<const QAxisAccumulator *>(frontEnd);
+    if (!node)
+        return;
 
-    default:
-        break;
+    m_sourceAxisId = Qt3DCore::qIdForNode(node->sourceAxis());
+    m_sourceAxisType = node->sourceAxisType();
+    m_scale = node->scale();
+
+    if (firstTime) {
+        m_value = 0.f;
+        m_velocity = 0.f;
     }
-    QBackendNode::sceneChangeEvent(e);
 }
 
 void AxisAccumulator::stepIntegration(AxisManager *axisManager, float dt)
diff --git a/src/input/backend/axisaccumulator_p.h b/src/input/backend/axisaccumulator_p.h
index bb1a35812..2f5a7de63 100644
--- a/src/input/backend/axisaccumulator_p.h
+++ b/src/input/backend/axisaccumulator_p.h
@@ -52,6 +52,7 @@
 //
 
 #include <Qt3DInput/qaxisaccumulator.h>
+#include <Qt3DInput/private/backendnode_p.h>
 #include <Qt3DCore/qbackendnode.h>
 #include <Qt3DCore/qnodeid.h>
 
@@ -62,7 +63,7 @@ namespace Input {
 
 class AxisManager;
 
-class Q_AUTOTEST_EXPORT AxisAccumulator : public Qt3DCore::QBackendNode
+class Q_AUTOTEST_EXPORT AxisAccumulator : public BackendNode
 {
 public:
     AxisAccumulator();
@@ -78,13 +79,11 @@ public:
     float velocity() const Q_DECL_NOTHROW { return  m_velocity; }
     void setVelocity(float velocity);
 
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
 
     void stepIntegration(AxisManager *axisManager, float dt);
 
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
-
     Qt3DCore::QNodeId m_sourceAxisId;
     QAxisAccumulator::SourceAxisType m_sourceAxisType;
     float m_scale;
diff --git a/src/input/frontend/qinputaspect.cpp b/src/input/frontend/qinputaspect.cpp
index fffde2851..e3816968b 100644
--- a/src/input/frontend/qinputaspect.cpp
+++ b/src/input/frontend/qinputaspect.cpp
@@ -150,7 +150,7 @@ QInputAspect::QInputAspect(QInputAspectPrivate &dd, QObject *parent)
     registerBackendType<QMouseDevice, true>(QBackendNodeMapperPtr(new Input::MouseDeviceFunctor(this, d_func()->m_inputHandler.data())));
     registerBackendType<QMouseHandler>(QBackendNodeMapperPtr(new Input::MouseHandlerFunctor(d_func()->m_inputHandler.data())));
     registerBackendType<QAxis, true>(QBackendNodeMapperPtr(new Input::InputNodeFunctor<Input::Axis, Input::AxisManager>(d_func()->m_inputHandler->axisManager())));
-    registerBackendType<QAxisAccumulator>(QBackendNodeMapperPtr(new Input::InputNodeFunctor<Input::AxisAccumulator, Input::AxisAccumulatorManager>(d_func()->m_inputHandler->axisAccumulatorManager())));
+    registerBackendType<QAxisAccumulator, true>(QBackendNodeMapperPtr(new Input::InputNodeFunctor<Input::AxisAccumulator, Input::AxisAccumulatorManager>(d_func()->m_inputHandler->axisAccumulatorManager())));
     registerBackendType<QAnalogAxisInput>(QBackendNodeMapperPtr(new Input::InputNodeFunctor<Input::AnalogAxisInput, Input::AnalogAxisInputManager>(d_func()->m_inputHandler->analogAxisInputManager())));
     registerBackendType<QButtonAxisInput>(QBackendNodeMapperPtr(new Input::InputNodeFunctor<Input::ButtonAxisInput, Input::ButtonAxisInputManager>(d_func()->m_inputHandler->buttonAxisInputManager())));
     registerBackendType<QAxisSetting, true>(QBackendNodeMapperPtr(new Input::InputNodeFunctor<Input::AxisSetting, Input::AxisSettingManager>(d_func()->m_inputHandler->axisSettingManager())));
diff --git a/tests/auto/input/axisaccumulator/tst_axisaccumulator.cpp b/tests/auto/input/axisaccumulator/tst_axisaccumulator.cpp
index 8e0b499fd..f71f27440 100644
--- a/tests/auto/input/axisaccumulator/tst_axisaccumulator.cpp
+++ b/tests/auto/input/axisaccumulator/tst_axisaccumulator.cpp
@@ -61,7 +61,7 @@ private Q_SLOTS:
         axisAccumulator.setScale(2.0f);
 
         // WHEN
-        simulateInitialization(&axisAccumulator, &backendAccumulator);
+        simulateInitializationSync(&axisAccumulator, &backendAccumulator);
 
         // THEN
         QCOMPARE(backendAccumulator.peerId(), axisAccumulator.id());
@@ -95,7 +95,7 @@ private Q_SLOTS:
         axisAccumulator.setEnabled(true);
 
         // WHEN
-        simulateInitialization(&axisAccumulator, &backendAxisAccumulator);
+        simulateInitializationSync(&axisAccumulator, &backendAxisAccumulator);
         backendAxisAccumulator.cleanup();
 
         // THEN
@@ -110,43 +110,36 @@ private Q_SLOTS:
     void checkPropertyChanges()
     {
         // GIVEN
+        Qt3DInput::QAxisAccumulator axisAccumulator;
         Qt3DInput::Input::AxisAccumulator backendAxisAccumulator;
-        Qt3DCore::QPropertyUpdatedChangePtr updateChange;
+        simulateInitializationSync(&axisAccumulator, &backendAxisAccumulator);
 
         // WHEN
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        updateChange->setPropertyName("enabled");
-        updateChange->setValue(true);
-        backendAxisAccumulator.sceneChangeEvent(updateChange);
+        axisAccumulator.setEnabled(false);
+        backendAxisAccumulator.syncFromFrontEnd(&axisAccumulator, false);
 
         // THEN
-        QCOMPARE(backendAxisAccumulator.isEnabled(), true);
+        QCOMPARE(backendAxisAccumulator.isEnabled(), false);
 
         // WHEN
         Qt3DInput::QAxis axis;
         const Qt3DCore::QNodeId axisId = axis.id();
-        updateChange = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-        updateChange->setPropertyName("sourceAxis");
-        updateChange->setValue(QVariant::fromValue(axisId));
-        backendAxisAccumulator.sceneChangeEvent(updateChange);
+        axisAccumulator.setSourceAxis(&axis);
+        backendAxisAccumulator.syncFromFrontEnd(&axisAccumulator, false);
 
         // THEN
         QCOMPARE(backendAxisAccumulator.sourceAxisId(), axisId);
 
         // WHEN
-        updateChange = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-        updateChange->setPropertyName("sourceAxisType");
-        updateChange->setValue(Qt3DInput::QAxisAccumulator::Acceleration);
-        backendAxisAccumulator.sceneChangeEvent(updateChange);
+        axisAccumulator.setSourceAxisType(Qt3DInput::QAxisAccumulator::Acceleration);
+        backendAxisAccumulator.syncFromFrontEnd(&axisAccumulator, false);
 
         // THEN
         QCOMPARE(backendAxisAccumulator.sourceAxisType(), Qt3DInput::QAxisAccumulator::Acceleration);
 
         // WHEN
-        updateChange = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-        updateChange->setPropertyName("scale");
-        updateChange->setValue(3.0f);
-        backendAxisAccumulator.sceneChangeEvent(updateChange);
+        axisAccumulator.setScale(3.f);
+        backendAxisAccumulator.syncFromFrontEnd(&axisAccumulator, false);
 
         // THEN
         QCOMPARE(backendAxisAccumulator.scale(), 3.0f);
@@ -288,7 +281,7 @@ private Q_SLOTS:
         axisAccumulator.setScale(scale);
         axisAccumulator.setSourceAxisType(sourceAxisType);
         axisAccumulator.setEnabled(true);
-        simulateInitialization(&axisAccumulator, &backendAxisAccumulator);
+        simulateInitializationSync(&axisAccumulator, &backendAxisAccumulator);
 
         backendAxisAccumulator.stepIntegration(&axisManager, dt);
 
diff --git a/tests/auto/input/axisaccumulatorjob/tst_axisaccumulatorjob.cpp b/tests/auto/input/axisaccumulatorjob/tst_axisaccumulatorjob.cpp
index fa3bca3d2..51ae35598 100644
--- a/tests/auto/input/axisaccumulatorjob/tst_axisaccumulatorjob.cpp
+++ b/tests/auto/input/axisaccumulatorjob/tst_axisaccumulatorjob.cpp
@@ -79,7 +79,7 @@ private Q_SLOTS:
             axisAccumulator->setSourceAxis(axis);
             axisAccumulator->setScale(scale);
             axisAccumulator->setSourceAxisType(sourceAxisType);
-            simulateInitialization(axisAccumulator, backendAxisAccumulator);
+            simulateInitializationSync(axisAccumulator, backendAxisAccumulator);
         }
 
         // WHEN