Revision control
++ // Copyright (C) 2015 Klaralvdalens Datakonsult AB (KDAB).
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
++
++ #include <QtTest/QTest>
++ #include <qbackendnodetester.h>
++ #include <shadervariables_p.h>
++ #include <Qt3DRender/private/renderviewjobutils_p.h>
++ #include <Qt3DRender/private/shaderdata_p.h>
++ #include <Qt3DRender/private/managers_p.h>
++ #include <Qt3DRender/private/stringtoint_p.h>
++ #include <Qt3DRender/private/uniformblockbuilder_p.h>
++ #include <Qt3DRender/qshaderdata.h>
++ #include <QVariant>
++ #include "testrenderer.h"
++ #include "testarbiter.h"
++
++ class tst_RenderViewUtils : public Qt3DCore::QBackendNodeTester
++ {
++ Q_OBJECT
++ private Q_SLOTS:
++ void topLevelScalarValueNoUniforms();
++ void topLevelScalarValue();
++ void topLevelTextureValueNoUniforms();
++ void topLevelTextureValue();
++ void topLevelArrayValue();
++ void nestedShaderDataValue();
++ void topLevelStructValue_data();
++ void topLevelStructValue();
++ void topLevelDynamicProperties();
++ void transformedProperties();
++ void shouldNotifyDynamicPropertyChanges();
++
++ private:
++ 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(renderer, cShaderData, manager);
++ }
++
++ // Create backend element for frontend one
++ Qt3DRender::Render::ShaderData *backend = manager->getOrCreateResource(frontend->id());
++ // Init the backend element
++ backend->setRenderer(renderer);
++ simulateInitializationSync(frontend, backend);
++ }
++
++ void initBackendTexture(Qt3DRender::QAbstractTexture *frontend,
++ Qt3DRender::Render::TextureManager *manager)
++ {
++ // Create backend element for frontend one
++ Qt3DRender::Render::Texture *backend = manager->getOrCreateResource(frontend->id());
++ // Init the backend element
++ simulateInitializationSync(frontend, backend);
++ }
++ };
++
++ class ScalarShaderData : public Qt3DRender::QShaderData
++ {
++ Q_OBJECT
++ Q_PROPERTY(float scalar READ scalar WRITE setScalar NOTIFY scalarChanged)
++
++ public:
++ ScalarShaderData(Qt3DCore::QNode *parent = nullptr)
++ : Qt3DRender::QShaderData(parent)
++ , m_scalar(0.0f)
++ {
++ }
++
++ void setScalar(float scalar)
++ {
++ if (scalar != m_scalar) {
++ m_scalar = scalar;
++ emit scalarChanged();
++ }
++ }
++
++ float scalar() const
++ {
++ return m_scalar;
++ }
++
++ QHash<QString, Qt3DRender::Render::OpenGL::ShaderUniform> buildUniformMap(const QString &blockName)
++ {
++ QHash<QString, Qt3DRender::Render::OpenGL::ShaderUniform> uniforms;
++
++ uniforms.insert(blockName + QStringLiteral(".scalar"), Qt3DRender::Render::OpenGL::ShaderUniform());
++
++ return uniforms;
++ }
++
++ std::vector<int> buildUniformMapNameIds(const QString &blockName) const
++ {
++ std::vector<int> ids;
++
++ ids.push_back(Qt3DRender::Render::StringToInt::lookupId(blockName + QStringLiteral(".scalar")));
++
++ return ids;
++ }
++
++
++ Q_SIGNALS:
++ void scalarChanged();
++
++ private:
++ float m_scalar;
++ };
++
++ class TextureShaderData : public Qt3DRender::QShaderData
++ {
++ Q_OBJECT
++ Q_PROPERTY(Qt3DRender::QAbstractTexture* texture READ texture WRITE setTexture NOTIFY textureChanged)
++
++ public:
++ TextureShaderData()
++ : Qt3DRender::QShaderData()
++ , m_texture(nullptr)
++ {
++ }
++
++ void setTexture(Qt3DRender::QAbstractTexture *texture)
++ {
++ if (texture != m_texture) {
++ m_texture = texture;
++ emit textureChanged();
++ }
++ }
++
++ Qt3DRender::QAbstractTexture *texture() const
++ {
++ return m_texture;
++ }
++
++ QHash<QString, Qt3DRender::Render::OpenGL::ShaderUniform> buildUniformMap(const QString &blockName)
++ {
++ QHash<QString, Qt3DRender::Render::OpenGL::ShaderUniform> uniforms;
++
++ uniforms.insert(blockName + QStringLiteral(".texture"), Qt3DRender::Render::OpenGL::ShaderUniform());
++
++ return uniforms;
++ }
++
++ std::vector<int> buildUniformMapNameIds(const QString &blockName) const
++ {
++ std::vector<int> ids;
++
++ ids.push_back(Qt3DRender::Render::StringToInt::lookupId(blockName + QStringLiteral(".texture")));
++
++ return ids;
++ }
++
++ Q_SIGNALS:
++ void textureChanged();
++
++ private:
++ Qt3DRender::QAbstractTexture *m_texture;
++ };
++
++
++ class ArrayShaderData : public Qt3DRender::QShaderData
++ {
++ Q_OBJECT
++ Q_PROPERTY(QVariantList array READ array WRITE setArray NOTIFY arrayChanged)
++
++ public:
++ ArrayShaderData()
++ : Qt3DRender::QShaderData()
++ {
++ }
++
++ void setArray(const QVariantList &array)
++ {
++ if (array != m_array) {
++ m_array = array;
++ emit arrayChanged();
++ }
++ }
++
++ QVariantList array() const
++ {
++ return m_array;
++ }
++
++ QHash<QString, Qt3DRender::Render::OpenGL::ShaderUniform> buildUniformMap(const QString &blockName)
++ {
++ QHash<QString, Qt3DRender::Render::OpenGL::ShaderUniform> uniforms;
++
++ uniforms.insert(blockName + QStringLiteral(".array[0]"), Qt3DRender::Render::OpenGL::ShaderUniform());
++
++ return uniforms;
++ }
++
++ std::vector<int> buildUniformMapNameIds(const QString &blockName) const
++ {
++ std::vector<int> ids;
++
++ ids.push_back(Qt3DRender::Render::StringToInt::lookupId(blockName + QStringLiteral(".array[0]")));
++
++ return ids;
++ }
++
++ Q_SIGNALS:
++ void arrayChanged();
++
++ private:
++ QVariantList m_array;
++ };
++
++ class StructShaderData : public Qt3DRender::QShaderData
++ {
++ Q_OBJECT
++ Q_PROPERTY(float scalar READ scalar WRITE setScalar NOTIFY scalarChanged)
++ Q_PROPERTY(QVariantList array READ array WRITE setArray NOTIFY arrayChanged)
++
++ public:
++ StructShaderData()
++ : Qt3DRender::QShaderData()
++ , m_scalar(0.0f)
++ {
++ }
++
++ void setScalar(float scalar)
++ {
++ if (scalar != m_scalar) {
++ m_scalar = scalar;
++ emit scalarChanged();
++ }
++ }
++
++ float scalar() const
++ {
++ return m_scalar;
++ }
++
++ void setArray(const QVariantList &array)
++ {
++ if (array != m_array) {
++ m_array = array;
++ emit arrayChanged();
++ }
++ }
++
++ QVariantList array() const
++ {
++ return m_array;
++ }
++
++ virtual QHash<QString, Qt3DRender::Render::OpenGL::ShaderUniform> buildUniformMap(const QString &blockName)
++ {
++ QHash<QString, Qt3DRender::Render::OpenGL::ShaderUniform> uniforms;
++
++ uniforms.insert(blockName + QStringLiteral(".scalar"), Qt3DRender::Render::OpenGL::ShaderUniform());
++ uniforms.insert(blockName + QStringLiteral(".array[0]"), Qt3DRender::Render::OpenGL::ShaderUniform());
++
++ return uniforms;
++ }
++
++ virtual QHash<QString, QVariant> buildUniformMapValues(const QString &blockName)
++ {
++ QHash<QString, QVariant> uniforms;
++
++ uniforms.insert(blockName + QStringLiteral(".scalar"), QVariant(scalar()));
++ uniforms.insert(blockName + QStringLiteral(".array[0]"), QVariant(array()));
++
++ return uniforms;
++ }
++
++ std::vector<int> buildUniformMapNameIds(const QString &blockName) const
++ {
++ std::vector<int> ids;
++
++ ids.push_back(Qt3DRender::Render::StringToInt::lookupId(blockName + QStringLiteral(".scalar")));
++ ids.push_back(Qt3DRender::Render::StringToInt::lookupId(blockName + QStringLiteral(".array[0]")));
++
++ return ids;
++ }
++
++
++ Q_SIGNALS:
++ void scalarChanged();
++ void arrayChanged();
++
++ private:
++ float m_scalar;
++ QVariantList m_array;
++ };
++
++ class MultiLevelStructShaderData : public StructShaderData
++ {
++ Q_OBJECT
++ Q_PROPERTY(Qt3DRender::QShaderData *inner READ inner WRITE setInner NOTIFY innerChanged)
++
++ public:
++ MultiLevelStructShaderData()
++ : StructShaderData()
++ , m_inner(nullptr)
++ {
++ }
++
++ void setInner(Qt3DRender::QShaderData *inner)
++ {
++ if (inner != m_inner) {
++ m_inner = inner;
++ emit innerChanged();
++ }
++ }
++
++ Qt3DRender::QShaderData *inner() const
++ {
++ return m_inner;
++ }
++
++ QHash<QString, Qt3DRender::Render::OpenGL::ShaderUniform> buildUniformMap(const QString &blockName) override
++ {
++ QHash<QString, Qt3DRender::Render::OpenGL::ShaderUniform> innerUniforms;
++
++ StructShaderData *innerData = nullptr;
++ if ((innerData = qobject_cast<StructShaderData *>(m_inner)) != nullptr)
++ innerUniforms = innerData->buildUniformMap(QStringLiteral(".inner"));
++
++ QHash<QString, Qt3DRender::Render::OpenGL::ShaderUniform> uniforms = StructShaderData::buildUniformMap(blockName);
++ QHash<QString, Qt3DRender::Render::OpenGL::ShaderUniform>::const_iterator it = innerUniforms.begin();
++ const QHash<QString, Qt3DRender::Render::OpenGL::ShaderUniform>::const_iterator end = innerUniforms.end();
++
++ while (it != end) {
++ uniforms.insert(blockName + it.key(), it.value());
++ ++it;
++ }
++ return uniforms;
++ }
++
++ QHash<QString, QVariant> buildUniformMapValues(const QString &blockName) override
++ {
++ QHash<QString, QVariant> innerUniformsValues;
++
++ StructShaderData *innerData = nullptr;
++ if ((innerData = qobject_cast<StructShaderData *>(m_inner)) != nullptr)
++ innerUniformsValues = innerData->buildUniformMapValues(QStringLiteral(".inner"));
++
++ QHash<QString, QVariant> uniformsValues = StructShaderData::buildUniformMapValues(blockName);
++ QHash<QString, QVariant>::const_iterator it = innerUniformsValues.begin();
++ const QHash<QString, QVariant>::const_iterator end = innerUniformsValues.end();
++
++ while (it != end) {
++ uniformsValues.insert(blockName + it.key(), it.value());
++ ++it;
++ }
++
++ return uniformsValues;
++ }
++
++ std::vector<int> buildUniformMapNameIds(const QString &blockName) const
++ {
++ std::vector<int> ids;
++ QHash<QString, Qt3DRender::Render::OpenGL::ShaderUniform> innerUniforms;
++
++ StructShaderData *innerData = nullptr;
++ if ((innerData = qobject_cast<StructShaderData *>(m_inner)) != nullptr)
++ innerUniforms = innerData->buildUniformMap(QStringLiteral(".inner"));
++
++ QHash<QString, Qt3DRender::Render::OpenGL::ShaderUniform>::const_iterator it = innerUniforms.begin();
++ const QHash<QString, Qt3DRender::Render::OpenGL::ShaderUniform>::const_iterator end = innerUniforms.end();
++
++ while (it != end) {
++ ids.push_back(Qt3DRender::Render::StringToInt::lookupId(blockName + it.key()));
++ ++it;
++ }
++
++ return ids;
++ }
++
++ Q_SIGNALS:
++ void innerChanged();
++
++ private:
++ Qt3DRender::QShaderData *m_inner;
++ };
++
++ 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(&renderer, shaderData.data(), manager.data());
++
++ // THEN
++ Qt3DRender::Render::ShaderData *backendShaderData = manager->lookupResource(shaderData->id());
++ QVERIFY(backendShaderData != nullptr);
++
++ // WHEB
++ const Matrix4x4 v;
++ Qt3DRender::Render::UniformBlockValueBuilder blockBuilder({},
++ manager.data(),
++ textureManager.data(),
++ v);
++ // build name-value map
++ blockBuilder.buildActiveUniformNameValueMapStructHelper(backendShaderData, QStringLiteral(""));
++
++ // THEN
++ // activeUniformNamesToValue should be empty as blockBuilder.uniforms is
++ QVERIFY(blockBuilder.activeUniformNamesToValue.isEmpty());
++ }
++
++ 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(&renderer, shaderData.data(), manager.data());
++
++ // THEN
++ Qt3DRender::Render::ShaderData *backendShaderData = manager->lookupResource(shaderData->id());
++ QVERIFY(backendShaderData != nullptr);
++
++ // WHEN
++ const Matrix4x4 v;
++ const auto nameIds = shaderData->buildUniformMapNameIds(QStringLiteral("MyBlock"));
++ Qt3DRender::Render::UniformBlockValueBuilder blockBuilder(nameIds,
++ manager.data(),
++ textureManager.data(),
++ v);
++ // build name-value map
++ blockBuilder.buildActiveUniformNameValueMapStructHelper(backendShaderData, QStringLiteral("MyBlock"));
++
++ // THEN
++ QCOMPARE(blockBuilder.activeUniformNamesToValue.size(), 1);
++
++ // WHEN
++ Qt3DRender::Render::UniformBlockValueBuilderHash::const_iterator it = blockBuilder.activeUniformNamesToValue.begin();
++ const Qt3DRender::Render::UniformBlockValueBuilderHash::const_iterator end = blockBuilder.activeUniformNamesToValue.end();
++
++ while (it != end) {
++ // THEN
++ QCOMPARE(it.value(), QVariant(shaderData->scalar()));
++ ++it;
++ }
++ }
++
++ 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);
++ QScopedPointer<Qt3DRender::Render::TextureManager> textureManager(new Qt3DRender::Render::TextureManager());
++
++ // WHEN
++ shaderData->setTexture(texture.data());
++ initBackendShaderData(&renderer, shaderData.data(), manager.data());
++
++ // THEN
++ Qt3DRender::Render::ShaderData *backendShaderData = manager->lookupResource(shaderData->id());
++ QVERIFY(backendShaderData != nullptr);
++
++ // WHEN
++ const Matrix4x4 v;
++ Qt3DRender::Render::UniformBlockValueBuilder blockBuilder({},
++ manager.data(),
++ textureManager.data(),
++ v);
++ // build name-value map
++ blockBuilder.buildActiveUniformNameValueMapStructHelper(backendShaderData, QStringLiteral(""));
++
++ // THEN
++ // activeUniformNamesToValue should be empty as blockBuilder.uniforms is
++ QVERIFY(blockBuilder.activeUniformNamesToValue.isEmpty());
++ }
++
++ 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);
++ QScopedPointer<Qt3DRender::Render::TextureManager> textureManager(new Qt3DRender::Render::TextureManager());
++
++ // WHEN
++ initBackendTexture(texture.data(), textureManager.data());
++ shaderData->setTexture(texture.data());
++ initBackendShaderData(&renderer, shaderData.data(), manager.data());
++
++ // THEN
++ Qt3DRender::Render::ShaderData *backendShaderData = manager->lookupResource(shaderData->id());
++ QVERIFY(backendShaderData != nullptr);
++
++ // WHEN
++ const Matrix4x4 v;
++ Qt3DRender::Render::UniformBlockValueBuilder blockBuilder(shaderData->buildUniformMapNameIds(QStringLiteral("MyBlock")),
++ manager.data(),
++ textureManager.data(),
++ v);
++
++
++ // build name-value map
++ blockBuilder.buildActiveUniformNameValueMapStructHelper(backendShaderData, QStringLiteral("MyBlock"));
++
++ // THEN
++ QCOMPARE(blockBuilder.activeUniformNamesToValue.size(), 1);
++
++ // WHEN
++ Qt3DRender::Render::UniformBlockValueBuilderHash::const_iterator it = blockBuilder.activeUniformNamesToValue.begin();
++ const Qt3DRender::Render::UniformBlockValueBuilderHash::const_iterator end = blockBuilder.activeUniformNamesToValue.end();
++
++ while (it != end) {
++ // THEN
++ QCOMPARE(it.value(), QVariant::fromValue(shaderData->texture()->id()));
++ ++it;
++ }
++ }
++
++ 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());
++
++ // WHEN
++ QVariantList arrayValues = QVariantList() << 454 << 350 << 383 << 427 << 552;
++ shaderData->setArray(arrayValues);
++ initBackendShaderData(&renderer, shaderData.data(), manager.data());
++
++ // THEN
++ Qt3DRender::Render::ShaderData *backendShaderData = manager->lookupResource(shaderData->id());
++ QVERIFY(backendShaderData != nullptr);
++
++ // WHEN
++ const Matrix4x4 v;
++ const auto nameIds = shaderData->buildUniformMapNameIds(QStringLiteral("MyBlock"));
++ Qt3DRender::Render::UniformBlockValueBuilder blockBuilder(nameIds,
++ manager.data(),
++ textureManager.data(),
++ v);
++ // build name-value map
++ blockBuilder.buildActiveUniformNameValueMapStructHelper(backendShaderData, QStringLiteral("MyBlock"));
++
++ // THEN
++ QCOMPARE(blockBuilder.activeUniformNamesToValue.size(), 1);
++
++ // WHEN
++ Qt3DRender::Render::UniformBlockValueBuilderHash::const_iterator it = blockBuilder.activeUniformNamesToValue.begin();
++ const Qt3DRender::Render::UniformBlockValueBuilderHash::const_iterator end = blockBuilder.activeUniformNamesToValue.end();
++
++ while (it != end) {
++ // THEN
++ QCOMPARE(it.value(), QVariant(arrayValues));
++ ++it;
++ }
++ }
++
++ 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());
++
++ QScopedPointer<ScalarShaderData> shaderData1(new ScalarShaderData(arrayShaderData.data()));
++ QScopedPointer<ScalarShaderData> shaderData2(new ScalarShaderData(arrayShaderData.data()));
++ QScopedPointer<ScalarShaderData> shaderData3(new ScalarShaderData(arrayShaderData.data()));
++
++ shaderData1->setScalar(883.0f);
++ shaderData2->setScalar(1200.0f);
++ shaderData3->setScalar(1340.0f);
++ QHash<QString, QVariant> scalarValues;
++ scalarValues[QStringLiteral("MyBlock.array[0].scalar")] = shaderData1->scalar();
++ scalarValues[QStringLiteral("MyBlock.array[1].scalar")] = shaderData2->scalar();
++ scalarValues[QStringLiteral("MyBlock.array[2].scalar")] = shaderData3->scalar();
++
++
++ const Qt3DCore::QNodeId id1 = shaderData1->id();
++ const Qt3DCore::QNodeId id2 = shaderData2->id();
++ const Qt3DCore::QNodeId id3 = shaderData3->id();
++
++ // WHEN
++ const QVariantList arrayValues = QVariantList() << QVariant::fromValue(id1) << QVariant::fromValue(id2) << QVariant::fromValue(id3);
++ arrayShaderData->setArray(arrayValues);
++ initBackendShaderData(&renderer, arrayShaderData.data(), manager.data());
++
++ // THEN
++ Qt3DRender::Render::ShaderData *backendArrayShaderData = manager->lookupResource(arrayShaderData->id());
++ Qt3DRender::Render::ShaderData *backendShaderData1 = manager->lookupResource(id1);
++ Qt3DRender::Render::ShaderData *backendShaderData2 = manager->lookupResource(id2);
++ Qt3DRender::Render::ShaderData *backendShaderData3 = manager->lookupResource(id3);
++ QVERIFY(backendArrayShaderData != nullptr);
++ QVERIFY(backendShaderData1 != nullptr);
++ QVERIFY(backendShaderData2 != nullptr);
++ QVERIFY(backendShaderData3 != nullptr);
++
++ // WHEN
++ const Matrix4x4 v;
++ const std::vector<int> nameIds = {
++ Qt3DRender::Render::StringToInt::lookupId(QStringLiteral("MyBlock.array[0].scalar")),
++ Qt3DRender::Render::StringToInt::lookupId(QStringLiteral("MyBlock.array[1].scalar")),
++ Qt3DRender::Render::StringToInt::lookupId(QStringLiteral("MyBlock.array[2].scalar")),
++ };
++
++ Qt3DRender::Render::UniformBlockValueBuilder blockBuilder(nameIds,
++ manager.data(),
++ textureManager.data(),
++ v);
++
++ // build name-value map
++ blockBuilder.buildActiveUniformNameValueMapStructHelper(backendArrayShaderData, QStringLiteral("MyBlock"));
++
++ // THEN
++ QCOMPARE(blockBuilder.activeUniformNamesToValue.size(), 3);
++
++ // WHEN
++ auto it = blockBuilder.activeUniformNamesToValue.cbegin();
++ const auto end = blockBuilder.activeUniformNamesToValue.cend();
++
++ while (it != end) {
++ // THEN
++ QCOMPARE(it.value(), scalarValues.value(Qt3DRender::Render::StringToInt::lookupString(it.key())));
++ ++it;
++ }
++ }
++
++ void tst_RenderViewUtils::topLevelStructValue_data()
++ {
++ QTest::addColumn<StructShaderData*>("shaderData");
++ QTest::addColumn<QString>("blockName");
++
++ QVariantList arrayValues2 = QVariantList() << 180 << 220 << 250 << 270 << 300 << 350 << 550;
++ QVariantList arrayValues = QVariantList() << 454 << 350 << 383 << 427 << 552;
++
++ MultiLevelStructShaderData *twoLevelsNestedShaderData = new MultiLevelStructShaderData();
++ MultiLevelStructShaderData *singleLevelShaderData = new MultiLevelStructShaderData();
++ StructShaderData *shaderData = new StructShaderData();
++
++ // Don't forget to set the parent so that initBackendShaderData
++ // properly initializes nested members
++ shaderData->setParent(singleLevelShaderData);
++ shaderData->setArray(arrayValues);
++ shaderData->setScalar(1584.0f);
++
++ singleLevelShaderData->setParent(twoLevelsNestedShaderData);
++ singleLevelShaderData->setInner(shaderData);
++ singleLevelShaderData->setScalar(1200.0f);
++ singleLevelShaderData->setArray(arrayValues2);
++
++ twoLevelsNestedShaderData->setInner(singleLevelShaderData);
++ twoLevelsNestedShaderData->setArray(arrayValues + arrayValues2);
++ twoLevelsNestedShaderData->setScalar(1340.0f);
++
++ QTest::newRow("simple struct") << shaderData << QStringLiteral("Block");
++ QTest::newRow("single level inner struct") << (StructShaderData *)singleLevelShaderData << QStringLiteral("Block");
++ QTest::newRow("tow level inner struct") << (StructShaderData *)twoLevelsNestedShaderData << QStringLiteral("Block");
++ }
++
++ 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(&renderer, shaderData, manager.data());
++
++ // THEN
++ Qt3DRender::Render::ShaderData *backendShaderData = manager->lookupResource(shaderData->id());
++ QVERIFY(backendShaderData != nullptr);
++
++ // WHEN
++ const Matrix4x4 v;
++ const auto nameIds = shaderData->buildUniformMapNameIds(blockName);
++ Qt3DRender::Render::UniformBlockValueBuilder blockBuilder(nameIds,
++ manager.data(),
++ textureManager.data(),
++ v);
++
++ const QHash<QString, QVariant> expectedValues = shaderData->buildUniformMapValues(blockName);
++ // build name-value map
++ blockBuilder.buildActiveUniformNameValueMapStructHelper(backendShaderData, blockName);
++
++ // THEN
++ QCOMPARE(size_t(blockBuilder.activeUniformNamesToValue.size()),
++ shaderData->buildUniformMapNameIds(blockName).size());
++
++ // WHEN
++ Qt3DRender::Render::UniformBlockValueBuilderHash::const_iterator it = blockBuilder.activeUniformNamesToValue.begin();
++ const Qt3DRender::Render::UniformBlockValueBuilderHash::const_iterator end = blockBuilder.activeUniformNamesToValue.end();
++
++ while (it != end) {
++ // THEN
++ QVERIFY(expectedValues.contains(Qt3DRender::Render::StringToInt::lookupString(it.key())));
++ QCOMPARE(it.value(), expectedValues.value(Qt3DRender::Render::StringToInt::lookupString(it.key())));
++ ++it;
++ }
++ }
++
++ 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);
++ QScopedPointer<Qt3DRender::Render::TextureManager> textureManager(new Qt3DRender::Render::TextureManager());
++
++ // WHEN
++ initBackendTexture(texture.data(), textureManager.data());
++ shaderData->setProperty("scalar", 883.0f);
++ shaderData->setProperty("array", QVariantList() << 454 << 350 << 383 << 427 << 552);
++ shaderData->setProperty("texture", QVariant::fromValue(texture.data()));
++ initBackendShaderData(&renderer, shaderData.data(), manager.data());
++
++ // THEN
++ Qt3DRender::Render::ShaderData *backendShaderData = manager->lookupResource(shaderData->id());
++ QVERIFY(backendShaderData != nullptr);
++
++ // WHEN
++ const Matrix4x4 v;
++ const std::vector<int> nameIds = {
++ Qt3DRender::Render::StringToInt::lookupId(QStringLiteral("MyBlock.scalar")),
++ Qt3DRender::Render::StringToInt::lookupId(QStringLiteral("MyBlock.array[0]")),
++ Qt3DRender::Render::StringToInt::lookupId(QStringLiteral("MyBlock.texture")),
++ };
++
++ Qt3DRender::Render::UniformBlockValueBuilder blockBuilder(nameIds,
++ manager.data(),
++ textureManager.data(),
++ v);
++ // build name-value map
++ blockBuilder.buildActiveUniformNameValueMapStructHelper(backendShaderData, QStringLiteral("MyBlock"));
++ // THEN
++ QCOMPARE(blockBuilder.activeUniformNamesToValue.size(), 3);
++
++ QCOMPARE(blockBuilder.activeUniformNamesToValue.value(Qt3DRender::Render::StringToInt::lookupId("MyBlock.scalar")),
++ shaderData->property("scalar"));
++ QCOMPARE(blockBuilder.activeUniformNamesToValue.value(Qt3DRender::Render::StringToInt::lookupId("MyBlock.array[0]")),
++ shaderData->property("array"));
++ QCOMPARE(blockBuilder.activeUniformNamesToValue.value(Qt3DRender::Render::StringToInt::lookupId("MyBlock.texture")),
++ QVariant::fromValue(texture->id()));
++ }
++
++ 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);
++ const QVector3D positionQt = convertToQVector3D(position);
++ Matrix4x4 worldMatrix;
++ {
++ QMatrix4x4 m;
++ m.translate(-3.0f, 2.0f, 7.5f);
++ worldMatrix = Matrix4x4(m);
++ }
++ Matrix4x4 viewMatrix;
++ {
++ QMatrix4x4 m;
++ m.translate(9.0f, 6.0f, 12.0f);
++ viewMatrix = Matrix4x4(m);
++ }
++
++ shaderData->setProperty("position0", positionQt);
++ shaderData->setProperty("position1", positionQt);
++ shaderData->setProperty("position2", positionQt);
++ shaderData->setProperty("position3", positionQt);
++ shaderData->setProperty("position1Transformed", Qt3DRender::Render::ShaderData::ModelToEye);
++ shaderData->setProperty("position2Transformed", Qt3DRender::Render::ShaderData::ModelToWorld);
++ shaderData->setProperty("position3Transformed", Qt3DRender::Render::ShaderData::ModelToWorldDirection);
++ initBackendShaderData(&renderer, shaderData.data(), manager.data());
++
++ // THEN
++ Qt3DRender::Render::ShaderData *backendShaderData = manager->lookupResource(shaderData->id());
++ QVERIFY(backendShaderData != nullptr);
++ QCOMPARE(backendShaderData->propertyTransformType(QStringLiteral("position0")), Qt3DRender::Render::ShaderData::NoTransform);
++ QCOMPARE(backendShaderData->propertyTransformType(QStringLiteral("position1")), Qt3DRender::Render::ShaderData::ModelToEye);
++ QCOMPARE(backendShaderData->propertyTransformType(QStringLiteral("position2")), Qt3DRender::Render::ShaderData::ModelToWorld);
++ QCOMPARE(backendShaderData->propertyTransformType(QStringLiteral("position3")), Qt3DRender::Render::ShaderData::ModelToWorldDirection);
++
++ // WHEN
++ backendShaderData->updateWorldTransform(worldMatrix);
++ const QHash<QString, Qt3DRender::Render::ShaderData::PropertyValue> &props = backendShaderData->properties();
++ const Qt3DRender::Render::ShaderData::PropertyValue propPos1 = props[QStringLiteral("position1")];
++ const Qt3DRender::Render::ShaderData::PropertyValue propPos2 = props[QStringLiteral("position2")];
++ const Qt3DRender::Render::ShaderData::PropertyValue propPos3 = props[QStringLiteral("position3")];
++ const Qt3DRender::Render::ShaderData::PropertyValue propPos0 = props[QStringLiteral("position0")];
++
++ const Vector3D position1Value = backendShaderData->getTransformedProperty(&propPos1, viewMatrix).value<Vector3D>();
++ const Vector3D position2Value = backendShaderData->getTransformedProperty(&propPos2, viewMatrix).value<Vector3D>();
++ const Vector3D position3Value = backendShaderData->getTransformedProperty(&propPos3, viewMatrix).value<Vector3D>();
++ const QVariant position0Value = backendShaderData->getTransformedProperty(&propPos0, viewMatrix);
++
++ // THEN
++ QCOMPARE(position0Value, positionQt);
++ QCOMPARE(position1Value, (viewMatrix * worldMatrix).map(position));
++ QCOMPARE(position2Value, worldMatrix.map(position));
++ QCOMPARE(position3Value, Vector3D((worldMatrix * Vector4D(position, 0.0f))));
++ }
++
++ void tst_RenderViewUtils::shouldNotifyDynamicPropertyChanges()
++ {
++ // GIVEN
++ TestArbiter arbiter;
++ QScopedPointer<Qt3DRender::QShaderData> shaderData(new Qt3DRender::QShaderData());
++ arbiter.setArbiterOnNode(shaderData.data());
++
++ // WHEN
++ shaderData->setProperty("scalar", 883.0f);
++
++ // THEN
++ QCOMPARE(arbiter.dirtyNodes().size(), 1);
++ QCOMPARE(arbiter.dirtyNodes().front(), shaderData.data());
++
++ arbiter.clear();
++
++ // WHEN
++ QScopedPointer<Qt3DRender::QAbstractTexture> texture(new Qt3DRender::QTexture2D);
++ shaderData->setProperty("texture", QVariant::fromValue(texture.data()));
++
++ // THEN
++ QCOMPARE(arbiter.dirtyNodes().size(), 1);
++ QCOMPARE(arbiter.dirtyNodes().front(), shaderData.data());
++ }
++
++ QTEST_MAIN(tst_RenderViewUtils)
++
++ #include "tst_renderviewutils.moc"