Keep rendering in sync with aspect jobs by adding barriers

This makes sure that jobs that depend on a specific state of the
renderer (such as context being initialized) never run before this
is the case. This reduces the number of possible race conditions
and checks we need to do to ensure the jobs and the renderer are in
the correct state.

This way we no longer swap buffers when nothing has been rendered,
which in turn makes sure that we only draw one frame when the
render policy is OnDemand and there are no changes.

This change also adds a number of assertions on pointers to
resources to make it easier to detect missing job dependencies.

Finally, this change overhauls the job dependencies in
Renderer and RenderViewBuilder.

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

8 files changed, 253 insertions, 70 deletions

diff --git a/tests/auto/render/commons/testrenderer.h b/tests/auto/render/commons/testrenderer.h
index 20ab032b1..6f5f535ee 100644
--- a/tests/auto/render/commons/testrenderer.h
+++ b/tests/auto/render/commons/testrenderer.h
@@ -52,14 +52,14 @@ public:
     void shutdown() Q_DECL_OVERRIDE {}
     void releaseGraphicsResources() Q_DECL_OVERRIDE {}
     void render() Q_DECL_OVERRIDE {}
-    void doRender(bool scene3dBlocking = false) Q_DECL_OVERRIDE { Q_UNUSED(scene3dBlocking); }
+    void doRender() Q_DECL_OVERRIDE {}
     void cleanGraphicsResources() Q_DECL_OVERRIDE {}
     bool isRunning() const Q_DECL_OVERRIDE { return true; }
     bool shouldRender() Q_DECL_OVERRIDE { return true; }
     void skipNextFrame() Q_DECL_OVERRIDE {}
     QVector<Qt3DCore::QAspectJobPtr> renderBinJobs() Q_DECL_OVERRIDE { return QVector<Qt3DCore::QAspectJobPtr>(); }
     Qt3DCore::QAspectJobPtr pickBoundingVolumeJob() Q_DECL_OVERRIDE { return Qt3DCore::QAspectJobPtr(); }
-    Qt3DCore::QAspectJobPtr syncTextureLoadingJob() Q_DECL_OVERRIDE { return Qt3DCore::QAspectJobPtr(); }
+    Qt3DCore::QAspectJobPtr syncSkeletonLoadingJob() Q_DECL_OVERRIDE { return Qt3DCore::QAspectJobPtr(); }
     Qt3DCore::QAspectJobPtr expandBoundingVolumeJob() Q_DECL_OVERRIDE { return Qt3DCore::QAspectJobPtr(); }
     void setSceneRoot(Qt3DCore::QBackendNodeFactory *factory, Qt3DRender::Render::Entity *root) Q_DECL_OVERRIDE { Q_UNUSED(factory);  Q_UNUSED(root); }
     Qt3DRender::Render::Entity *sceneRoot() const Q_DECL_OVERRIDE { return nullptr; }
@@ -80,6 +80,12 @@ public:
     void setOffscreenSurfaceHelper(Qt3DRender::Render::OffscreenSurfaceHelper *helper) Q_DECL_OVERRIDE;
     QSurfaceFormat format() Q_DECL_OVERRIDE;
 
+    void lockSurfaceAndRender() override {}
+    bool releaseRendererAndRequestPromiseToRender() override { return true; }
+    bool waitForRenderJobs() override { return true; }
+    bool tryWaitForRenderJobs(int timeout) override { Q_UNUSED(timeout); return true; }
+    void abortRenderJobs() override {}
+
 protected:
     Qt3DRender::Render::AbstractRenderer::BackendNodeDirtySet m_changes;
     Qt3DRender::Render::NodeManagers *m_managers;
