Split RenderCommand generation and uniform update

In most cases, we can generate the RenderCommands once and reuse them in
subsequent frames only updating the uniforms. We still have to copy the
RenderCommands as the renderer renders while we start preparing the next frame.
This is still faster than regenerating them entirely.

Regenerating the entire commands will happen only when FrameGraph or Scene
structure changes. That should rarely be happening on a per frame basis.

Next step could be to look at how to only update commands for Entity with Parameters
that have changed.

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

3 files changed, 151 insertions, 162 deletions

diff --git a/tests/auto/render/renderer/tst_renderer.cpp b/tests/auto/render/renderer/tst_renderer.cpp
index e1bf8dfd9..65309707c 100644
--- a/tests/auto/render/renderer/tst_renderer.cpp
+++ b/tests/auto/render/renderer/tst_renderer.cpp
@@ -160,6 +160,9 @@ private Q_SLOTS:
         const int layerCacheJobCount = 2;
         // filterEntityByLayerJob,
         // syncFilterEntityByLayerJob
+
+        const int singleRenderViewCommandRebuildJobCount  = 1 + Qt3DRender::Render::RenderViewBuilder::optimalJobCount();
+
         const int singleRenderViewJobCount = 8 + 1 * Qt3DRender::Render::RenderViewBuilder::optimalJobCount();
         // RenderViewBuilder renderViewJob,
         //                   syncRenderViewInitializationJob,
@@ -167,20 +170,42 @@ private Q_SLOTS:
         //                   filterProximityJob,
         //                   setClearDrawBufferIndexJob,
         //                   frustumCullingJob,
-        //                   syncRenderCommandBuldingJob,
-        //                   syncRenderViewCommandBuilderJob
+        //                   syncRenderCommandUpdateJob,
+        //                   syncRenderViewCommandPostUpdateJob
         //                   n * (RenderViewCommandBuildJobs)
 
         // WHEN
         QVector<Qt3DCore::QAspectJobPtr> jobs = renderer.renderBinJobs();
 
-        // THEN
+        // THEN -> AllDirty
+        // (Renderer is not initialized so FilterCompatibleTechniqueJob
+        // and ShaderGathererJob are not added here)
         QCOMPARE(jobs.size(),
+                 1 + // EntityEnabledDirty
+                 1 + // WorldTransformJob
+                 1 + // UpdateWorldBoundingVolume
+                 1 + // UpdateShaderDataTransform
+                 1 + // ExpandBoundingVolumeJob
+                 1 + // CalculateBoundingVolumeJob
+                 1 + // UpdateMeshTriangleListJob
+                 1 + // updateSkinningPaletteJob
+                 1 + // SyncLoadingJobs
                  1 + // updateLevelOfDetailJob
                  1 + // cleanupJob
                  1 + // VAOGatherer
-                 1 + // updateSkinningPaletteJob
-                 1); // SyncLoadingJobs
+                 1 + // BufferGathererJob
+                 1 + // TexturesGathererJob
+                 1 + // UpdateEntityLayersJob
+                 1 + // LightGathererJob
+                 1 + // CacheLightJob
+                 1 + // RenderableEntityFilterJob
+                 1 + // CacheRenderableEntitiesJob
+                 1 + // ComputableEntityFilterJob
+                 1 + // CacheComputableEntitiesJob
+                 singleRenderViewJobCount +
+                 singleRenderViewCommandRebuildJobCount +
+                 layerCacheJobCount +
+                 renderViewBuilderMaterialCacheJobCount);
 
         renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
         renderQueue->reset();
@@ -197,6 +222,7 @@ private Q_SLOTS:
                  1 + // updateSkinningPaletteJob
                  1 + // SyncLoadingJobs
                  singleRenderViewJobCount +
+                 singleRenderViewCommandRebuildJobCount +
                  renderViewBuilderMaterialCacheJobCount +
                  layerCacheJobCount);
 
@@ -253,6 +279,7 @@ private Q_SLOTS:
                  1 + // updateSkinningPaletteJob
                  1 + // SyncLoadingJobs
                  singleRenderViewJobCount +
+                 singleRenderViewCommandRebuildJobCount +
                  renderViewBuilderMaterialCacheJobCount);
 
         renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
@@ -274,6 +301,7 @@ private Q_SLOTS:
                  1 + // ExpandBoundingVolumeJob
                  1 + // RenderableEntityFilterPtr
                  1 + // SyncRenderableEntities
+                 singleRenderViewCommandRebuildJobCount +
                  singleRenderViewJobCount);
 
         renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
@@ -315,41 +343,6 @@ private Q_SLOTS:
         renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
         renderQueue->reset();
 
