Update QShaderData to use direct sync

Also a bit of cleanup

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

7 files changed, 160 insertions, 238 deletions

diff --git a/src/render/frontend/qrenderaspect.cpp b/src/render/frontend/qrenderaspect.cpp
index 70ec70b2b..159c11981 100644
--- a/src/render/frontend/qrenderaspect.cpp
+++ b/src/render/frontend/qrenderaspect.cpp
@@ -288,7 +288,7 @@ void QRenderAspectPrivate::registerBackendTypes()
     q->registerBackendType<QMaterial, true>(QSharedPointer<Render::NodeFunctor<Render::Material, Render::MaterialManager> >::create(m_renderer));
     q->registerBackendType<QParameter, true>(QSharedPointer<Render::NodeFunctor<Render::Parameter, Render::ParameterManager> >::create(m_renderer));
     q->registerBackendType<QRenderPass, true>(QSharedPointer<Render::NodeFunctor<Render::RenderPass, Render::RenderPassManager> >::create(m_renderer));
-    q->registerBackendType<QShaderData>(QSharedPointer<Render::RenderShaderDataFunctor>::create(m_renderer, m_nodeManagers));
+    q->registerBackendType<QShaderData, true>(QSharedPointer<Render::RenderShaderDataFunctor>::create(m_renderer, m_nodeManagers));
     q->registerBackendType<QShaderProgram, true>(QSharedPointer<Render::NodeFunctor<Render::Shader, Render::ShaderManager> >::create(m_renderer));
     q->registerBackendType<QShaderProgramBuilder, true>(QSharedPointer<Render::NodeFunctor<Render::ShaderBuilder, Render::ShaderBuilderManager> >::create(m_renderer));
     q->registerBackendType<QTechnique, true>(QSharedPointer<Render::TechniqueFunctor>::create(m_renderer, m_nodeManagers));
diff --git a/src/render/materialsystem/shaderdata.cpp b/src/render/materialsystem/shaderdata.cpp
index 130333898..34d4641e9 100644
--- a/src/render/materialsystem/shaderdata.cpp
+++ b/src/render/materialsystem/shaderdata.cpp
@@ -64,8 +64,6 @@ const int qNodeIdTypeId = qMetaTypeId<Qt3DCore::QNodeId>();
 
 }
 
-QVector<Qt3DCore::QNodeId> ShaderData::m_updatedShaderData;
-
 ShaderData::ShaderData()
     : m_managers(nullptr)
 {
@@ -80,51 +78,82 @@ void ShaderData::setManagers(NodeManagers *managers)
     m_managers = managers;
 }
 