diff --git a/tests/auto/render/filtercompatibletechniquejob/tst_filtercompatibletechniquejob.cpp b/tests/auto/render/filtercompatibletechniquejob/tst_filtercompatibletechniquejob.cpp
index 4d4a08a34..803d57fa9 100644
--- a/tests/auto/render/filtercompatibletechniquejob/tst_filtercompatibletechniquejob.cpp
+++ b/tests/auto/render/filtercompatibletechniquejob/tst_filtercompatibletechniquejob.cpp
@@ -93,7 +93,8 @@ public:
     {
         renderer()->setOpenGLContext(&m_glContext);
         d_func()->m_renderer->initialize();
-        renderer()->graphicsContext()->beginDrawing(m_window.data());
+        renderer()->graphicsContext()->makeCurrent(m_window.data());
+        renderer()->graphicsContext()->beginDrawing();
     }
 
     Render::Renderer *renderer() const
diff --git a/tests/auto/render/geometryrenderer/tst_geometryrenderer.cpp b/tests/auto/render/geometryrenderer/tst_geometryrenderer.cpp
index af074def0..2c6fe12b6 100644
--- a/tests/auto/render/geometryrenderer/tst_geometryrenderer.cpp
+++ b/tests/auto/render/geometryrenderer/tst_geometryrenderer.cpp
@@ -30,6 +30,7 @@
 #include <qbackendnodetester.h>
 #include <Qt3DRender/private/geometryrenderer_p.h>
 #include <Qt3DRender/private/geometryrenderermanager_p.h>
+#include <Qt3DRender/private/nodemanagers_p.h>
 #include <Qt3DRender/qgeometry.h>
 #include <Qt3DRender/qgeometryfactory.h>
 #include <Qt3DCore/qpropertyupdatedchange.h>
@@ -186,6 +187,8 @@ private Q_SLOTS:
         // GIVEN
         Qt3DRender::Render::GeometryRenderer renderGeometryRenderer;
         TestRenderer renderer;
+        Qt3DRender::Render::NodeManagers nodeManagers;
+
         renderGeometryRenderer.setRenderer(&renderer);
 
         QVERIFY(!renderGeometryRenderer.isDirty());