-        // WHEN
-        renderer.markDirty(Qt3DRender::Render::AbstractRenderer::AllDirty, nullptr);
-        jobs = renderer.renderBinJobs();
-
-        // THEN (Renderer is not initialized so FilterCompatibleTechniqueJob
-        // and ShaderGathererJob are not added here)
-        QCOMPARE(jobs.size(),
-                 1 + // EntityEnabledDirty
-                 1 + // WorldTransformJob
-                 1 + // UpdateWorldBoundingVolume
-                 1 + // UpdateShaderDataTransform
-                 1 + // ExpandBoundingVolumeJob
-                 1 + // CalculateBoundingVolumeJob
-                 1 + // UpdateMeshTriangleListJob
-                 1 + // updateSkinningPaletteJob
-                 1 + // SyncLoadingJobs
-                 1 + // updateLevelOfDetailJob
-                 1 + // cleanupJob
-                 1 + // VAOGatherer
-                 1 + // BufferGathererJob
-                 1 + // TexturesGathererJob
-                 1 + // UpdateEntityLayersJob
-                 1 + // LightGathererJob
-                 1 + // CacheLightJob
-                 1 + // RenderableEntityFilterJob
-                 1 + // CacheRenderableEntitiesJob
-                 1 + // ComputableEntityFilterJob
-                 1 + // CacheComputableEntitiesJob
-                 singleRenderViewJobCount +
-                 layerCacheJobCount +
-                 renderViewBuilderMaterialCacheJobCount);
-
-        renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
-        renderQueue->reset();
-
         // Properly shutdown command thread
         renderer.shutdown();
     }
diff --git a/tests/auto/render/renderviewbuilder/tst_renderviewbuilder.cpp b/tests/auto/render/renderviewbuilder/tst_renderviewbuilder.cpp
index 96d51a3a9..0fb1f5e24 100644
--- a/tests/auto/render/renderviewbuilder/tst_renderviewbuilder.cpp
+++ b/tests/auto/render/renderviewbuilder/tst_renderviewbuilder.cpp
@@ -224,29 +224,29 @@ private Q_SLOTS:
             QCOMPARE(renderViewBuilder.materialGathererCacheNeedsToBeRebuilt(), false);
             QVERIFY(!renderViewBuilder.renderViewJob().isNull());
             QVERIFY(!renderViewBuilder.frustumCullingJob().isNull());
-            QVERIFY(!renderViewBuilder.syncFrustumCullingJob().isNull());
+            QVERIFY(!renderViewBuilder.syncPreFrustumCullingJob().isNull());
             QVERIFY(!renderViewBuilder.setClearDrawBufferIndexJob().isNull());
 
             QVERIFY(renderViewBuilder.filterEntityByLayerJob().isNull());
             QVERIFY(renderViewBuilder.syncFilterEntityByLayerJob().isNull());
-            QVERIFY(renderViewBuilder.syncRenderCommandBuildingJob().isNull());
-            QVERIFY(renderViewBuilder.syncRenderViewCommandBuildersJob().isNull());
-            QVERIFY(renderViewBuilder.syncRenderViewInitializationJob().isNull());
+            QVERIFY(renderViewBuilder.syncRenderViewPreCommandUpdateJob().isNull());
+            QVERIFY(renderViewBuilder.syncRenderViewPostCommandUpdateJob().isNull());
+            QVERIFY(renderViewBuilder.syncRenderViewPostInitializationJob().isNull());
 
-            QCOMPARE(renderViewBuilder.renderViewBuilderJobs().size(), 0);
+            QCOMPARE(renderViewBuilder.renderViewCommandUpdaterJobs().size(), 0);
             QCOMPARE(renderViewBuilder.materialGathererJobs().size(), 0);
 
             // WHEN
             renderViewBuilder.prepareJobs();
 
             // THEN
-            QVERIFY(!renderViewBuilder.syncRenderCommandBuildingJob().isNull());
-            QVERIFY(!renderViewBuilder.syncRenderViewCommandBuildersJob().isNull());
-            QVERIFY(!renderViewBuilder.syncRenderViewInitializationJob().isNull());
+            QVERIFY(!renderViewBuilder.syncRenderViewPreCommandUpdateJob().isNull());
+            QVERIFY(!renderViewBuilder.syncRenderViewPostCommandUpdateJob().isNull());
+            QVERIFY(!renderViewBuilder.syncRenderViewPostInitializationJob().isNull());
             QVERIFY(renderViewBuilder.filterEntityByLayerJob().isNull());
             QVERIFY(renderViewBuilder.syncFilterEntityByLayerJob().isNull());
 
-            QCOMPARE(renderViewBuilder.renderViewBuilderJobs().size(), Qt3DRender::Render::RenderViewBuilder::optimalJobCount());
+            QCOMPARE(renderViewBuilder.renderViewCommandUpdaterJobs().size(), Qt3DRender::Render::RenderViewBuilder::optimalJobCount());
             QCOMPARE(renderViewBuilder.materialGathererJobs().size(), 0);
             QCOMPARE(renderViewBuilder.buildJobHierachy().size(), 8 + 1 * Qt3DRender::Render::RenderViewBuilder::optimalJobCount());
         }
@@ -338,8 +338,8 @@ private Q_SLOTS:
 
 
             // Step 2