-void ShaderData::initializeFromPeer(const QNodeCreatedChangeBasePtr &change)
+void ShaderData::syncFromFrontEnd(const QNode *frontEnd, bool firstTime)
 {
-    const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QShaderDataData>>(change);
-    const QShaderDataData &data = typedChange->data;
-
-    m_propertyReader = data.propertyReader;
-
-    for (const QPair<QByteArray, QVariant> &entry : data.properties) {
-        if (entry.first == QByteArrayLiteral("data") ||
-                entry.first == QByteArrayLiteral("childNodes")) // We don't handle default Node properties
-            continue;
-        const QVariant &propertyValue = entry.second;
-        const QString propertyName = QString::fromLatin1(entry.first);
-
-        m_originalProperties.insert(propertyName, propertyValue);
-
-        // We check if the property is a QNodeId or QVector<QNodeId> so that we can
-        // check nested QShaderData for update
-        if (propertyValue.userType() == qNodeIdTypeId) {
-            m_nestedShaderDataProperties.insert(propertyName, propertyValue);
-        } else if (propertyValue.userType() == QMetaType::QVariantList) {
-            QVariantList list = propertyValue.value<QVariantList>();
-            if (list.count() > 0 && list.at(0).userType() == qNodeIdTypeId)
-                m_nestedShaderDataProperties.insert(propertyName, propertyValue);
-        }
-    }
+    const QShaderData *node = qobject_cast<const QShaderData *>(frontEnd);
+    if (!node)
+        return;
+    BackendNode::syncFromFrontEnd(frontEnd, firstTime);
+
+    if (firstTime) {
+        m_propertyReader = node->propertyReader();
+
+        const QMetaObject *metaObj = node->metaObject();
+        const int propertyOffset = QShaderData::staticMetaObject.propertyOffset();
+        const int propertyCount = metaObj->propertyCount();
+        // Dynamic properties names
+        const auto dynamicPropertyNames = node->dynamicPropertyNames();
 
-    // We look for transformed properties once the complete hash of
-    // originalProperties is available
-    QHash<QString, QVariant>::iterator it = m_originalProperties.begin();
-    const QHash<QString, QVariant>::iterator end = m_originalProperties.end();
-
-    while (it != end) {
-        if (it.value().type() == QVariant::Vector3D) {
-            // if there is a matching QShaderData::TransformType propertyTransformed
-            QVariant value = m_originalProperties.value(it.key() + QLatin1String("Transformed"));
-            // if that's the case, we apply a space transformation to the property
-            if (value.isValid() && value.type() == QVariant::Int)
-                m_transformedProperties.insert(it.key(), static_cast<TransformType>(value.toInt()));
+        QVector<QString> propertyNames;
+        propertyNames.reserve(propertyCount - propertyOffset + dynamicPropertyNames.size());
+
+        // Statiically defined properties
+        for (int i = propertyOffset; i < propertyCount; ++i) {
+            const QMetaProperty pro = metaObj->property(i);
+            if (pro.isWritable())
+                propertyNames.push_back(QString::fromLatin1(pro.name()));
+        }
+        // Dynamic properties
+        for (const QByteArray &propertyName : dynamicPropertyNames)
+            propertyNames.push_back(QString::fromLatin1(propertyName));
+
+        for (const QString &propertyName : propertyNames) {
+            if (propertyName == QStringLiteral("data") ||
+                    propertyName == QStringLiteral("childNodes")) // We don't handle default Node properties
+                continue;
+
+            const QVariant &propertyValue = m_propertyReader->readProperty(node->property(propertyName.toLatin1()));
+            bool isNested = false;
+            bool isTransformed = false;
+
+            // We check if the property is a QNodeId
+            isNested = (propertyValue.userType() == qNodeIdTypeId);
+            // We check if QVector<QNodeId>
+            if (propertyValue.userType() == QMetaType::QVariantList) {
+                QVariantList list = propertyValue.value<QVariantList>();
+                if (list.count() > 0 && list.at(0).userType() == qNodeIdTypeId)
+                    isNested = true;
+            }
+
+            // We check if property is a Transformed property
+            if (propertyValue.userType() == QVariant::Vector3D) {
+                // if there is a matching QShaderData::TransformType propertyTransformed
+                isTransformed = propertyNames.contains(propertyName + QLatin1String("Transformed"));
+            }
+            m_originalProperties.insert(propertyName, { propertyValue, isNested, isTransformed });
+        }
+        BackendNode::markDirty(AbstractRenderer::ParameterDirty);
+    } else {
+        // Updates
+        if (!m_propertyReader.isNull()) {
+            auto it = m_originalProperties.begin();
+            const auto end = m_originalProperties.end();
+
+            while (it != end) {
+                const QVariant newValue = m_propertyReader->readProperty(node->property(it.key().toLatin1()));
+                PropertyValue &propValue = it.value();
+                if (propValue.value != newValue) {
+                    // Note we aren't notified about nested QShaderData in this call
+                    // only scalar / vec properties
+                    propValue.value = newValue;
+                    BackendNode::markDirty(AbstractRenderer::ParameterDirty);
+                }
+                ++it;
+            }
         }
-        ++it;
     }
 }
 
-
 ShaderData *ShaderData::lookupResource(NodeManagers *managers, QNodeId id)
 {
     return managers->shaderDataManager()->lookupResource(id);
@@ -135,120 +164,62 @@ ShaderData *ShaderData::lookupResource(QNodeId id)
     return ShaderData::lookupResource(m_managers, id);
 }
 
-// Call by cleanup job (single thread)
-void ShaderData::clearUpdatedProperties()
-{
-    // DISABLED: Is only useful when building UBO from a ShaderData, which is disable since 5.7
-    //    const QHash<QString, QVariant>::const_iterator end = m_nestedShaderDataProperties.end();
-    //    QHash<QString, QVariant>::const_iterator it = m_nestedShaderDataProperties.begin();
-
-    //    while (it != end) {
-    //        if (it.value().userType() == QMetaType::QVariantList) {
-    //            const auto values = it.value().value<QVariantList>();
-    //            for (const QVariant &v : values) {
-    //                ShaderData *nested = lookupResource(v.value<QNodeId>());
-    //                if (nested != nullptr)
-    //                    nested->clearUpdatedProperties();
-    //            }
-    //        } else {
-    //            ShaderData *nested = lookupResource(it.value().value<QNodeId>());
-    //            if (nested != nullptr)
-    //                nested->clearUpdatedProperties();
-    //        }
-    //        ++it;
-    //    }
-}
-
 void ShaderData::cleanup(NodeManagers *managers)
 {
     Q_UNUSED(managers)
-    // DISABLED: Is only useful when building UBO from a ShaderData, which is disable since 5.7
-    //    for (Qt3DCore::QNodeId id : qAsConst(m_updatedShaderData)) {
-    //        ShaderData *shaderData = ShaderData::lookupResource(managers, id);
-    //        if (shaderData)
-    //            shaderData->clearUpdatedProperties();
-    //    }
-    m_updatedShaderData.clear();
 }
 
+// RenderCommand updater jobs
 QVariant ShaderData::getTransformedProperty(const QString &name, const Matrix4x4 &viewMatrix)
 {
     // Note protecting m_worldMatrix at this point as we assume all world updates
     // have been performed when reaching this point
-    auto it = m_transformedProperties.find(name);
-    if (it != m_transformedProperties.end()) {
-        const TransformType transformType = it.value();
-        switch (transformType) {
-        case ModelToEye:
-            return QVariant::fromValue(viewMatrix * m_worldMatrix * Vector3D(m_originalProperties.value(name).value<QVector3D>()));
-        case ModelToWorld:
-            return QVariant::fromValue(m_worldMatrix * Vector3D(m_originalProperties.value(it.key()).value<QVector3D>()));
-        case ModelToWorldDirection:
-            return QVariant::fromValue(Vector3D(m_worldMatrix * Vector4D(m_originalProperties.value(it.key()).value<QVector3D>(), 0.0f)));
-        case NoTransform:
-            break;
+    const auto it = m_originalProperties.constFind(name);
+    if (it != m_originalProperties.constEnd()) {
+        const PropertyValue &propertyValue = it.value();
+        if (propertyValue.isTransformed) {
+            const auto transformedIt = m_originalProperties.constFind(name + QLatin1String("Transformed"));
+            if (transformedIt != m_originalProperties.constEnd()) {
+                const PropertyValue &transformedValue = transformedIt.value();
+                const TransformType transformType = static_cast<TransformType>(transformedValue.value.toInt());
+                switch (transformType) {
+                case ModelToEye:
+                    return QVariant::fromValue(viewMatrix * m_worldMatrix * Vector3D(propertyValue.value.value<QVector3D>()));
+                case ModelToWorld:
+                    return QVariant::fromValue(m_worldMatrix * Vector3D(propertyValue.value.value<QVector3D>()));
+                case ModelToWorldDirection:
+                    return QVariant::fromValue(Vector3D(m_worldMatrix * Vector4D(propertyValue.value.value<QVector3D>(), 0.0f)));
+                case NoTransform:
+                    break;
+                }
+            }
         }
+        return propertyValue.value;
     }
     return QVariant();
 }
 
-// Called by FramePreparationJob or by RenderView when dealing with lights
-void ShaderData::updateWorldTransform(const Matrix4x4 &worldMatrix)
-{
-    QMutexLocker lock(&m_mutex);
-    if (m_worldMatrix != worldMatrix) {
-        m_worldMatrix = worldMatrix;
-    }
-}
-
-// This will add the ShaderData to be cleared from updates at the end of the frame
-// by the cleanup job
-// Called by renderview jobs (several concurrent threads)
-void ShaderData::markDirty()
-{
-    QMutexLocker lock(&m_mutex);
-    if (!ShaderData::m_updatedShaderData.contains(peerId()))
-        ShaderData::m_updatedShaderData.append(peerId());
-}
-
-/*!
-  \internal
-  Lookup if the current ShaderData or a nested ShaderData has updated properties.
-  UpdateProperties contains either the value of the propertie of a QNodeId if it's another ShaderData.
-  Transformed properties are updated for all of ShaderData that have ones at the point.
-
-  \note This needs to be performed for every top level ShaderData every time it is used.
-  As we don't know if the transformed properties use the same viewMatrix for all RenderViews.
- */
-
+// Unit tests only
 ShaderData::TransformType ShaderData::propertyTransformType(const QString &name) const
 {
-    return m_transformedProperties.value(name, TransformType::NoTransform);
+    const auto it = m_originalProperties.constFind(name);
+    if (it != m_originalProperties.constEnd()) {
+        const PropertyValue &propertyValue = it.value();
+        if (propertyValue.isTransformed) {
+            auto transformedIt = m_originalProperties.constFind(name + QLatin1String("Transformed"));
+            if (transformedIt != m_originalProperties.end())
+                return static_cast<TransformType>(transformedIt.value().value.toInt());
+        }
+    }
+    return NoTransform;
 }
 
-void ShaderData::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
+// Called by FramePreparationJob or by RenderView when dealing with lights
+void ShaderData::updateWorldTransform(const Matrix4x4 &worldMatrix)
 {
-    if (!m_propertyReader.isNull() && e->type() == PropertyUpdated) {
-        QString propertyName;
-        QVariant propertyValue;
-
-        if (auto propertyChange = qSharedPointerDynamicCast<QPropertyUpdatedChange>(e)) {
-            propertyName = QString::fromLatin1(propertyChange->propertyName());
-            propertyValue =  m_propertyReader->readProperty(propertyChange->value());
-        } else if (auto propertyChange = qSharedPointerDynamicCast<QDynamicPropertyUpdatedChange>(e)) {
-            propertyName = QString::fromLatin1(propertyChange->propertyName());
-            propertyValue = m_propertyReader->readProperty(propertyChange->value());
-        } else {
-            Q_UNREACHABLE();
-        }
-
-        // Note we aren't notified about nested QShaderData in this call
-        // only scalar / vec properties
-        m_originalProperties.insert(propertyName, propertyValue);
-        BackendNode::markDirty(AbstractRenderer::ParameterDirty);
+    if (m_worldMatrix != worldMatrix) {
+        m_worldMatrix = worldMatrix;
     }
-
-    BackendNode::sceneChangeEvent(e);
 }
 
 RenderShaderDataFunctor::RenderShaderDataFunctor(AbstractRenderer *renderer, NodeManagers *managers)
diff --git a/src/render/materialsystem/shaderdata_p.h b/src/render/materialsystem/shaderdata_p.h
index f9c3ecc79..c9cc22939 100644
--- a/src/render/materialsystem/shaderdata_p.h
+++ b/src/render/materialsystem/shaderdata_p.h
@@ -76,49 +76,42 @@ public:
         ModelToWorld,
         ModelToWorldDirection
     };
+    struct PropertyValue {
+        QVariant value;
+        bool isNested;
+        bool isTransformed;
+    };
 
     ShaderData();
     ~ShaderData();
 
-    QHash<QString, QVariant> properties() const { return m_originalProperties; }
+    QHash<QString, PropertyValue> properties() const { return m_originalProperties; }
 
     // Called by FramePreparationJob
     void updateWorldTransform(const Matrix4x4 &worldMatrix);
 
-    // Call by RenderViewJob
-    void markDirty();
+    QVariant getTransformedProperty(const QString &name, const Matrix4x4 &viewMatrix);
 
+    // Unit tests purposes only
     TransformType propertyTransformType(const QString &name) const;
-    QVariant getTransformedProperty(const QString &name, const Matrix4x4 &viewMatrix);
 
     // Called by FrameCleanupJob
     static void cleanup(NodeManagers *managers);
 
     void setManagers(NodeManagers *managers);
 
-protected:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) override;
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
 
+protected:
     PropertyReaderInterfacePtr m_propertyReader;
 
-    // 1 to 1 match with frontend properties, modified only by sceneChangeEvent
-    QHash<QString, QVariant> m_originalProperties;
-
-    // Contains properties thar are of type ShaderData
-    QHash<QString, QVariant> m_nestedShaderDataProperties;
-
-    // Contains property that are defined like: postionTransformed: ModelToEye
-    QHash<QString, TransformType> m_transformedProperties;
 
+    // 1 to 1 match with frontend properties
+    QHash<QString, PropertyValue> m_originalProperties;
 
-    QMutex m_mutex;
-    static QVector<Qt3DCore::QNodeId> m_updatedShaderData;
     Matrix4x4 m_worldMatrix;
-    Matrix4x4 m_viewMatrix;
     NodeManagers *m_managers;
 
-    void clearUpdatedProperties();
     static ShaderData *lookupResource(NodeManagers *managers, Qt3DCore::QNodeId id);
     ShaderData *lookupResource(Qt3DCore::QNodeId id);
 
diff --git a/src/render/renderers/opengl/jobs/renderviewjobutils.cpp b/src/render/renderers/opengl/jobs/renderviewjobutils.cpp
index c70f82dea..fee1cc4b5 100644
--- a/src/render/renderers/opengl/jobs/renderviewjobutils.cpp
+++ b/src/render/renderers/opengl/jobs/renderviewjobutils.cpp
@@ -512,27 +512,24 @@ void UniformBlockValueBuilder::buildActiveUniformNameValueMapHelper(ShaderData *
             // If the property needs to be transformed, we transform it here as
             // the shaderdata cannot hold transformed properties for multiple
             // thread contexts at once
-            if (currentShaderData->propertyTransformType(qmlPropertyName) != ShaderData::NoTransform)
-                activeUniformNamesToValue.insert(StringToInt::lookupId(varName),
-                                                 currentShaderData->getTransformedProperty(qmlPropertyName, viewMatrix));
-            else
-                activeUniformNamesToValue.insert(StringToInt::lookupId(varName), value);
+            activeUniformNamesToValue.insert(StringToInt::lookupId(varName),
+                                             currentShaderData->getTransformedProperty(qmlPropertyName.toLatin1(), viewMatrix));
         }
     }
 }
 
 void UniformBlockValueBuilder::buildActiveUniformNameValueMapStructHelper(ShaderData *rShaderData, const QString &blockName, const QString &qmlPropertyName)
 {
-    const QHash<QString, QVariant> &properties = rShaderData->properties();
-    QHash<QString, QVariant>::const_iterator it = properties.begin();
-    const QHash<QString, QVariant>::const_iterator end = properties.end();
+    const QHash<QString, ShaderData::PropertyValue> &properties = rShaderData->properties();
+    auto it = properties.begin();
+    const auto end = properties.end();
 
     while (it != end) {
         const auto prefix = qmlPropertyName.isEmpty() ? QLatin1String("") : QLatin1String(".");
         buildActiveUniformNameValueMapHelper(rShaderData,
                                              blockName + prefix + qmlPropertyName,
                                              it.key(),
-                                             it.value());
+                                             it.value().value);
         ++it;
     }
 }