diff --git a/tests/auto/render/render.pro b/tests/auto/render/render.pro
index da01dd95f..9355d8310 100644
--- a/tests/auto/render/render.pro
+++ b/tests/auto/render/render.pro
@@ -110,7 +110,8 @@ qtConfig(private_tests) {
         proximityfiltering \
         qblitframebuffer \
         blitframebuffer \
-        qcamera
+        qcamera \
+        renderbarrierjob
 
     QT_FOR_CONFIG = 3dcore-private
     qtConfig(qt3d-extras) {
diff --git a/tests/auto/render/renderbarrierjob/renderbarrierjob.pro b/tests/auto/render/renderbarrierjob/renderbarrierjob.pro
new file mode 100644
index 000000000..5a988144f
--- /dev/null
+++ b/tests/auto/render/renderbarrierjob/renderbarrierjob.pro
@@ -0,0 +1,9 @@
+TEMPLATE = app
+
+TARGET = tst_renderbarrierjob
+
+QT += 3dcore 3dcore-private 3drender 3drender-private testlib
+
+CONFIG += testcase
+
+SOURCES += tst_renderbarrierjob.cpp
diff --git a/tests/auto/render/renderbarrierjob/tst_renderbarrierjob.cpp b/tests/auto/render/renderbarrierjob/tst_renderbarrierjob.cpp
new file mode 100644
index 000000000..e3b49edd4
--- /dev/null
+++ b/tests/auto/render/renderbarrierjob/tst_renderbarrierjob.cpp
@@ -0,0 +1,118 @@
+/****************************************************************************
+**
+** Copyright (C) 2018 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the Qt3D module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:GPL-EXCEPT$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 as published by the Free Software
+** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtTest/QtTest>
+#include <QMutex>
+#include <QWaitCondition>
+#include <QThread>
+#include <Qt3DRender/private/renderbarrierjob_p.h>
+#include <Qt3DRender/private/job_common_p.h>
+
+class TestRenderThread : public QThread
+{
+public:
+    TestRenderThread(Qt3DRender::Render::RenderBarrierJobPtr barrier)
+        : m_barrier(barrier)
+    {}
+
+    void run() override
+    {
+        m_started.store(1);
+        m_writeSemaphore.release();
+        m_readSemaphore.acquire();
+
+        m_barrier->allowToProceed();
+        m_released.store(1);
+        m_writeSemaphore.release();
+        m_readSemaphore.acquire();
+
+        m_barrier->waitForDependencies();
+        m_completed.store(1);
+    }
+
+    Qt3DRender::Render::RenderBarrierJobPtr m_barrier;
+    QSemaphore m_writeSemaphore;
+    QSemaphore m_readSemaphore;
+
+    QAtomicInt m_started;
+    QAtomicInt m_released;
+    QAtomicInt m_completed;
+};
+
+class tst_RenderBarrierJob : public QObject
+{
+    Q_OBJECT
+public :
+    tst_RenderBarrierJob() {}
+    ~tst_RenderBarrierJob() {}
+
+private Q_SLOTS:
+    void shouldControlRenderThread()
+    {
+        // GIVEN a barrier (of any type)
+        auto barrier = Qt3DRender::Render::RenderBarrierJobPtr::create(Qt3DRender::Render::JobTypes::BeginDrawingBarrier);
+        TestRenderThread testThread(barrier);
+
+        // THEN
+        QVERIFY(testThread.m_started.load() == 0);
+        QVERIFY(testThread.m_released.load() == 0);
+        QVERIFY(testThread.m_completed.load() == 0);
+
+        // WHEN
+        testThread.start();
+        testThread.m_writeSemaphore.acquire();
+
+        // THEN thread should have started
+        QVERIFY(testThread.m_started.load() == 1);
+        QVERIFY(testThread.m_released.load() == 0);
+        QVERIFY(testThread.m_completed.load() == 0);
+        testThread.m_readSemaphore.release();
+
+        // WHEN
+        testThread.m_writeSemaphore.acquire();
+
+        // THEN job should be released
+        QVERIFY(testThread.m_started.load() == 1);
+        QVERIFY(testThread.m_released.load() == 1);
+        QVERIFY(testThread.m_completed.load() == 0);
+        testThread.m_readSemaphore.release();
+
+        // WHEN job runs and we wait for thread
+        barrier->run();
+        testThread.wait();
+
+        // THEN thread should be finished
+        QVERIFY(testThread.m_started.load() == 1);
+        QVERIFY(testThread.m_released.load() == 1);
+        QVERIFY(testThread.m_completed.load() == 1);
+    }
+};
+
+QTEST_MAIN(tst_RenderBarrierJob)
+
+#include "tst_renderbarrierjob.moc"
diff --git a/tests/auto/render/renderer/tst_renderer.cpp b/tests/auto/render/renderer/tst_renderer.cpp
index b53c26f83..1d2f172a7 100644
--- a/tests/auto/render/renderer/tst_renderer.cpp
+++ b/tests/auto/render/renderer/tst_renderer.cpp
@@ -34,6 +34,9 @@
 #include <Qt3DRender/private/viewportnode_p.h>
 #include <Qt3DRender/private/renderview_p.h>
 #include <Qt3DRender/private/renderviewbuilder_p.h>
+#include <Qt3DRender/private/offscreensurfacehelper_p.h>
+#include <Qt3DRender/private/loadtexturedatajob_p.h>
+#include <Qt3DRender/private/renderbarrierjob_p.h>
 
 class tst_Renderer : public QObject
 {
@@ -63,47 +66,62 @@ private Q_SLOTS:
         // NOTE: FilterCompatibleTechniqueJob and ShaderGathererJob cannot run because the context
         // is not initialized in this test
 
-        const int singleRenderViewJobCount = 11 + 2 * Qt3DRender::Render::RenderViewBuilder::optimalJobCount();
+        const int renderBarrierJobCount = 5;
+        // Barriers:    readRenderQueueSize
+        //              beginDrawing
+        //              updateGLResources
+        //              prepareCommandSubmission
+        //              endDrawing
+
+        const int renderViewJobCount = 13 + 2 * Qt3DRender::Render::RenderViewBuilder::optimalJobCount();
         // RenderViewBuilder renderViewJob,
         //                   renderableEntityFilterJob,
         //                   lightGatherJob,
         //                   computableEntityFilterJob,
         //                   syncRenderViewInitializationJob,
-        //                   syncFrustumCullingJob,
         //                   filterEntityByLayerJob,
+        //                   syncFilterEntityByLayerJob,
+        //                   syncFrustumCullingJob,
         //                   filterProximityJob,
         //                   setClearDrawBufferIndexJob,
         //                   frustumCullingJob,
         //                   syncRenderCommandBuldingJob,
-        //                   syncRenderViewCommandBuilderJob)
-        //                   n * (RenderViewCommandBuildJobs + MaterialGathererJobs
+        //                   syncRenderViewCommandBuilderJob
+        //                   n * (RenderViewCommandBuildJobs + MaterialGathererJobs)
+
+        const int flagIndependentRendererJobCount = 6;
+        // Flag independent: updateLevelOfDetailJob
+        //                   cleanupJob
+        //                   sendRenderCaptureJob
+        //                   sendBufferCaptureJob
+        //                   VAOGatherer
+        //                   updateSkinningPaletteJob
+
+        const int flagIndependetRenderViewJobCount = renderViewJobCount - 2;
+        // Cached: filterEntityByLayerJob,
+        //         syncFilterEntityByLayerJob,
+
 
         // WHEN (nothing dirty, no buffers)
         QVector<Qt3DCore::QAspectJobPtr> jobs = renderer.renderBinJobs();
 
-        // THEN (level
+        // THEN
         QCOMPARE(jobs.size(),
-                 1 + // updateLevelOfDetailJob
-                 1 + // cleanupJob
-                 1 + // sendRenderCaptureJob
-                 1 + // sendBufferCaptureJob
-                 1 + // VAOGatherer
-                 1 + // updateSkinningPaletteJob
-                 singleRenderViewJobCount); // Only valid for the first call to renderBinJobs(), since subsequent calls won't have the renderqueue reset
-
+                 flagIndependetRenderViewJobCount +
+                 renderBarrierJobCount +
+                 flagIndependentRendererJobCount);
 
         // WHEN
         renderer.markDirty(Qt3DRender::Render::AbstractRenderer::EntityEnabledDirty, nullptr);
         jobs = renderer.renderBinJobs();
 
-        // THEN (level
+        // THEN
         QCOMPARE(jobs.size(),
-                 1 + // updateLevelOfDetailJob
-                 1 + // cleanupJob
-                 1 + // sendRenderCaptureJob
-                 1 + // sendBufferCaptureJob
-                 1 + // VAOGatherer
-                 1 + // updateSkinningPaletteJob
+                 flagIndependetRenderViewJobCount +
+                 renderBarrierJobCount +
+                 flagIndependentRendererJobCount +
+                 1 + // filterEntityByLayerJob
+                 1 + // syncFilterEntityByLayerJob
                  1); // EntityEnabledDirty
 
         renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
@@ -112,17 +130,14 @@ private Q_SLOTS:
         renderer.markDirty(Qt3DRender::Render::AbstractRenderer::TransformDirty, nullptr);
         jobs = renderer.renderBinJobs();
 
-        // THEN (level
+        // THEN
         QCOMPARE(jobs.size(),
-                 1 + // updateLevelOfDetailJob
-                 1 + // cleanupJob
-                 1 + // sendRenderCaptureJob
-                 1 + // sendBufferCaptureJob
-                 1 + // VAOGatherer
+                 flagIndependetRenderViewJobCount +
+                 renderBarrierJobCount +
+                 flagIndependentRendererJobCount +
                  1 + // WorldTransformJob
                  1 + // UpdateWorldBoundingVolume
                  1 + // UpdateShaderDataTransform
-                 1 + // updateSkinningPaletteJob
                  1); // ExpandBoundingVolumeJob
 
         renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
@@ -131,16 +146,13 @@ private Q_SLOTS:
         renderer.markDirty(Qt3DRender::Render::AbstractRenderer::GeometryDirty, nullptr);
         jobs = renderer.renderBinJobs();
 
-        // THEN (level
+        // THEN
         QCOMPARE(jobs.size(),
-                 1 + // updateLevelOfDetailJob
-                 1 + // cleanupJob
-                 1 + // sendRenderCaptureJob
-                 1 + // sendBufferCaptureJob
-                 1 + // VAOGatherer
+                 flagIndependetRenderViewJobCount +
+                 renderBarrierJobCount +
+                 flagIndependentRendererJobCount +
                  1 + // CalculateBoundingVolumeJob
                  1 + // UpdateMeshTriangleListJob
-                 1 + // updateSkinningPaletteJob
                  1); // ExpandBoundingVolumeJob
 
         renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
@@ -149,14 +161,11 @@ private Q_SLOTS:
         renderer.markDirty(Qt3DRender::Render::AbstractRenderer::BuffersDirty, nullptr);
         jobs = renderer.renderBinJobs();
 
-        // THEN (level
+        // THEN
         QCOMPARE(jobs.size(),
-                 1 + // updateLevelOfDetailJob
-                 1 + // cleanupJob
-                 1 + // sendRenderCaptureJob
-                 1 + // sendBufferCaptureJob
-                 1 + // VAOGatherer
-                 1 + // updateSkinningPaletteJob
+                 flagIndependetRenderViewJobCount +
+                 renderBarrierJobCount +
+                 flagIndependentRendererJobCount +
                  1); // BufferGathererJob
 
         renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
@@ -165,16 +174,26 @@ private Q_SLOTS:
         renderer.markDirty(Qt3DRender::Render::AbstractRenderer::TexturesDirty, nullptr);
         jobs = renderer.renderBinJobs();
 
-        // THEN (level
+        // THEN
         QCOMPARE(jobs.size(),
-                 1 + // updateLevelOfDetailJob
-                 1 + // cleanupJob
-                 1 + // sendRenderCaptureJob
-                 1 + // sendBufferCaptureJob
-                 1 + // VAOGatherer
-                 1 + // TexturesGathererJob
-                 1 + // updateSkinningPaletteJob
-                 1); // SyncTexturesGathererJob
+                 flagIndependetRenderViewJobCount +
+                 renderBarrierJobCount +
+                 flagIndependentRendererJobCount +
+                 1 + // LoadTextureDataJob
+                 1); // TexturesGathererJob
+
+        renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
+
+        // WHEN
+        renderer.markDirty(Qt3DRender::Render::AbstractRenderer::SkeletonDataDirty, nullptr);
+        jobs = renderer.renderBinJobs();
+
+        // THEN
+        QCOMPARE(jobs.size(),
+                 flagIndependetRenderViewJobCount +
+                 renderBarrierJobCount +
+                 flagIndependentRendererJobCount +
+                 1); // SyncSkeletonLoadingJob
 
         renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
 
@@ -182,28 +201,45 @@ private Q_SLOTS:
         renderer.markDirty(Qt3DRender::Render::AbstractRenderer::AllDirty, nullptr);
         jobs = renderer.renderBinJobs();
 
-        // THEN (level
+        // THEN
         QCOMPARE(jobs.size(),
-                 1 + // updateLevelOfDetailJob
-                 1 + // cleanupJob
-                 1 + // sendRenderCaptureJob
-                 1 + // sendBufferCaptureJob
-                 1 + // VAOGatherer
-                 1 + // EntityEnabledDirty
+                 renderViewJobCount +
+                 renderBarrierJobCount +
+                 flagIndependentRendererJobCount +
+                 1 + // UpdateTreeEnablee
                  1 + // WorldTransformJob
                  1 + // UpdateWorldBoundingVolume
                  1 + // UpdateShaderDataTransform
-                 1 + // ExpandBoundingVolumeJob
                  1 + // CalculateBoundingVolumeJob
                  1 + // UpdateMeshTriangleListJob
+                 1 + // ExpandBoundingVolumeJob
                  1 + // BufferGathererJob
+                 1 + // LoadTextureDataJob
                  1 + // TexturesGathererJob
-                 1 + // updateSkinningPaletteJob
-                 1); // SyncTexturesGathererJob
+                 1 + // SyncSkeletonLoadingJob
+                 1 + // FilterCompatibleTechniqueJob
+                 1); // ShaderGathererJob
 
         renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
+    }
+
+    void checkRenderBarrierJobDependencies()
+    {
+        // GIVEN
+        Qt3DRender::Render::Renderer renderer(Qt3DRender::QRenderAspect::Synchronous);
+
+        // THEN
 
+        // internal dependencies
+        QVERIFY(renderer.beginDrawingBarrierJob()->dependencies().contains(renderer.readRenderQueueSizeBarrierJob()));
+        QVERIFY(renderer.updateGLResourcesBarrierJob()->dependencies().contains(renderer.beginDrawingBarrierJob()));
+        QVERIFY(renderer.prepareCommandSubmissionBarrierJob()->dependencies().contains(renderer.updateGLResourcesBarrierJob()));
+        QVERIFY(renderer.endDrawingBarrierJob()->dependencies().contains(renderer.prepareCommandSubmissionBarrierJob()));
 
+        QVERIFY(renderer.filterCompatibleTechniqueJob()->dependencies().contains(renderer.beginDrawingBarrierJob()));
+        QVERIFY(renderer.loadTextureJob()->dependencies().contains(renderer.updateGLResourcesBarrierJob()));
+        QVERIFY(renderer.prepareCommandSubmissionBarrierJob()->dependencies().contains(renderer.loadTextureJob()));
+        QVERIFY(renderer.updateGLResourcesBarrierJob()->dependencies().contains(renderer.filterCompatibleTechniqueJob()));
     }
 };
 
diff --git a/tests/auto/render/renderviewbuilder/tst_renderviewbuilder.cpp b/tests/auto/render/renderviewbuilder/tst_renderviewbuilder.cpp
index 21e2e2639..1309249d7 100644
--- a/tests/auto/render/renderviewbuilder/tst_renderviewbuilder.cpp
+++ b/tests/auto/render/renderviewbuilder/tst_renderviewbuilder.cpp
@@ -49,6 +49,7 @@
 #include <Qt3DRender/private/qrenderaspect_p.h>
 #include <Qt3DRender/private/nodemanagers_p.h>
 #include <Qt3DRender/private/managers_p.h>
+#include <Qt3DRender/private/renderbarrierjob_p.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -290,21 +291,25 @@ private Q_SLOTS:
             QVERIFY(renderViewBuilder.frustumCullingJob()->dependencies().contains(renderViewBuilder.syncFrustumCullingJob()));
             QVERIFY(renderViewBuilder.frustumCullingJob()->dependencies().contains(testAspect.renderer()->expandBoundingVolumeJob()));
 
-            QCOMPARE(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().size(), renderViewBuilder.materialGathererJobs().size() + 6);
+            QCOMPARE(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().size(), renderViewBuilder.materialGathererJobs().size() + 7);
             QVERIFY(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().contains(renderViewBuilder.syncRenderViewInitializationJob()));
             QVERIFY(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().contains(renderViewBuilder.renderableEntityFilterJob()));
             QVERIFY(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().contains(renderViewBuilder.computableEntityFilterJob()));
             QVERIFY(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().contains(renderViewBuilder.filterProximityJob()));
             QVERIFY(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().contains(renderViewBuilder.lightGathererJob()));
             QVERIFY(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().contains(renderViewBuilder.frustumCullingJob()));
+            QVERIFY(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().contains(testAspect.renderer()->updateGLResourcesBarrierJob()));
             for (const auto materialGatherer : renderViewBuilder.materialGathererJobs()) {
                 QVERIFY(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().contains(materialGatherer));
             }
 
             // Step 5
             for (const auto renderViewBuilderJob : renderViewBuilder.renderViewBuilderJobs()) {
-                QCOMPARE(renderViewBuilderJob->dependencies().size(), 1);
-                QCOMPARE(renderViewBuilderJob->dependencies().first().data(), renderViewBuilder.syncRenderCommandBuildingJob().data());
+                QCOMPARE(renderViewBuilderJob->dependencies().size(), 4);
+                QVERIFY(renderViewBuilderJob->dependencies().contains(renderViewBuilder.syncRenderCommandBuildingJob()));
+                QVERIFY(renderViewBuilderJob->dependencies().contains(testAspect.renderer()->updateSkinningPaletteJob()));
+                QVERIFY(renderViewBuilderJob->dependencies().contains(testAspect.renderer()->updateWorldBoundingVolumeJob()));
+                QVERIFY(renderViewBuilderJob->dependencies().contains(testAspect.renderer()->updateShaderDataTransformJob()));
             }
 
             // Step 6
@@ -362,7 +367,7 @@ private Q_SLOTS:
             QVERIFY(renderViewBuilder.frustumCullingJob()->dependencies().contains(renderViewBuilder.syncFrustumCullingJob()));
             QVERIFY(renderViewBuilder.frustumCullingJob()->dependencies().contains(testAspect.renderer()->expandBoundingVolumeJob()));
 
-            QCOMPARE(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().size(), renderViewBuilder.materialGathererJobs().size() + 7);
+            QCOMPARE(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().size(), renderViewBuilder.materialGathererJobs().size() + 8);
             QVERIFY(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().contains(renderViewBuilder.syncRenderViewInitializationJob()));
             QVERIFY(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().contains(renderViewBuilder.renderableEntityFilterJob()));
             QVERIFY(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().contains(renderViewBuilder.computableEntityFilterJob()));
@@ -370,14 +375,18 @@ private Q_SLOTS:
             QVERIFY(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().contains(renderViewBuilder.lightGathererJob()));
             QVERIFY(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().contains(renderViewBuilder.frustumCullingJob()));
             QVERIFY(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().contains(renderViewBuilder.filterProximityJob()));
+            QVERIFY(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().contains(testAspect.renderer()->updateGLResourcesBarrierJob()));
             for (const auto materialGatherer : renderViewBuilder.materialGathererJobs()) {
                 QVERIFY(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().contains(materialGatherer));
             }
 
             // Step 5
             for (const auto renderViewBuilderJob : renderViewBuilder.renderViewBuilderJobs()) {
-                QCOMPARE(renderViewBuilderJob->dependencies().size(), 1);
-                QCOMPARE(renderViewBuilderJob->dependencies().first().data(), renderViewBuilder.syncRenderCommandBuildingJob().data());
+                QCOMPARE(renderViewBuilderJob->dependencies().size(), 4);
+                QVERIFY(renderViewBuilderJob->dependencies().contains(renderViewBuilder.syncRenderCommandBuildingJob()));
+                QVERIFY(renderViewBuilderJob->dependencies().contains(testAspect.renderer()->updateSkinningPaletteJob()));
+                QVERIFY(renderViewBuilderJob->dependencies().contains(testAspect.renderer()->updateWorldBoundingVolumeJob()));
+                QVERIFY(renderViewBuilderJob->dependencies().contains(testAspect.renderer()->updateShaderDataTransformJob()));
             }
 
             // Step 6