-            QCOMPARE(renderViewBuilder.syncRenderViewInitializationJob()->dependencies().size(), 1);
-            QCOMPARE(renderViewBuilder.syncRenderViewInitializationJob()->dependencies().constFirst().toStrongRef().data(),
+            QCOMPARE(renderViewBuilder.syncRenderViewPostInitializationJob()->dependencies().size(), 1);
+            QCOMPARE(renderViewBuilder.syncRenderViewPostInitializationJob()->dependencies().constFirst().toStrongRef().data(),
                      renderViewBuilder.renderViewJob().data());
 
             // Step 3
@@ -347,43 +347,43 @@ private Q_SLOTS:
             QVERIFY(renderViewBuilder.syncFilterEntityByLayerJob().isNull());
 
             QCOMPARE(renderViewBuilder.filterProximityJob()->dependencies().size(), 2);
-            QVERIFY(renderViewBuilder.filterProximityJob()->dependencies().contains(renderViewBuilder.syncRenderViewInitializationJob()));
+            QVERIFY(renderViewBuilder.filterProximityJob()->dependencies().contains(renderViewBuilder.syncRenderViewPostInitializationJob()));
             QVERIFY(renderViewBuilder.filterProximityJob()->dependencies().contains(testAspect.renderer()->expandBoundingVolumeJob()));
 
             QCOMPARE(renderViewBuilder.setClearDrawBufferIndexJob()->dependencies().size(), 1);
             QCOMPARE(renderViewBuilder.setClearDrawBufferIndexJob()->dependencies().constFirst().toStrongRef().data(),
-                     renderViewBuilder.syncRenderViewInitializationJob().data());
+                     renderViewBuilder.syncRenderViewPostInitializationJob().data());
 
-            QCOMPARE(renderViewBuilder.syncFrustumCullingJob()->dependencies().size(), 3);
-            QVERIFY(renderViewBuilder.syncFrustumCullingJob()->dependencies().contains(renderViewBuilder.syncRenderViewInitializationJob()));
-            QVERIFY(renderViewBuilder.syncFrustumCullingJob()->dependencies().contains(testAspect.renderer()->updateWorldTransformJob()));
-            QVERIFY(renderViewBuilder.syncFrustumCullingJob()->dependencies().contains(testAspect.renderer()->updateShaderDataTransformJob()));
+            QCOMPARE(renderViewBuilder.syncPreFrustumCullingJob()->dependencies().size(), 3);
+            QVERIFY(renderViewBuilder.syncPreFrustumCullingJob()->dependencies().contains(renderViewBuilder.syncRenderViewPostInitializationJob()));
+            QVERIFY(renderViewBuilder.syncPreFrustumCullingJob()->dependencies().contains(testAspect.renderer()->updateWorldTransformJob()));
+            QVERIFY(renderViewBuilder.syncPreFrustumCullingJob()->dependencies().contains(testAspect.renderer()->updateShaderDataTransformJob()));
 
             // Step 4
             QCOMPARE(renderViewBuilder.frustumCullingJob()->dependencies().size(), 2);
-            QVERIFY(renderViewBuilder.frustumCullingJob()->dependencies().contains(renderViewBuilder.syncFrustumCullingJob()));
+            QVERIFY(renderViewBuilder.frustumCullingJob()->dependencies().contains(renderViewBuilder.syncPreFrustumCullingJob()));
             QVERIFY(renderViewBuilder.frustumCullingJob()->dependencies().contains(testAspect.renderer()->expandBoundingVolumeJob()));
 
 
-            QCOMPARE(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().size(), renderViewBuilder.materialGathererJobs().size() + 6);
-            QVERIFY(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().contains(renderViewBuilder.syncRenderViewInitializationJob()));
-            QVERIFY(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().contains(renderViewBuilder.filterProximityJob()));
-            QVERIFY(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().contains(renderViewBuilder.frustumCullingJob()));
-            QVERIFY(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().contains(testAspect.renderer()->introspectShadersJob()));
-            QVERIFY(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().contains(testAspect.renderer()->bufferGathererJob()));
-            QVERIFY(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().contains(testAspect.renderer()->textureGathererJob()));
+            QCOMPARE(renderViewBuilder.syncRenderViewPreCommandUpdateJob()->dependencies().size(), renderViewBuilder.materialGathererJobs().size() + 6);
+            QVERIFY(renderViewBuilder.syncRenderViewPreCommandUpdateJob()->dependencies().contains(renderViewBuilder.syncRenderViewPostInitializationJob()));
+            QVERIFY(renderViewBuilder.syncRenderViewPreCommandUpdateJob()->dependencies().contains(renderViewBuilder.filterProximityJob()));
+            QVERIFY(renderViewBuilder.syncRenderViewPreCommandUpdateJob()->dependencies().contains(renderViewBuilder.frustumCullingJob()));
+            QVERIFY(renderViewBuilder.syncRenderViewPreCommandUpdateJob()->dependencies().contains(testAspect.renderer()->introspectShadersJob()));
+            QVERIFY(renderViewBuilder.syncRenderViewPreCommandUpdateJob()->dependencies().contains(testAspect.renderer()->bufferGathererJob()));
+            QVERIFY(renderViewBuilder.syncRenderViewPreCommandUpdateJob()->dependencies().contains(testAspect.renderer()->textureGathererJob()));
 
             // Step 5
