Fix OnDemand render policy

The OnDemand render policy has no effect because the ShadersDirty and
ComputeDirty flags are always set. This commit resets ShadersDirty so
that ShaderGathererJob is only run when needed. It also introduces the
TechniquesDirty flag so we know when to run
FilterCompatibleTechniqueJob and makes sure the job is only run if
the context has been initialized and the renderer is running.

Task-number: QTBUG-65965
Change-Id: Icbcc03ed2dc6b14c6580cc794267b5a88e5f4ca2
Reviewed-by: Paul Lemire <paul.lemire@kdab.com>

7 files changed, 118 insertions, 149 deletions

diff --git a/src/render/backend/abstractrenderer_p.h b/src/render/backend/abstractrenderer_p.h
index bc8a9812f..5603a9195 100644
--- a/src/render/backend/abstractrenderer_p.h
+++ b/src/render/backend/abstractrenderer_p.h
@@ -108,6 +108,7 @@ public:
         SkeletonDataDirty   = 1 << 10,
         JointDirty          = 1 << 11,
         LayersDirty         = 1 << 12,
+        TechniquesDirty     = 1 << 13,
         AllDirty            = 0xffffff
     };
     Q_DECLARE_FLAGS(BackendNodeDirtySet, BackendNodeDirtyFlag)