diff --git a/src/render/renderers/opengl/renderer/renderview.cpp b/src/render/renderers/opengl/renderer/renderview.cpp
index 420b32325..8fbe8e188 100644
--- a/src/render/renderers/opengl/renderer/renderview.cpp
+++ b/src/render/renderers/opengl/renderer/renderview.cpp
@@ -849,56 +849,6 @@ void RenderView::setUniformBlockValue(ShaderParameterPack &uniformPack,
             uniformPack.setUniformBuffer(std::move(uniformBlockUBO));
             // Buffer update to GL buffer will be done at render time
         }
-
-
-        //ShaderData *shaderData = nullptr;
-        // if ((shaderData = m_manager->shaderDataManager()->lookupResource(value.value<Qt3DCore::QNodeId>())) != nullptr) {
-        // UBO are indexed by <ShaderId, ShaderDataId> so that a same QShaderData can be used among different shaders
-        // while still making sure that if they have a different layout everything will still work
-        // If two shaders define the same block with the exact same layout, in that case the UBO could be shared
-        // but how do we know that ? We'll need to compare ShaderUniformBlocks
-
-        // Note: we assume that if a buffer is shared across multiple shaders
-        // then it implies that they share the same layout
-
-        // Temporarly disabled
-
-        //        BufferShaderKey uboKey(shaderData->peerId(),
-        //                               shader->peerId());
-
-        //        BlockToUBO uniformBlockUBO;
-        //        uniformBlockUBO.m_blockIndex = block.m_index;
-        //        uniformBlockUBO.m_shaderDataID = shaderData->peerId();
-        //        bool uboNeedsUpdate = false;
-
-        //        // build UBO at uboId if not created before
-        //        if (!m_manager->glBufferManager()->contains(uboKey)) {
-        //            m_manager->glBufferManager()->getOrCreateResource(uboKey);
-        //            uboNeedsUpdate = true;
-        //        }
-
-        //        // If shaderData  has been updated (property has changed or one of the nested properties has changed)
-        //        // foreach property defined in the QShaderData, we try to fill the value of the corresponding active uniform(s)
-        //        // for all the updated properties (all the properties if the UBO was just created)
-        //        if (shaderData->updateViewTransform(*m_data->m_viewMatrix) || uboNeedsUpdate) {
-        //            // Clear previous values remaining in the hash
-        //            m_data->m_uniformBlockBuilder.activeUniformNamesToValue.clear();
-        //            // Update only update properties if uboNeedsUpdate is true, otherwise update the whole block
-        //            m_data->m_uniformBlockBuilder.updatedPropertiesOnly = uboNeedsUpdate;
-        //            // Retrieve names and description of each active uniforms in the uniform block
-        //            m_data->m_uniformBlockBuilder.uniforms = shader->activeUniformsForUniformBlock(block.m_index);
-        //            // Builds the name-value map for the block
-        //            m_data->m_uniformBlockBuilder.buildActiveUniformNameValueMapStructHelper(shaderData, block.m_name);
-        //            if (!uboNeedsUpdate)
-        //                shaderData->markDirty();
-        //            // copy the name-value map into the BlockToUBO
-        //            uniformBlockUBO.m_updatedProperties = m_data->m_uniformBlockBuilder.activeUniformNamesToValue;
-        //            uboNeedsUpdate = true;
-        //        }
-
-        //        uniformBlockUBO.m_needsUpdate = uboNeedsUpdate;
-        //        uniformPack.setUniformBuffer(std::move(uniformBlockUBO));
-        // }
     }
 }
 