-            for (const auto &renderViewBuilderJob : renderViewBuilder.renderViewBuilderJobs()) {
+            for (const auto &renderViewBuilderJob : renderViewBuilder.renderViewCommandUpdaterJobs()) {
                 QCOMPARE(renderViewBuilderJob->dependencies().size(), 1);
                 QCOMPARE(renderViewBuilderJob->dependencies().constFirst().toStrongRef().data(),
-                         renderViewBuilder.syncRenderCommandBuildingJob().data());
+                         renderViewBuilder.syncRenderViewPreCommandUpdateJob().data());
             }
 
             // Step 6
-            QCOMPARE(renderViewBuilder.syncRenderViewCommandBuildersJob()->dependencies().size(), renderViewBuilder.renderViewBuilderJobs().size());
-            for (const auto &renderViewBuilderJob : renderViewBuilder.renderViewBuilderJobs()) {
-                QVERIFY(renderViewBuilder.syncRenderViewCommandBuildersJob()->dependencies().contains(renderViewBuilderJob));
+            QCOMPARE(renderViewBuilder.syncRenderViewPostCommandUpdateJob()->dependencies().size(), renderViewBuilder.renderViewCommandUpdaterJobs().size());
+            for (const auto &renderViewBuilderJob : renderViewBuilder.renderViewCommandUpdaterJobs()) {
+                QVERIFY(renderViewBuilder.syncRenderViewPostCommandUpdateJob()->dependencies().contains(renderViewBuilderJob));
             }
         }
         {
@@ -399,63 +399,63 @@ private Q_SLOTS:
             QCOMPARE(renderViewBuilder.renderViewJob()->dependencies().size(), 1); // Depends upon skinning palette update
 
             // Step 2
-            QCOMPARE(renderViewBuilder.syncRenderViewInitializationJob()->dependencies().size(), 1);
-            QCOMPARE(renderViewBuilder.syncRenderViewInitializationJob()->dependencies().constFirst().toStrongRef().data(),
+            QCOMPARE(renderViewBuilder.syncRenderViewPostInitializationJob()->dependencies().size(), 1);
+            QCOMPARE(renderViewBuilder.syncRenderViewPostInitializationJob()->dependencies().constFirst().toStrongRef().data(),
                      renderViewBuilder.renderViewJob().data());
 
             // Step 3
             QCOMPARE(renderViewBuilder.filterEntityByLayerJob()->dependencies().size(), 3);
             QVERIFY(renderViewBuilder.filterEntityByLayerJob()->dependencies().contains(testAspect.renderer()->updateEntityLayersJob()));
-            QVERIFY(renderViewBuilder.filterEntityByLayerJob()->dependencies().contains(renderViewBuilder.syncRenderViewInitializationJob()));
+            QVERIFY(renderViewBuilder.filterEntityByLayerJob()->dependencies().contains(renderViewBuilder.syncRenderViewPostInitializationJob()));
             QVERIFY(renderViewBuilder.filterEntityByLayerJob()->dependencies().contains(testAspect.renderer()->updateTreeEnabledJob()));
 
             QCOMPARE(renderViewBuilder.syncFilterEntityByLayerJob()->dependencies().size(), 1);
             QVERIFY(renderViewBuilder.syncFilterEntityByLayerJob()->dependencies().contains(renderViewBuilder.filterEntityByLayerJob()));
 
             QCOMPARE(renderViewBuilder.filterProximityJob()->dependencies().size(), 2);
-            QVERIFY(renderViewBuilder.filterProximityJob()->dependencies().contains(renderViewBuilder.syncRenderViewInitializationJob()));
+            QVERIFY(renderViewBuilder.filterProximityJob()->dependencies().contains(renderViewBuilder.syncRenderViewPostInitializationJob()));
             QVERIFY(renderViewBuilder.filterProximityJob()->dependencies().contains(testAspect.renderer()->expandBoundingVolumeJob()));
 
             QCOMPARE(renderViewBuilder.setClearDrawBufferIndexJob()->dependencies().size(), 1);
             QCOMPARE(renderViewBuilder.setClearDrawBufferIndexJob()->dependencies().constFirst().toStrongRef().data(),
-                     renderViewBuilder.syncRenderViewInitializationJob().data());
+                     renderViewBuilder.syncRenderViewPostInitializationJob().data());
 
-            QCOMPARE(renderViewBuilder.syncFrustumCullingJob()->dependencies().size(), 3);
-            QVERIFY(renderViewBuilder.syncFrustumCullingJob()->dependencies().contains(renderViewBuilder.syncRenderViewInitializationJob()));
-            QVERIFY(renderViewBuilder.syncFrustumCullingJob()->dependencies().contains(testAspect.renderer()->updateWorldTransformJob()));
-            QVERIFY(renderViewBuilder.syncFrustumCullingJob()->dependencies().contains(testAspect.renderer()->updateShaderDataTransformJob()));
+            QCOMPARE(renderViewBuilder.syncPreFrustumCullingJob()->dependencies().size(), 3);
+            QVERIFY(renderViewBuilder.syncPreFrustumCullingJob()->dependencies().contains(renderViewBuilder.syncRenderViewPostInitializationJob()));
+            QVERIFY(renderViewBuilder.syncPreFrustumCullingJob()->dependencies().contains(testAspect.renderer()->updateWorldTransformJob()));
+            QVERIFY(renderViewBuilder.syncPreFrustumCullingJob()->dependencies().contains(testAspect.renderer()->updateShaderDataTransformJob()));
 
             for (const auto &materialGatherer : renderViewBuilder.materialGathererJobs()) {
                 QCOMPARE(materialGatherer->dependencies().size(), 3);
-                QVERIFY(materialGatherer->dependencies().contains(renderViewBuilder.syncRenderViewInitializationJob()));
+                QVERIFY(materialGatherer->dependencies().contains(renderViewBuilder.syncRenderViewPostInitializationJob()));
                 QVERIFY(materialGatherer->dependencies().contains(testAspect.renderer()->introspectShadersJob()));
                 QVERIFY(materialGatherer->dependencies().contains(testAspect.renderer()->filterCompatibleTechniqueJob()));
             }
 
             // Step 4
             QCOMPARE(renderViewBuilder.frustumCullingJob()->dependencies().size(), 2);
-            QVERIFY(renderViewBuilder.frustumCullingJob()->dependencies().contains(renderViewBuilder.syncFrustumCullingJob()));
+            QVERIFY(renderViewBuilder.frustumCullingJob()->dependencies().contains(renderViewBuilder.syncPreFrustumCullingJob()));
             QVERIFY(renderViewBuilder.frustumCullingJob()->dependencies().contains(testAspect.renderer()->expandBoundingVolumeJob()));
 
-            QVERIFY(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().contains(renderViewBuilder.syncRenderViewInitializationJob()));
-            QVERIFY(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().contains(renderViewBuilder.syncFilterEntityByLayerJob()));
-            QVERIFY(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().contains(renderViewBuilder.frustumCullingJob()));
-            QVERIFY(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().contains(renderViewBuilder.filterProximityJob()));
-            QVERIFY(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().contains(testAspect.renderer()->introspectShadersJob()));
-            QVERIFY(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().contains(testAspect.renderer()->bufferGathererJob()));
-            QVERIFY(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().contains(testAspect.renderer()->textureGathererJob()));
+            QVERIFY(renderViewBuilder.syncRenderViewPreCommandUpdateJob()->dependencies().contains(renderViewBuilder.syncRenderViewPostInitializationJob()));
+            QVERIFY(renderViewBuilder.syncRenderViewPreCommandUpdateJob()->dependencies().contains(renderViewBuilder.syncFilterEntityByLayerJob()));
+            QVERIFY(renderViewBuilder.syncRenderViewPreCommandUpdateJob()->dependencies().contains(renderViewBuilder.frustumCullingJob()));
+            QVERIFY(renderViewBuilder.syncRenderViewPreCommandUpdateJob()->dependencies().contains(renderViewBuilder.filterProximityJob()));
+            QVERIFY(renderViewBuilder.syncRenderViewPreCommandUpdateJob()->dependencies().contains(testAspect.renderer()->introspectShadersJob()));
+            QVERIFY(renderViewBuilder.syncRenderViewPreCommandUpdateJob()->dependencies().contains(testAspect.renderer()->bufferGathererJob()));
+            QVERIFY(renderViewBuilder.syncRenderViewPreCommandUpdateJob()->dependencies().contains(testAspect.renderer()->textureGathererJob()));
 
             // Step 5
-            for (const auto &renderViewBuilderJob : renderViewBuilder.renderViewBuilderJobs()) {
+            for (const auto &renderViewBuilderJob : renderViewBuilder.renderViewCommandUpdaterJobs()) {
                 QCOMPARE(renderViewBuilderJob->dependencies().size(), 1);
                 QCOMPARE(renderViewBuilderJob->dependencies().constFirst().toStrongRef().data(),
-                         renderViewBuilder.syncRenderCommandBuildingJob().data());
+                         renderViewBuilder.syncRenderViewPreCommandUpdateJob().data());
             }
 
             // Step 6
-            QCOMPARE(renderViewBuilder.syncRenderViewCommandBuildersJob()->dependencies().size(), renderViewBuilder.renderViewBuilderJobs().size());
-            for (const auto &renderViewBuilderJob : renderViewBuilder.renderViewBuilderJobs()) {
-                QVERIFY(renderViewBuilder.syncRenderViewCommandBuildersJob()->dependencies().contains(renderViewBuilderJob));
+            QCOMPARE(renderViewBuilder.syncRenderViewPostCommandUpdateJob()->dependencies().size(), renderViewBuilder.renderViewCommandUpdaterJobs().size());
+            for (const auto &renderViewBuilderJob : renderViewBuilder.renderViewCommandUpdaterJobs()) {
+                QVERIFY(renderViewBuilder.syncRenderViewPostCommandUpdateJob()->dependencies().contains(renderViewBuilderJob));
             }
         }
     }