diff --git a/src/render/backend/renderer.cpp b/src/render/backend/renderer.cpp
index 7ed62a98f..cfe0cd98a 100644
--- a/src/render/backend/renderer.cpp
+++ b/src/render/backend/renderer.cpp
@@ -1013,72 +1013,71 @@ void Renderer::lookForDirtyTextures()
 // Executed in a job
 void Renderer::lookForDirtyShaders()
 {
-    if (isRunning()) {
-        const QVector<HTechnique> activeTechniques = m_nodesManager->techniqueManager()->activeHandles();
-        const QVector<HShaderBuilder> activeBuilders = m_nodesManager->shaderBuilderManager()->activeHandles();
-        for (const HTechnique &techniqueHandle : activeTechniques) {
-            Technique *technique = m_nodesManager->techniqueManager()->data(techniqueHandle);
-            // If api of the renderer matches the one from the technique
-            if (technique->isCompatibleWithRenderer()) {
-                const auto passIds = technique->renderPasses();
-                for (const QNodeId passId : passIds) {
-                    RenderPass *renderPass = m_nodesManager->renderPassManager()->lookupResource(passId);
-                    HShader shaderHandle = m_nodesManager->shaderManager()->lookupHandle(renderPass->shaderProgram());
-                    Shader *shader = m_nodesManager->shaderManager()->data(shaderHandle);
-
-                    ShaderBuilder *shaderBuilder = nullptr;
-                    for (const HShaderBuilder &builderHandle : activeBuilders) {
-                        ShaderBuilder *builder = m_nodesManager->shaderBuilderManager()->data(builderHandle);
-                        if (builder->shaderProgramId() == shader->peerId()) {
-                            shaderBuilder = builder;
-                            break;
-                        }
+    Q_ASSERT(isRunning());
+    const QVector<HTechnique> activeTechniques = m_nodesManager->techniqueManager()->activeHandles();
+    const QVector<HShaderBuilder> activeBuilders = m_nodesManager->shaderBuilderManager()->activeHandles();
+    for (const HTechnique &techniqueHandle : activeTechniques) {
+        Technique *technique = m_nodesManager->techniqueManager()->data(techniqueHandle);
+        // If api of the renderer matches the one from the technique
+        if (technique->isCompatibleWithRenderer()) {
+            const auto passIds = technique->renderPasses();
+            for (const QNodeId passId : passIds) {
+                RenderPass *renderPass = m_nodesManager->renderPassManager()->lookupResource(passId);
+                HShader shaderHandle = m_nodesManager->shaderManager()->lookupHandle(renderPass->shaderProgram());
+                Shader *shader = m_nodesManager->shaderManager()->data(shaderHandle);
+
+                ShaderBuilder *shaderBuilder = nullptr;
+                for (const HShaderBuilder &builderHandle : activeBuilders) {
+                    ShaderBuilder *builder = m_nodesManager->shaderBuilderManager()->data(builderHandle);
+                    if (builder->shaderProgramId() == shader->peerId()) {
+                        shaderBuilder = builder;
+                        break;
                     }
+                }
 
-                    if (shaderBuilder) {
-                        shaderBuilder->setGraphicsApi(*technique->graphicsApiFilter());
-
-                        for (int i = 0; i <= ShaderBuilder::Compute; i++) {
-                            const auto builderType = static_cast<ShaderBuilder::ShaderType>(i);
-                            if (!shaderBuilder->shaderGraph(builderType).isValid())
-                                continue;
-
-                            if (shaderBuilder->isShaderCodeDirty(builderType)) {
-                                shaderBuilder->generateCode(builderType);
-                            }
-
-                            QShaderProgram::ShaderType shaderType = QShaderProgram::Vertex;
-                            switch (builderType) {
-                            case ShaderBuilder::Vertex:
-                                shaderType = QShaderProgram::Vertex;
-                                break;
-                            case ShaderBuilder::TessellationControl:
-                                shaderType = QShaderProgram::TessellationControl;
-                                break;
-                            case ShaderBuilder::TessellationEvaluation:
-                                shaderType = QShaderProgram::TessellationEvaluation;
-                                break;
-                            case ShaderBuilder::Geometry:
-                                shaderType = QShaderProgram::Geometry;
-                                break;
-                            case ShaderBuilder::Fragment:
-                                shaderType = QShaderProgram::Fragment;
-                                break;
-                            case ShaderBuilder::Compute:
-                                shaderType = QShaderProgram::Compute;
-                                break;
-                            }
-
-                            const auto code = shaderBuilder->shaderCode(builderType);
-                            shader->setShaderCode(shaderType, code);
+                if (shaderBuilder) {
+                    shaderBuilder->setGraphicsApi(*technique->graphicsApiFilter());
+
+                    for (int i = 0; i <= ShaderBuilder::Compute; i++) {
+                        const auto builderType = static_cast<ShaderBuilder::ShaderType>(i);
+                        if (!shaderBuilder->shaderGraph(builderType).isValid())
+                            continue;
+
+                        if (shaderBuilder->isShaderCodeDirty(builderType)) {
+                            shaderBuilder->generateCode(builderType);
                         }
-                    }
 
-                    if (Q_UNLIKELY(shader->hasPendingNotifications()))
-                        shader->submitPendingNotifications();
-                    if (shader != nullptr && !shader->isLoaded())
-                        m_dirtyShaders.push_back(shaderHandle);
+                        QShaderProgram::ShaderType shaderType = QShaderProgram::Vertex;
+                        switch (builderType) {
+                        case ShaderBuilder::Vertex:
+                            shaderType = QShaderProgram::Vertex;
+                            break;
+                        case ShaderBuilder::TessellationControl:
+                            shaderType = QShaderProgram::TessellationControl;
+                            break;
+                        case ShaderBuilder::TessellationEvaluation:
+                            shaderType = QShaderProgram::TessellationEvaluation;
+                            break;
+                        case ShaderBuilder::Geometry:
+                            shaderType = QShaderProgram::Geometry;
+                            break;
+                        case ShaderBuilder::Fragment:
+                            shaderType = QShaderProgram::Fragment;
+                            break;
+                        case ShaderBuilder::Compute:
+                            shaderType = QShaderProgram::Compute;
+                            break;
+                        }
+
+                        const auto code = shaderBuilder->shaderCode(builderType);
+                        shader->setShaderCode(shaderType, code);
+                    }
                 }
+
+                if (Q_UNLIKELY(shader->hasPendingNotifications()))
+                    shader->submitPendingNotifications();
+                if (shader != nullptr && !shader->isLoaded())
+                    m_dirtyShaders.push_back(shaderHandle);
             }
         }
     }
@@ -1536,7 +1535,6 @@ QVector<Qt3DCore::QAspectJobPtr> Renderer::renderBinJobs()
     renderBinJobs.push_back(m_cleanupJob);
     renderBinJobs.push_back(m_sendRenderCaptureJob);
     renderBinJobs.push_back(m_sendBufferCaptureJob);
-    renderBinJobs.push_back(m_filterCompatibleTechniqueJob);
     renderBinJobs.append(bufferJobs);
 
     // Jobs to prepare GL Resource upload
@@ -1545,9 +1543,6 @@ QVector<Qt3DCore::QAspectJobPtr> Renderer::renderBinJobs()
     if (dirtyBitsForFrame & AbstractRenderer::BuffersDirty)
         renderBinJobs.push_back(m_bufferGathererJob);
 
-    if (dirtyBitsForFrame & AbstractRenderer::ShadersDirty)
-        renderBinJobs.push_back(m_shaderGathererJob);
-
     if (dirtyBitsForFrame & AbstractRenderer::TexturesDirty) {
         renderBinJobs.push_back(m_syncTextureLoadingJob);
         renderBinJobs.push_back(m_textureGathererJob);
@@ -1558,7 +1553,6 @@ QVector<Qt3DCore::QAspectJobPtr> Renderer::renderBinJobs()
     // on entities
     const bool layersDirty = dirtyBitsForFrame & AbstractRenderer::LayersDirty;
     const bool layersCacheNeedsToBeRebuilt = layersDirty || entitiesEnabledDirty;
-    bool layersCacheRebuilt = false;
 
     QMutexLocker lock(m_renderQueue->mutex());
     if (m_renderQueue->wasReset()) { // Have we rendered yet? (Scene3D case)
@@ -1584,25 +1578,25 @@ QVector<Qt3DCore::QAspectJobPtr> Renderer::renderBinJobs()
             builder.prepareJobs();
             renderBinJobs.append(builder.buildJobHierachy());
         }
-        layersCacheRebuilt = true;
 
         // Set target number of RenderViews
         m_renderQueue->setTargetRenderViewCount(fgBranchCount);
-    }
-
-    // Only reset LayersDirty flag once we have really rebuilt the caches
-    if (layersDirty && !layersCacheRebuilt)
-        notCleared |= AbstractRenderer::LayersDirty;
-    if (entitiesEnabledDirty && !layersCacheRebuilt)
+    } else {
+        // FilterLayerEntityJob is part of the RenderViewBuilder jobs and must be run later
+        // if none of those jobs are started this frame
         notCleared |= AbstractRenderer::EntityEnabledDirty;
+        notCleared |= AbstractRenderer::LayersDirty;
+    }
 
-    // Clear dirty bits
-    // TO DO: When secondary GL thread is integrated, the following line can be removed
-    notCleared |= AbstractRenderer::ShadersDirty;
-
-    // Clear all dirty flags but Compute so that
-    // we still render every frame when a compute shader is used in a scene
-    notCleared |= Renderer::ComputeDirty;
+    if (isRunning() && m_graphicsContext->isInitialized()) {
+        if (dirtyBitsForFrame & AbstractRenderer::TechniquesDirty )
+            renderBinJobs.push_back(m_filterCompatibleTechniqueJob);
+        if (dirtyBitsForFrame & AbstractRenderer::ShadersDirty)
+            renderBinJobs.push_back(m_shaderGathererJob);
+    } else {
+        notCleared |= AbstractRenderer::TechniquesDirty;
+        notCleared |= AbstractRenderer::ShadersDirty;
+    }
 
     m_dirtyBits.remaining = dirtyBitsForFrame & notCleared;
 
diff --git a/src/render/jobs/filtercompatibletechniquejob.cpp b/src/render/jobs/filtercompatibletechniquejob.cpp
index 362e4088f..080ccd306 100644
--- a/src/render/jobs/filtercompatibletechniquejob.cpp
+++ b/src/render/jobs/filtercompatibletechniquejob.cpp
@@ -79,14 +79,13 @@ Renderer *FilterCompatibleTechniqueJob::renderer() const
 void FilterCompatibleTechniqueJob::run()
 {
     Q_ASSERT(m_manager != nullptr && m_renderer != nullptr);
+    Q_ASSERT(m_renderer->isRunning() && m_renderer->graphicsContext()->isInitialized());
 
-    if (m_renderer->isRunning() && m_renderer->graphicsContext()->isInitialized()) {
-        const QVector<Qt3DCore::QNodeId> dirtyTechniqueIds = m_manager->takeDirtyTechniques();
-        for (const Qt3DCore::QNodeId techniqueId : dirtyTechniqueIds) {
-            Technique *technique = m_manager->lookupResource(techniqueId);
-            if (Q_LIKELY(technique != nullptr))
-                technique->setCompatibleWithRenderer((*m_renderer->contextInfo() == *technique->graphicsApiFilter()));
-        }
+    const QVector<Qt3DCore::QNodeId> dirtyTechniqueIds = m_manager->takeDirtyTechniques();
+    for (const Qt3DCore::QNodeId techniqueId : dirtyTechniqueIds) {
+        Technique *technique = m_manager->lookupResource(techniqueId);
+        if (Q_LIKELY(technique != nullptr))
+            technique->setCompatibleWithRenderer((*m_renderer->contextInfo() == *technique->graphicsApiFilter()));
     }
 }
 
diff --git a/src/render/materialsystem/technique.cpp b/src/render/materialsystem/technique.cpp
index 4fd1555e1..5438fa9c8 100644
--- a/src/render/materialsystem/technique.cpp
+++ b/src/render/materialsystem/technique.cpp
@@ -102,43 +102,53 @@ void Technique::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
     switch (e->type()) {
     case PropertyUpdated: {
         const auto change = qSharedPointerCast<QPropertyUpdatedChange>(e);
-        if (change->propertyName() == QByteArrayLiteral("graphicsApiFilterData")) {
+        if (change->propertyName() == QByteArrayLiteral("enabled")) {
+            markDirty(AbstractRenderer::TechniquesDirty);
+        } else if (change->propertyName() == QByteArrayLiteral("graphicsApiFilterData")) {
             GraphicsApiFilterData filterData = change->value().value<GraphicsApiFilterData>();
             m_graphicsApiFilterData = filterData;
             // Notify the manager that our graphicsApiFilterData has changed
             // and that we therefore need to be check for compatibility again
             m_isCompatibleWithRenderer = false;
             m_nodeManager->techniqueManager()->addDirtyTechnique(peerId());
+            markDirty(AbstractRenderer::TechniquesDirty);
         }
         break;
     }
 
     case PropertyValueAdded: {
         const auto change = qSharedPointerCast<QPropertyNodeAddedChange>(e);
-        if (change->propertyName() == QByteArrayLiteral("pass"))
+        if (change->propertyName() == QByteArrayLiteral("pass")) {
             appendRenderPass(change->addedNodeId());
-        else if (change->propertyName() == QByteArrayLiteral("parameter"))
+            markDirty(AbstractRenderer::TechniquesDirty);
+        } else if (change->propertyName() == QByteArrayLiteral("parameter")) {
             m_parameterPack.appendParameter(change->addedNodeId());
-        else if (change->propertyName() == QByteArrayLiteral("filterKeys"))
+            markDirty(AbstractRenderer::TechniquesDirty);
+        } else if (change->propertyName() == QByteArrayLiteral("filterKeys")) {
             appendFilterKey(change->addedNodeId());
+            markDirty(AbstractRenderer::TechniquesDirty);
+        }
         break;
     }
 
     case PropertyValueRemoved: {
         const auto change = qSharedPointerCast<QPropertyNodeRemovedChange>(e);
-        if (change->propertyName() == QByteArrayLiteral("pass"))
+        if (change->propertyName() == QByteArrayLiteral("pass")) {
             removeRenderPass(change->removedNodeId());
-        else if (change->propertyName() == QByteArrayLiteral("parameter"))
+            markDirty(AbstractRenderer::TechniquesDirty);
+        } else if (change->propertyName() == QByteArrayLiteral("parameter")) {
             m_parameterPack.removeParameter(change->removedNodeId());
-        else if (change->propertyName() == QByteArrayLiteral("filterKeys"))
+            markDirty(AbstractRenderer::TechniquesDirty);
+        } else if (change->propertyName() == QByteArrayLiteral("filterKeys")) {
             removeFilterKey(change->removedNodeId());
+            markDirty(AbstractRenderer::TechniquesDirty);
+        }
         break;
     }
 
     default:
         break;
     }
-    markDirty(AbstractRenderer::AllDirty);
     BackendNode::sceneChangeEvent(e);
 }
 
diff --git a/tests/auto/render/filtercompatibletechniquejob/tst_filtercompatibletechniquejob.cpp b/tests/auto/render/filtercompatibletechniquejob/tst_filtercompatibletechniquejob.cpp
index 83e816861..4d4a08a34 100644
--- a/tests/auto/render/filtercompatibletechniquejob/tst_filtercompatibletechniquejob.cpp
+++ b/tests/auto/render/filtercompatibletechniquejob/tst_filtercompatibletechniquejob.cpp
@@ -192,35 +192,6 @@ private Q_SLOTS:
         QCOMPARE(backendFilterCompatibleTechniqueJob.renderer(), &renderer);
     }
 
-    void checkRunRendererNotRunning()
-    {
-        // GIVEN
-        Qt3DRender::Render::FilterCompatibleTechniqueJob backendFilterCompatibleTechniqueJob;
-        Qt3DRender::TestAspect testAspect(buildTestScene());
-
-        // WHEN
-        Qt3DRender::Render::NodeManagers *nodeManagers = testAspect.nodeManagers();
-        QVERIFY(nodeManagers);
-        Qt3DRender::Render::TechniqueManager *techniqueManager = nodeManagers->techniqueManager();
-        QVERIFY(techniqueManager);
-        backendFilterCompatibleTechniqueJob.setManager(techniqueManager);
-        backendFilterCompatibleTechniqueJob.setRenderer(testAspect.renderer());
-        testAspect.initializeRenderer();
-        testAspect.renderer()->shutdown();
-
-        // THEN
-        QCOMPARE(testAspect.renderer()->isRunning(), false);
-        QVector<Qt3DRender::Render::HTechnique> handles = testAspect.nodeManagers()->techniqueManager()->activeHandles();
-        QCOMPARE(handles.size(), 3);
-
-        // WHEN
-        backendFilterCompatibleTechniqueJob.run();
-
-        // THEN -> untouched since not running
-        const QVector<Qt3DCore::QNodeId> dirtyTechniquesId = testAspect.nodeManagers()->techniqueManager()->takeDirtyTechniques();
-        QCOMPARE(dirtyTechniquesId.size(), 3);
-    }
-
     void checkRunRendererRunning()
     {
         // GIVEN
diff --git a/tests/auto/render/renderer/tst_renderer.cpp b/tests/auto/render/renderer/tst_renderer.cpp
index 85d978926..b53c26f83 100644
--- a/tests/auto/render/renderer/tst_renderer.cpp
+++ b/tests/auto/render/renderer/tst_renderer.cpp
@@ -60,6 +60,9 @@ private Q_SLOTS:
         renderer.setSettings(&settings);
         renderer.initialize();
 
+        // NOTE: FilterCompatibleTechniqueJob and ShaderGathererJob cannot run because the context
+        // is not initialized in this test
+
         const int singleRenderViewJobCount = 11 + 2 * Qt3DRender::Render::RenderViewBuilder::optimalJobCount();
         // RenderViewBuilder renderViewJob,
         //                   renderableEntityFilterJob,
@@ -84,7 +87,6 @@ private Q_SLOTS:
                  1 + // cleanupJob
                  1 + // sendRenderCaptureJob
                  1 + // sendBufferCaptureJob
-                 1 + // filterCompatibleTechniquesJob
                  1 + // VAOGatherer
                  1 + // updateSkinningPaletteJob
                  singleRenderViewJobCount); // Only valid for the first call to renderBinJobs(), since subsequent calls won't have the renderqueue reset
@@ -100,7 +102,6 @@ private Q_SLOTS:
                  1 + // cleanupJob
                  1 + // sendRenderCaptureJob
                  1 + // sendBufferCaptureJob
-                 1 + // filterCompatibleTechniquesJob
                  1 + // VAOGatherer
                  1 + // updateSkinningPaletteJob
                  1); // EntityEnabledDirty
@@ -117,7 +118,6 @@ private Q_SLOTS:
                  1 + // cleanupJob
                  1 + // sendRenderCaptureJob
                  1 + // sendBufferCaptureJob
-                 1 + // filterCompatibleTechniquesJob
                  1 + // VAOGatherer
                  1 + // WorldTransformJob
                  1 + // UpdateWorldBoundingVolume
@@ -137,7 +137,6 @@ private Q_SLOTS:
                  1 + // cleanupJob
                  1 + // sendRenderCaptureJob
                  1 + // sendBufferCaptureJob
-                 1 + // filterCompatibleTechniquesJob
                  1 + // VAOGatherer
                  1 + // CalculateBoundingVolumeJob
                  1 + // UpdateMeshTriangleListJob
@@ -156,7 +155,6 @@ private Q_SLOTS:
                  1 + // cleanupJob
                  1 + // sendRenderCaptureJob
                  1 + // sendBufferCaptureJob
-                 1 + // filterCompatibleTechniquesJob
                  1 + // VAOGatherer
                  1 + // updateSkinningPaletteJob
                  1); // BufferGathererJob
@@ -164,23 +162,6 @@ private Q_SLOTS:
         renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
 
         // WHEN
-        renderer.markDirty(Qt3DRender::Render::AbstractRenderer::ShadersDirty, nullptr);
-        jobs = renderer.renderBinJobs();
-
-        // THEN (level
-        QCOMPARE(jobs.size(),
-                 1 + // updateLevelOfDetailJob
-                 1 + // cleanupJob
-                 1 + // sendRenderCaptureJob
-                 1 + // sendBufferCaptureJob
-                 1 + // filterCompatibleTechniquesJob
-                 1 + // VAOGatherer
-                 1 + // updateSkinningPaletteJob
-                 1); // ShaderGathererJob
-
-        renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
-
-        // WHEN
         renderer.markDirty(Qt3DRender::Render::AbstractRenderer::TexturesDirty, nullptr);
         jobs = renderer.renderBinJobs();
 
@@ -190,7 +171,6 @@ private Q_SLOTS:
                  1 + // cleanupJob
                  1 + // sendRenderCaptureJob
                  1 + // sendBufferCaptureJob
-                 1 + // filterCompatibleTechniquesJob
                  1 + // VAOGatherer
                  1 + // TexturesGathererJob
                  1 + // updateSkinningPaletteJob
@@ -208,7 +188,6 @@ private Q_SLOTS:
                  1 + // cleanupJob
                  1 + // sendRenderCaptureJob
                  1 + // sendBufferCaptureJob
-                 1 + // filterCompatibleTechniquesJob
                  1 + // VAOGatherer
                  1 + // EntityEnabledDirty
                  1 + // WorldTransformJob
@@ -218,7 +197,6 @@ private Q_SLOTS:
                  1 + // CalculateBoundingVolumeJob
                  1 + // UpdateMeshTriangleListJob
                  1 + // BufferGathererJob
-                 1 + // ShaderGathererJob
                  1 + // TexturesGathererJob
                  1 + // updateSkinningPaletteJob
                  1); // SyncTexturesGathererJob
diff --git a/tests/auto/render/technique/tst_technique.cpp b/tests/auto/render/technique/tst_technique.cpp
index a712434d1..7dfd5b85c 100644
--- a/tests/auto/render/technique/tst_technique.cpp
+++ b/tests/auto/render/technique/tst_technique.cpp
@@ -193,6 +193,8 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(backendTechnique.isEnabled(), newValue);
+            QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::TechniquesDirty);
+            renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
         }
         {
             // WHEN
@@ -217,6 +219,8 @@ private Q_SLOTS:
             QCOMPARE(dirtyTechniques.size(), 1);
             QCOMPARE(dirtyTechniques.first(), backendTechnique.peerId());
 
+            QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::TechniquesDirty);
+            renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
         }
         {
             Qt3DRender::QParameter parameter;
@@ -230,6 +234,8 @@ private Q_SLOTS:
                 // THEN
                 QCOMPARE(backendTechnique.parameters().size(), 1);
                 QCOMPARE(backendTechnique.parameters().first(), parameter.id());
+                QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::TechniquesDirty);
+                renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
             }
             {
                 // WHEN
@@ -239,6 +245,8 @@ private Q_SLOTS:
 
                 // THEN
                 QCOMPARE(backendTechnique.parameters().size(), 0);
+                QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::TechniquesDirty);
+                renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
             }
         }
         {
@@ -253,6 +261,8 @@ private Q_SLOTS:
                 // THEN
                 QCOMPARE(backendTechnique.filterKeys().size(), 1);
                 QCOMPARE(backendTechnique.filterKeys().first(), filterKey.id());
+                QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::TechniquesDirty);
+                renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
             }
             {
                 // WHEN
@@ -262,6 +272,8 @@ private Q_SLOTS:
 
                 // THEN
                 QCOMPARE(backendTechnique.filterKeys().size(), 0);
+                QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::TechniquesDirty);
+                renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
             }
         }
         {
@@ -276,6 +288,8 @@ private Q_SLOTS:
                 // THEN
                 QCOMPARE(backendTechnique.renderPasses().size(), 1);
                 QCOMPARE(backendTechnique.renderPasses().first(), pass.id());
+                QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::TechniquesDirty);
+                renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
             }
             {
                 // WHEN
@@ -285,6 +299,8 @@ private Q_SLOTS:
 
                 // THEN
                 QCOMPARE(backendTechnique.renderPasses().size(), 0);
+                QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::TechniquesDirty);
+                renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
             }
         }
     }