diff --git a/tests/auto/render/renderviewutils/tst_renderviewutils.cpp b/tests/auto/render/renderviewutils/tst_renderviewutils.cpp
index cf0c25d10..6d349f994 100644
--- a/tests/auto/render/renderviewutils/tst_renderviewutils.cpp
+++ b/tests/auto/render/renderviewutils/tst_renderviewutils.cpp
@@ -34,7 +34,7 @@
 #include <Qt3DRender/private/managers_p.h>
 #include <Qt3DRender/private/stringtoint_p.h>
 #include <Qt3DRender/qshaderdata.h>
-
+#include "testrenderer.h"
 #include "testpostmanarbiter.h"
 
 class tst_RenderViewUtils : public Qt3DCore::QBackendNodeTester
@@ -54,20 +54,22 @@ private Q_SLOTS:
     void shouldNotifyDynamicPropertyChanges();
 
 private:
-    void initBackendShaderData(Qt3DRender::QShaderData *frontend,
+    void initBackendShaderData(Qt3DRender::Render::AbstractRenderer *renderer,
+                               Qt3DRender::QShaderData *frontend,
                                Qt3DRender::Render::ShaderDataManager *manager)
     {
         // Create children first
         for (QObject *c : frontend->children()) {
             Qt3DRender::QShaderData *cShaderData = qobject_cast<Qt3DRender::QShaderData *>(c);
             if (cShaderData)
-                initBackendShaderData(cShaderData, manager);
+                initBackendShaderData(renderer, cShaderData, manager);
         }
 
         // Create backend element for frontend one
         Qt3DRender::Render::ShaderData *backend = manager->getOrCreateResource(frontend->id());
         // Init the backend element
-        simulateInitialization(frontend, backend);
+        backend->setRenderer(renderer);
+        simulateInitializationSync(frontend, backend);
     }
 
     void initBackendTexture(Qt3DRender::QAbstractTexture *frontend,
@@ -345,13 +347,14 @@ private:
 void tst_RenderViewUtils::topLevelScalarValueNoUniforms()
 {
     // GIVEN
+    TestRenderer renderer;
     QScopedPointer<ScalarShaderData> shaderData(new ScalarShaderData());
     QScopedPointer<Qt3DRender::Render::ShaderDataManager> manager(new Qt3DRender::Render::ShaderDataManager());
     QScopedPointer<Qt3DRender::Render::TextureManager> textureManager(new Qt3DRender::Render::TextureManager());
 
     // WHEN
     shaderData->setScalar(883.0f);
-    initBackendShaderData(shaderData.data(), manager.data());
+    initBackendShaderData(&renderer, shaderData.data(), manager.data());
 
     // THEN
     Qt3DRender::Render::ShaderData *backendShaderData = manager->lookupResource(shaderData->id());
@@ -373,13 +376,14 @@ void tst_RenderViewUtils::topLevelScalarValueNoUniforms()
 void tst_RenderViewUtils::topLevelScalarValue()
 {
     // GIVEN
+    TestRenderer renderer;
     QScopedPointer<ScalarShaderData> shaderData(new ScalarShaderData());
     QScopedPointer<Qt3DRender::Render::ShaderDataManager> manager(new Qt3DRender::Render::ShaderDataManager());
     QScopedPointer<Qt3DRender::Render::TextureManager> textureManager(new Qt3DRender::Render::TextureManager());
 
     // WHEN
     shaderData->setScalar(883.0f);
-    initBackendShaderData(shaderData.data(), manager.data());
+    initBackendShaderData(&renderer, shaderData.data(), manager.data());
 
     // THEN
     Qt3DRender::Render::ShaderData *backendShaderData = manager->lookupResource(shaderData->id());
@@ -413,6 +417,7 @@ void tst_RenderViewUtils::topLevelScalarValue()
 void tst_RenderViewUtils::topLevelTextureValueNoUniforms()
 {
     // GIVEN
+    TestRenderer renderer;
     QScopedPointer<TextureShaderData> shaderData(new TextureShaderData);
     QScopedPointer<Qt3DRender::Render::ShaderDataManager> manager(new Qt3DRender::Render::ShaderDataManager);
     QScopedPointer<Qt3DRender::QAbstractTexture> texture(new Qt3DRender::QTexture2D);
@@ -420,7 +425,7 @@ void tst_RenderViewUtils::topLevelTextureValueNoUniforms()
 
     // WHEN
     shaderData->setTexture(texture.data());
-    initBackendShaderData(shaderData.data(), manager.data());
+    initBackendShaderData(&renderer, shaderData.data(), manager.data());
 
     // THEN
     Qt3DRender::Render::ShaderData *backendShaderData = manager->lookupResource(shaderData->id());
@@ -442,6 +447,7 @@ void tst_RenderViewUtils::topLevelTextureValueNoUniforms()
 void tst_RenderViewUtils::topLevelTextureValue()
 {
     // GIVEN
+    TestRenderer renderer;
     QScopedPointer<TextureShaderData> shaderData(new TextureShaderData);
     QScopedPointer<Qt3DRender::Render::ShaderDataManager> manager(new Qt3DRender::Render::ShaderDataManager);
     QScopedPointer<Qt3DRender::QAbstractTexture> texture(new Qt3DRender::QTexture2D);
@@ -450,7 +456,7 @@ void tst_RenderViewUtils::topLevelTextureValue()
     // WHEN
     initBackendTexture(texture.data(), textureManager.data());
     shaderData->setTexture(texture.data());
-    initBackendShaderData(shaderData.data(), manager.data());
+    initBackendShaderData(&renderer, shaderData.data(), manager.data());
 
     // THEN
     Qt3DRender::Render::ShaderData *backendShaderData = manager->lookupResource(shaderData->id());
@@ -484,6 +490,7 @@ void tst_RenderViewUtils::topLevelTextureValue()
 void tst_RenderViewUtils::topLevelArrayValue()
 {
     // GIVEN
+    TestRenderer renderer;
     QScopedPointer<ArrayShaderData> shaderData(new ArrayShaderData());
     QScopedPointer<Qt3DRender::Render::ShaderDataManager> manager(new Qt3DRender::Render::ShaderDataManager());
     QScopedPointer<Qt3DRender::Render::TextureManager> textureManager(new Qt3DRender::Render::TextureManager());
@@ -491,7 +498,7 @@ void tst_RenderViewUtils::topLevelArrayValue()
     // WHEN
     QVariantList arrayValues = QVariantList() << 454 << 350 << 383 << 427 << 552;
     shaderData->setArray(arrayValues);
-    initBackendShaderData(shaderData.data(), manager.data());
+    initBackendShaderData(&renderer, shaderData.data(), manager.data());
 
     // THEN
     Qt3DRender::Render::ShaderData *backendShaderData = manager->lookupResource(shaderData->id());
@@ -525,6 +532,7 @@ void tst_RenderViewUtils::topLevelArrayValue()
 void tst_RenderViewUtils::nestedShaderDataValue()
 {
     // GIVEN
+    TestRenderer renderer;
     QScopedPointer<ArrayShaderData> arrayShaderData(new ArrayShaderData());
     QScopedPointer<Qt3DRender::Render::ShaderDataManager> manager(new Qt3DRender::Render::ShaderDataManager());
     QScopedPointer<Qt3DRender::Render::TextureManager> textureManager(new Qt3DRender::Render::TextureManager());
@@ -549,7 +557,7 @@ void tst_RenderViewUtils::nestedShaderDataValue()
     // WHEN
     const QVariantList arrayValues = QVariantList() << QVariant::fromValue(id1) << QVariant::fromValue(id2) << QVariant::fromValue(id3);
     arrayShaderData->setArray(arrayValues);
-    initBackendShaderData(arrayShaderData.data(), manager.data());
+    initBackendShaderData(&renderer, arrayShaderData.data(), manager.data());
 
     // THEN
     Qt3DRender::Render::ShaderData *backendArrayShaderData = manager->lookupResource(arrayShaderData->id());
@@ -624,13 +632,14 @@ void tst_RenderViewUtils::topLevelStructValue_data()
 void tst_RenderViewUtils::topLevelStructValue()
 {
     // GIVEN
+    TestRenderer renderer;
     QFETCH(StructShaderData *, shaderData);
     QFETCH(QString, blockName);
     QScopedPointer<Qt3DRender::Render::ShaderDataManager> manager(new Qt3DRender::Render::ShaderDataManager());
     QScopedPointer<Qt3DRender::Render::TextureManager> textureManager(new Qt3DRender::Render::TextureManager());
 
     // WHEN
-    initBackendShaderData(shaderData, manager.data());
+    initBackendShaderData(&renderer, shaderData, manager.data());
 
     // THEN
     Qt3DRender::Render::ShaderData *backendShaderData = manager->lookupResource(shaderData->id());
@@ -665,6 +674,7 @@ void tst_RenderViewUtils::topLevelStructValue()
 void tst_RenderViewUtils::topLevelDynamicProperties()
 {
     // GIVEN
+    TestRenderer renderer;
     QScopedPointer<Qt3DRender::QShaderData> shaderData(new Qt3DRender::QShaderData());
     QScopedPointer<Qt3DRender::Render::ShaderDataManager> manager(new Qt3DRender::Render::ShaderDataManager());
     QScopedPointer<Qt3DRender::QAbstractTexture> texture(new Qt3DRender::QTexture2D);
@@ -675,7 +685,7 @@ void tst_RenderViewUtils::topLevelDynamicProperties()
     shaderData->setProperty("scalar", 883.0f);
     shaderData->setProperty("array", QVariantList() << 454 << 350 << 383 << 427 << 552);
     shaderData->setProperty("texture", QVariant::fromValue(texture.data()));
-    initBackendShaderData(shaderData.data(), manager.data());
+    initBackendShaderData(&renderer, shaderData.data(), manager.data());
 
     // THEN
     Qt3DRender::Render::ShaderData *backendShaderData = manager->lookupResource(shaderData->id());
@@ -709,6 +719,7 @@ void tst_RenderViewUtils::transformedProperties()
     // GIVEN
     QScopedPointer<Qt3DRender::QShaderData> shaderData(new Qt3DRender::QShaderData());
     QScopedPointer<Qt3DRender::Render::ShaderDataManager> manager(new Qt3DRender::Render::ShaderDataManager());
+    TestRenderer renderer;
 
     // WHEN
     const Vector3D position = Vector3D(15.0f, -5.0f, 10.0f);
@@ -733,7 +744,7 @@ void tst_RenderViewUtils::transformedProperties()
     shaderData->setProperty("position1Transformed", Qt3DRender::Render::ShaderData::ModelToEye);
     shaderData->setProperty("position2Transformed", Qt3DRender::Render::ShaderData::ModelToWorld);
     shaderData->setProperty("position3Transformed", Qt3DRender::Render::ShaderData::ModelToWorldDirection);
-    initBackendShaderData(shaderData.data(), manager.data());
+    initBackendShaderData(&renderer, shaderData.data(), manager.data());
 
     // THEN
     Qt3DRender::Render::ShaderData *backendShaderData = manager->lookupResource(shaderData->id());
@@ -751,7 +762,7 @@ void tst_RenderViewUtils::transformedProperties()
     const QVariant position0Value = backendShaderData->getTransformedProperty(QStringLiteral("position0"), viewMatrix);
 
     // THEN
-    QCOMPARE(position0Value, QVariant());
+    QCOMPARE(position0Value, positionQt);
     QCOMPARE(position1Value, viewMatrix * worldMatrix * position);
     QCOMPARE(position2Value, worldMatrix * position);
     QCOMPARE(position3Value, Vector3D((worldMatrix * Vector4D(position, 0.0f))));
diff --git a/tests/auto/render/updateshaderdatatransformjob/tst_updateshaderdatatransformjob.cpp b/tests/auto/render/updateshaderdatatransformjob/tst_updateshaderdatatransformjob.cpp
index 492aa0fde..b2d0b612c 100644
--- a/tests/auto/render/updateshaderdatatransformjob/tst_updateshaderdatatransformjob.cpp
+++ b/tests/auto/render/updateshaderdatatransformjob/tst_updateshaderdatatransformjob.cpp
@@ -207,11 +207,11 @@ private Q_SLOTS:
 
         // THEN
         QCOMPARE(backendShaderData->properties().size(), 3);
-        QVERIFY(backendShaderData->properties().contains(QLatin1String("eyePosition")));
-        QVERIFY(backendShaderData->properties().contains(QLatin1String("eyePositionTransformed")));
+        QVERIFY(backendShaderData->properties().contains(QStringLiteral("eyePosition")));
+        QVERIFY(backendShaderData->properties().contains(QStringLiteral("eyePositionTransformed")));
 
-        QCOMPARE(backendShaderData->properties()[QLatin1String("eyePosition")].value<QVector3D>(), QVector3D(1.0f, 1.0f, 1.0f));
-        QCOMPARE(backendShaderData->properties()[QLatin1String("eyePositionTransformed")].toInt(), int(Qt3DRender::Render::ShaderData::ModelToEye));
+        QCOMPARE(backendShaderData->properties()[QStringLiteral("eyePosition")].value.value<QVector3D>(), QVector3D(1.0f, 1.0f, 1.0f));
+        QCOMPARE(backendShaderData->properties()[QStringLiteral("eyePositionTransformed")].value.toInt(), int(Qt3DRender::Render::ShaderData::ModelToEye));
 
         // WHEN
         Qt3DRender::Render::UpdateShaderDataTransformJob backendUpdateShaderDataTransformJob;
@@ -220,7 +220,7 @@ private Q_SLOTS:
 
         // THEN
         // See scene file to find translation
-        QCOMPARE(backendShaderData->getTransformedProperty(QLatin1String("eyePosition"), Matrix4x4(camera->viewMatrix())).value<Vector3D>(),
+        QCOMPARE(backendShaderData->getTransformedProperty(QStringLiteral("eyePosition"), Matrix4x4(camera->viewMatrix())).value<Vector3D>(),
                  Matrix4x4(camera->viewMatrix()) * (Vector3D(1.0f, 1.0f, 1.0f) + Vector3D(0.0f, 5.0f, 0.0f)));
     }
 
@@ -248,11 +248,11 @@ private Q_SLOTS:
 
         // THEN
         QCOMPARE(backendShaderData->properties().size(), 3);
-        QVERIFY(backendShaderData->properties().contains(QLatin1String("position")));
-        QVERIFY(backendShaderData->properties().contains(QLatin1String("positionTransformed")));
+        QVERIFY(backendShaderData->properties().contains(QStringLiteral("position")));
+        QVERIFY(backendShaderData->properties().contains(QStringLiteral("positionTransformed")));
 
-        QCOMPARE(backendShaderData->properties()[QLatin1String("position")].value<QVector3D>(), QVector3D(1.0f, 1.0f, 1.0f));
-        QCOMPARE(backendShaderData->properties()[QLatin1String("positionTransformed")].toInt(), int(Qt3DRender::Render::ShaderData::ModelToWorld));
+        QCOMPARE(backendShaderData->properties()[QStringLiteral("position")].value.value<QVector3D>(), QVector3D(1.0f, 1.0f, 1.0f));
+        QCOMPARE(backendShaderData->properties()[QStringLiteral("positionTransformed")].value.toInt(), int(Qt3DRender::Render::ShaderData::ModelToWorld));
 
         // WHEN
         Qt3DRender::Render::UpdateShaderDataTransformJob backendUpdateShaderDataTransformJob;
@@ -261,7 +261,7 @@ private Q_SLOTS:
 
         // THEN
         // See scene file to find translation
-        QCOMPARE(backendShaderData->getTransformedProperty(QLatin1String("position"), Matrix4x4(camera->viewMatrix())).value<Vector3D>(),
+        QCOMPARE(backendShaderData->getTransformedProperty(QStringLiteral("position"), Matrix4x4(camera->viewMatrix())).value<Vector3D>(),
                  Vector3D(1.0f, 1.0f, 1.0f) + Vector3D(5.0f, 5.0f, 5.0f));
     }
 };