@@ -581,7 +581,7 @@ private Q_SLOTS:
 
             // WHEN
             renderViewBuilder.renderViewJob()->run();
-            renderViewBuilder.syncRenderViewInitializationJob()->run();
+            renderViewBuilder.syncRenderViewPostInitializationJob()->run();
 
             // THEN
             QCOMPARE(renderViewBuilder.frustumCullingJob()->isActive(), true);
@@ -608,7 +608,7 @@ private Q_SLOTS:
 
             // WHEN
             renderViewBuilder.renderViewJob()->run();
-            renderViewBuilder.syncRenderViewInitializationJob()->run();
+            renderViewBuilder.syncRenderViewPostInitializationJob()->run();
 
             // THEN
             QCOMPARE(renderViewBuilder.frustumCullingJob()->isActive(), true);
@@ -647,7 +647,7 @@ private Q_SLOTS:
 
         // WHEN
         renderViewBuilder.renderViewJob()->run();
-        renderViewBuilder.syncFrustumCullingJob()->run();
+        renderViewBuilder.syncPreFrustumCullingJob()->run();
 
         // THEN
         QCOMPARE(convertToQMatrix4x4(renderViewBuilder.frustumCullingJob()->viewProjection()), camera->projectionMatrix() * camera->viewMatrix());
@@ -676,7 +676,7 @@ private Q_SLOTS:
 
         renderViewBuilder.renderViewJob()->run();
         renderViewBuilder.renderableEntityFilterJob()->run();
-        renderViewBuilder.syncRenderViewInitializationJob()->run();
+        renderViewBuilder.syncRenderViewPostInitializationJob()->run();
         renderViewBuilder.filterEntityByLayerJob()->run();
 
         QVector<Qt3DRender::Render::Entity *> renderableEntity = renderViewBuilder.renderableEntityFilterJob()->filteredEntities();
diff --git a/tests/auto/render/renderviews/tst_renderviews.cpp b/tests/auto/render/renderviews/tst_renderviews.cpp
index f38915bf8..17995659b 100644
--- a/tests/auto/render/renderviews/tst_renderviews.cpp
+++ b/tests/auto/render/renderviews/tst_renderviews.cpp
@@ -138,14 +138,14 @@ private Q_SLOTS:
     {
         // GIVEN
         RenderView renderView;
-        QVector<RenderCommand *> rawCommands;
+        QVector<RenderCommand> rawCommands;
         QVector<QSortPolicy::SortType> sortTypes;
 
         sortTypes.push_back(QSortPolicy::BackToFront);
 
         for (int i = 0; i < 200; ++i) {
-            RenderCommand *c = new RenderCommand();
-            c->m_depth = float(i);
+            RenderCommand c;
+            c.m_depth = float(i);
             rawCommands.push_back(c);
         }
 
@@ -155,10 +155,10 @@ private Q_SLOTS:
         renderView.sort();
 
         // THEN
-        const QVector<RenderCommand *> sortedCommands = renderView.commands();
+        const QVector<RenderCommand> sortedCommands = renderView.commands();
         QCOMPARE(rawCommands.size(), sortedCommands.size());
         for (int j = 1; j < sortedCommands.size(); ++j)
-            QVERIFY(sortedCommands.at(j - 1)->m_depth > sortedCommands.at(j)->m_depth);
+            QVERIFY(sortedCommands.at(j - 1).m_depth > sortedCommands.at(j).m_depth);
 
         // RenderCommands are deleted by RenderView dtor
     }
@@ -167,7 +167,7 @@ private Q_SLOTS:
     {
         // GIVEN
         RenderView renderView;
-        QVector<RenderCommand *> rawCommands;
+        QVector<RenderCommand> rawCommands;
         QVector<QSortPolicy::SortType> sortTypes;
 
         sortTypes.push_back(QSortPolicy::Material);
@@ -181,8 +181,8 @@ private Q_SLOTS:
         };
 
         for (int i = 0; i < 20; ++i) {
-            RenderCommand *c = new RenderCommand();
-            c->m_shaderDna = dnas[i % 5];
+            RenderCommand c;
+            c.m_shaderDna = dnas[i % 5];
             rawCommands.push_back(c);
         }
 
@@ -192,18 +192,18 @@ private Q_SLOTS:
         renderView.sort();
 
         // THEN
-        const QVector<RenderCommand *> sortedCommands = renderView.commands();
+        const QVector<RenderCommand> sortedCommands = renderView.commands();
         QCOMPARE(rawCommands.size(), sortedCommands.size());
         ProgramDNA targetDNA;
 
         for (int j = 0; j < sortedCommands.size(); ++j) {
 
             if (j % 4 == 0) {
-                targetDNA = sortedCommands.at(j)->m_shaderDna;
+                targetDNA = sortedCommands.at(j).m_shaderDna;
                 if (j > 0)
-                    QVERIFY(targetDNA != sortedCommands.at(j - 1)->m_shaderDna);
+                    QVERIFY(targetDNA != sortedCommands.at(j - 1).m_shaderDna);
             }
-            QCOMPARE(targetDNA, sortedCommands.at(j)->m_shaderDna);
+            QCOMPARE(targetDNA, sortedCommands.at(j).m_shaderDna);
         }
 
         // RenderCommands are deleted by RenderView dtor
@@ -247,12 +247,12 @@ private Q_SLOTS:
         QFETCH(QVector<ShaderParameterPack>, expectedMinimizedParameters);
 
         RenderView renderView;
-        QVector<RenderCommand *> rawCommands;
+        QVector<RenderCommand> rawCommands;
 
         for (int i = 0, m = programDNAs.size(); i < m; ++i) {
-            RenderCommand *c = new RenderCommand();
-            c->m_shaderDna = programDNAs.at(i);
-            c->m_parameterPack = rawParameters.at(i);
+            RenderCommand c;
+            c.m_shaderDna = programDNAs.at(i);
+            c.m_parameterPack = rawParameters.at(i);
             rawCommands.push_back(c);
         }
 
@@ -261,13 +261,13 @@ private Q_SLOTS:
         renderView.sort();
 
         // THEN
-        const QVector<RenderCommand *> sortedCommands = renderView.commands();
+        const QVector<RenderCommand> sortedCommands = renderView.commands();
         QCOMPARE(rawCommands, sortedCommands);
 
         for (int i = 0, m = programDNAs.size(); i < m; ++i) {
-            const RenderCommand *c = sortedCommands.at(i);
-            QCOMPARE(c->m_shaderDna, programDNAs.at(i));
-            compareShaderParameterPacks(c->m_parameterPack, expectedMinimizedParameters.at(i));
+            const RenderCommand c = sortedCommands.at(i);
+            QCOMPARE(c.m_shaderDna, programDNAs.at(i));
+            compareShaderParameterPacks(c.m_parameterPack, expectedMinimizedParameters.at(i));
         }
     }
 
@@ -276,14 +276,14 @@ private Q_SLOTS:
     {
         // GIVEN
         RenderView renderView;
-        QVector<RenderCommand *> rawCommands;
+        QVector<RenderCommand> rawCommands;
         QVector<QSortPolicy::SortType> sortTypes;
 
         sortTypes.push_back(QSortPolicy::FrontToBack);
 
         for (int i = 0; i < 200; ++i) {
-            RenderCommand *c = new RenderCommand();
-            c->m_depth = float(i);
+            RenderCommand c;
+            c.m_depth = float(i);
             rawCommands.push_back(c);
         }
 
@@ -293,10 +293,10 @@ private Q_SLOTS:
         renderView.sort();
 
         // THEN
-        const QVector<RenderCommand *> sortedCommands = renderView.commands();
+        const QVector<RenderCommand> sortedCommands = renderView.commands();
         QCOMPARE(rawCommands.size(), sortedCommands.size());
         for (int j = 1; j < sortedCommands.size(); ++j)
-            QVERIFY(sortedCommands.at(j - 1)->m_depth < sortedCommands.at(j)->m_depth);
+            QVERIFY(sortedCommands.at(j - 1).m_depth < sortedCommands.at(j).m_depth);
 
         // RenderCommands are deleted by RenderView dtor
     }
@@ -305,14 +305,14 @@ private Q_SLOTS:
     {
         // GIVEN
         RenderView renderView;
-        QVector<RenderCommand *> rawCommands;
+        QVector<RenderCommand> rawCommands;
         QVector<QSortPolicy::SortType> sortTypes;
 
         sortTypes.push_back(QSortPolicy::StateChangeCost);
 
         for (int i = 0; i < 200; ++i) {
-            RenderCommand *c = new RenderCommand();
-            c->m_changeCost = i;
+            RenderCommand c;
+            c.m_changeCost = i;
             rawCommands.push_back(c);
         }
 
@@ -322,10 +322,10 @@ private Q_SLOTS:
         renderView.sort();
 
         // THEN
-        const QVector<RenderCommand *> sortedCommands = renderView.commands();
+        const QVector<RenderCommand> sortedCommands = renderView.commands();
         QCOMPARE(rawCommands.size(), sortedCommands.size());
         for (int j = 1; j < sortedCommands.size(); ++j)
-            QVERIFY(sortedCommands.at(j - 1)->m_changeCost > sortedCommands.at(j)->m_changeCost);
+            QVERIFY(sortedCommands.at(j - 1).m_changeCost > sortedCommands.at(j).m_changeCost);
 
         // RenderCommands are deleted by RenderView dtor
     }
@@ -334,7 +334,7 @@ private Q_SLOTS:
     {
         // GIVEN
         RenderView renderView;
-        QVector<RenderCommand *> rawCommands;
+        QVector<RenderCommand> rawCommands;
         QVector<QSortPolicy::SortType> sortTypes;
 
         sortTypes.push_back(QSortPolicy::StateChangeCost);
@@ -360,24 +360,24 @@ private Q_SLOTS:
         };
 
         auto buildRC = [] (ProgramDNA dna, float depth, int changeCost) {
-            RenderCommand *c = new RenderCommand();
-            c->m_shaderDna = dna;
-            c->m_depth = depth;
-            c->m_changeCost = changeCost;
+            RenderCommand c;
+            c.m_shaderDna = dna;
+            c.m_depth = depth;
+            c.m_changeCost = changeCost;
             return c;
         };
 
-        RenderCommand *c5 = buildRC(dna[3], depth[1], stateChangeCost[1]);
-        RenderCommand *c3 = buildRC(dna[3], depth[0], stateChangeCost[1]);
-        RenderCommand *c4 = buildRC(dna[2], depth[1], stateChangeCost[1]);
-        RenderCommand *c8 = buildRC(dna[1], depth[1], stateChangeCost[1]);
-        RenderCommand *c0 = buildRC(dna[0], depth[2], stateChangeCost[1]);
+        RenderCommand c5 = buildRC(dna[3], depth[1], stateChangeCost[1]);
+        RenderCommand c3 = buildRC(dna[3], depth[0], stateChangeCost[1]);
+        RenderCommand c4 = buildRC(dna[2], depth[1], stateChangeCost[1]);
+        RenderCommand c8 = buildRC(dna[1], depth[1], stateChangeCost[1]);
+        RenderCommand c0 = buildRC(dna[0], depth[2], stateChangeCost[1]);
 
-        RenderCommand *c2 = buildRC(dna[2], depth[2], stateChangeCost[0]);
-        RenderCommand *c9 = buildRC(dna[2], depth[0], stateChangeCost[0]);
-        RenderCommand *c1 = buildRC(dna[1], depth[0], stateChangeCost[0]);
-        RenderCommand *c7 = buildRC(dna[0], depth[2], stateChangeCost[0]);
-        RenderCommand *c6 = buildRC(dna[0], depth[1], stateChangeCost[0]);
+        RenderCommand c2 = buildRC(dna[2], depth[2], stateChangeCost[0]);
+        RenderCommand c9 = buildRC(dna[2], depth[0], stateChangeCost[0]);
+        RenderCommand c1 = buildRC(dna[1], depth[0], stateChangeCost[0]);
+        RenderCommand c7 = buildRC(dna[0], depth[2], stateChangeCost[0]);
+        RenderCommand c6 = buildRC(dna[0], depth[1], stateChangeCost[0]);
 
         rawCommands << c0 << c1 << c2 << c3 << c4 << c5 << c6 << c7 << c8 << c9;
 
@@ -387,12 +387,9 @@ private Q_SLOTS:
         renderView.sort();
 
         // THEN
-        const QVector<RenderCommand *> sortedCommands = renderView.commands();
+        const QVector<RenderCommand> sortedCommands = renderView.commands();
         QCOMPARE(rawCommands.size(), sortedCommands.size());
 
-        for (RenderCommand *rc : sortedCommands)
-            qDebug() << rc->m_changeCost << rc->m_shaderDna << rc->m_depth;
-
         // Ordered by higher state, higher shaderDNA and higher depth
         QCOMPARE(c0, sortedCommands.at(4));
         QCOMPARE(c3, sortedCommands.at(1));
@@ -423,61 +420,60 @@ private Q_SLOTS:
         Qt3DCore::QNodeId tex3 = Qt3DCore::QNodeId::createId();
         Qt3DCore::QNodeId tex4 = Qt3DCore::QNodeId::createId();
 
-        RenderCommand *a = new RenderCommand();
+        RenderCommand a;
         {
             ShaderParameterPack pack;
             pack.setTexture(0, 0, tex1);
             pack.setTexture(1, 0, tex3);
             pack.setTexture(2, 0, tex4);
             pack.setTexture(3, 0, tex2);
-            a->m_parameterPack = pack;
+            a.m_parameterPack = pack;
         }
-        RenderCommand *b = new RenderCommand();
-        RenderCommand *c = new RenderCommand();
+        RenderCommand b;
+        RenderCommand c;
         {
             ShaderParameterPack pack;
             pack.setTexture(0, 0, tex1);
             pack.setTexture(3, 0, tex2);
-            c->m_parameterPack = pack;
+            c.m_parameterPack = pack;
         }
-        RenderCommand *d = new RenderCommand();
+        RenderCommand d;
         {
             ShaderParameterPack pack;
             pack.setTexture(1, 0, tex3);
             pack.setTexture(2, 0, tex4);
-            d->m_parameterPack = pack;
+            d.m_parameterPack = pack;
         }
-        RenderCommand *e = new RenderCommand();
+        RenderCommand e;
         {
             ShaderParameterPack pack;
             pack.setTexture(3, 0, tex2);
-            e->m_parameterPack = pack;
+            e.m_parameterPack = pack;
         }
-        RenderCommand *f = new RenderCommand();
+        RenderCommand f;
         {
             ShaderParameterPack pack;
             pack.setTexture(3, 0, tex2);
-            f->m_parameterPack = pack;
+            f.m_parameterPack = pack;
         }
-        RenderCommand *g = new RenderCommand();
+        RenderCommand g;
         {
             ShaderParameterPack pack;
             pack.setTexture(0, 0, tex1);
             pack.setTexture(1, 0, tex3);
             pack.setTexture(2, 0, tex4);
             pack.setTexture(3, 0, tex2);
-            g->m_parameterPack = pack;
+            g.m_parameterPack = pack;
         }
 
         // WHEN
-        QVector<RenderCommand *> rawCommands = {a, b, c, d, e, f, g};
+        QVector<RenderCommand> rawCommands = {a, b, c, d, e, f, g};
         renderView.addSortType(sortTypes);
         renderView.setCommands(rawCommands);
         renderView.sort();
 
         // THEN
-        const QVector<RenderCommand *> sortedCommands = renderView.commands();
-        qDebug() << rawCommands << sortedCommands;
+        const QVector<RenderCommand> sortedCommands = renderView.commands();
         QCOMPARE(rawCommands.size(), sortedCommands.size());
         QCOMPARE(sortedCommands.at(0), a);
         QCOMPARE(sortedCommands.at(1), g);