Move jobs into Renderer

Will make it easier to set dependencies between all the jobs in a RenderView
since they have been split up in several.

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

13 files changed, 143 insertions, 104 deletions

diff --git a/src/render/backend/renderer.cpp b/src/render/backend/renderer.cpp
index 7ea218da8..55950fbbd 100644
--- a/src/render/backend/renderer.cpp
+++ b/src/render/backend/renderer.cpp
@@ -78,6 +78,7 @@
 #include <Qt3DRender/private/geometryrenderermanager_p.h>
 #include <Qt3DRender/private/openglvertexarrayobject_p.h>
 #include <Qt3DRender/private/platformsurfacefilter_p.h>
+#include <Qt3DRender/private/loadbufferjob_p.h>
 
 #include <Qt3DRender/qcameralens.h>
 #include <Qt3DCore/private/qeventfilterservice_p.h>
@@ -147,15 +148,29 @@ Renderer::Renderer(QRenderAspect::RenderType type)
     , m_changeSet(0)
     , m_lastFrameCorrect(0)
     , m_glContext(nullptr)
-    , m_pickBoundingVolumeJob(nullptr)
+    , m_pickBoundingVolumeJob(PickBoundingVolumeJobPtr::create(this))
     , m_time(0)
     , m_settings(nullptr)
+    , m_framePreparationJob(Render::FramePreparationJobPtr::create())
+    , m_cleanupJob(Render::FrameCleanupJobPtr::create())
+    , m_worldTransformJob(Render::UpdateWorldTransformJobPtr::create())
+    , m_updateBoundingVolumeJob(Render::UpdateBoundingVolumeJobPtr::create())
+    , m_calculateBoundingVolumeJob(Render::CalculateBoundingVolumeJobPtr::create())
 {
     // Set renderer as running - it will wait in the context of the
     // RenderThread for RenderViews to be submitted
     m_running.fetchAndStoreOrdered(1);
     if (m_renderThread)
         m_renderThread->waitForStart();
+
+    // Create jobs to update transforms and bounding volumes
+    // We can only update bounding volumes once all world transforms are known
+    m_updateBoundingVolumeJob->addDependency(m_worldTransformJob);
+    m_framePreparationJob->addDependency(m_worldTransformJob);
+
+    // All world stuff depends on the RenderEntity's localBoundingVolume
+    m_worldTransformJob->addDependency(m_calculateBoundingVolumeJob);
+    m_pickBoundingVolumeJob->addDependency(m_framePreparationJob);
 }
 
 Renderer::~Renderer()
@@ -190,6 +205,16 @@ void Renderer::setTime(qint64 time)
     m_time = time;
 }
 
+void Renderer::setNodeManagers(NodeManagers *managers)
+{
+    m_nodesManager = managers;
+
+    m_framePreparationJob->setManagers(m_nodesManager);
+    m_cleanupJob->setManagers(m_nodesManager);
+    m_calculateBoundingVolumeJob->setManagers(m_nodesManager);
+    m_pickBoundingVolumeJob->setManagers(m_nodesManager);
+}
+
 NodeManagers *Renderer::nodeManagers() const
 {
     return m_nodesManager;
@@ -468,6 +493,14 @@ void Renderer::setSceneRoot(QBackendNodeFactory *factory, Entity *sgRoot)
     m_defaultTechniqueHandle = nodeManagers()->lookupHandle<Technique, TechniqueManager, HTechnique>(m_defaultTechnique->id());
     m_defaultRenderPassHandle = nodeManagers()->lookupHandle<RenderPass, RenderPassManager, HRenderPass>(m_defaultTechnique->renderPasses().constFirst()->id());
     m_defaultRenderShader = nodeManagers()->lookupResource<Shader, ShaderManager>(m_defaultTechnique->renderPasses().constFirst()->shaderProgram()->id());
+
+    // Set the scene root on the jobs
+    m_framePreparationJob->setRoot(m_renderSceneRoot);
+    m_worldTransformJob->setRoot(m_renderSceneRoot);
+    m_updateBoundingVolumeJob->setRoot(m_renderSceneRoot);
+    m_calculateBoundingVolumeJob->setRoot(m_renderSceneRoot);
+    m_cleanupJob->setRoot(m_renderSceneRoot);
+    m_pickBoundingVolumeJob->setRoot(m_renderSceneRoot);
 }
 
 void Renderer::registerEventFilter(QEventFilterService *service)
@@ -849,31 +882,47 @@ void Renderer::skipNextFrame()
 
 // Waits to be told to create jobs for the next frame
 // Called by QRenderAspect jobsToExecute context of QAspectThread
+// Returns all the jobs (and with proper dependency chain) required
+// for the rendering of the scene
 QVector<Qt3DCore::QAspectJobPtr> Renderer::renderBinJobs()
 {
     QVector<QAspectJobPtr> renderBinJobs;
 
+    // Create the jobs to build the frame
+    const QVector<QAspectJobPtr> bufferJobs = createRenderBufferJobs();
+
+    // Remove previous dependencies
+    m_calculateBoundingVolumeJob->removeDependency(QWeakPointer<QAspectJob>());
+    m_cleanupJob->removeDependency(QWeakPointer<QAspectJob>());
+
+    // Set dependencies
+    for (const QAspectJobPtr &bufferJob : bufferJobs)
+        m_calculateBoundingVolumeJob->addDependency(bufferJob);
+
+    // Add jobs
+    renderBinJobs.push_back(m_framePreparationJob);
+    renderBinJobs.push_back(m_updateBoundingVolumeJob);
+    renderBinJobs.push_back(m_calculateBoundingVolumeJob);
+    renderBinJobs.push_back(m_worldTransformJob);
+    renderBinJobs.push_back(m_cleanupJob);
+    renderBinJobs.append(bufferJobs);
+
     // Traverse the current framegraph. For each leaf node create a
     // RenderView and set its configuration then create a job to
     // populate the RenderView with a set of RenderCommands that get
     // their details from the RenderNodes that are visible to the
     // Camera selected by the framegraph configuration
-
     FrameGraphVisitor visitor(this, m_nodesManager->frameGraphManager());
     visitor.traverse(frameGraphRoot(), &renderBinJobs);
 
     // Set target number of RenderViews
     m_renderQueue->setTargetRenderViewCount(visitor.leafNodeCount());
+
     return renderBinJobs;
 }
 
 QAspectJobPtr Renderer::pickBoundingVolumeJob()
 {
-    // Clear any previous dependency not valid anymore
-    if (!m_pickBoundingVolumeJob)
-        m_pickBoundingVolumeJob.reset(new PickBoundingVolumeJob(this));
-    m_pickBoundingVolumeJob->removeDependency(QWeakPointer<QAspectJob>());
-    m_pickBoundingVolumeJob->setRoot(m_renderSceneRoot);
     return m_pickBoundingVolumeJob;
 }
 
@@ -1171,6 +1220,27 @@ const GraphicsApiFilterData *Renderer::contextInfo() const
     return m_graphicsContext->contextInfo();
 }
 
+// Returns a vector of jobs to be performed for dirty buffers
+// 1 dirty buffer == 1 job, all job can be performed in parallel
+QVector<Qt3DCore::QAspectJobPtr> Renderer::createRenderBufferJobs() const
+{
+    const QVector<QNodeId> dirtyBuffers = m_nodesManager->bufferManager()->dirtyBuffers();
+    QVector<QAspectJobPtr> dirtyBuffersJobs;
+    dirtyBuffersJobs.reserve(dirtyBuffers.size());
+
+    for (const QNodeId bufId : dirtyBuffers) {
+        Render::HBuffer bufferHandle = m_nodesManager->lookupHandle<Render::Buffer, Render::BufferManager, Render::HBuffer>(bufId);
+        if (!bufferHandle.isNull()) {
+            // Create new buffer job
+            auto job = Render::LoadBufferJobPtr::create(bufferHandle);
+            job->setNodeManager(m_nodesManager);
+            dirtyBuffersJobs.push_back(job);
+        }
+    }
+
+    return dirtyBuffersJobs;
+}
+
 } // namespace Render
 } // namespace Qt3DRender
 
diff --git a/src/render/backend/renderer_p.h b/src/render/backend/renderer_p.h
index cb0383d7d..56638ce65 100644
--- a/src/render/backend/renderer_p.h
+++ b/src/render/backend/renderer_p.h
@@ -62,6 +62,12 @@
 #include <Qt3DRender/private/pickboundingvolumejob_p.h>
 #include <Qt3DRender/private/rendersettings_p.h>
 #include <Qt3DRender/private/renderviewinitializerjob_p.h>
+#include <Qt3DRender/private/updateboundingvolumejob_p.h>
+#include <Qt3DRender/private/updateworldtransformjob_p.h>
+#include <Qt3DRender/private/calcboundingvolumejob_p.h>
+#include <Qt3DRender/private/framepreparationjob_p.h>
+#include <Qt3DRender/private/framecleanupjob_p.h>
+#include <Qt3DRender/private/platformsurfacefilter_p.h>
 
 #include <QHash>
 #include <QMatrix4x4>
@@ -131,7 +137,7 @@ public:
     qint64 time() const Q_DECL_OVERRIDE;
     void setTime(qint64 time) Q_DECL_OVERRIDE;
 
-    void setNodeManagers(NodeManagers *managers) Q_DECL_OVERRIDE { m_nodesManager = managers; }
+    void setNodeManagers(NodeManagers *managers) Q_DECL_OVERRIDE;
     void setServices(Qt3DCore::QServiceLocator *services) Q_DECL_OVERRIDE { m_services = services; }
     void setSurfaceExposed(bool exposed) Q_DECL_OVERRIDE;
 
@@ -164,6 +170,13 @@ public:
 
     QVector<Qt3DCore::QAspectJobPtr> renderBinJobs() Q_DECL_OVERRIDE;
     Qt3DCore::QAspectJobPtr pickBoundingVolumeJob() Q_DECL_OVERRIDE;
+    QVector<Qt3DCore::QAspectJobPtr> createRenderBufferJobs() const;
+
+    inline FrameCleanupJobPtr frameCleanupJob() const { return m_cleanupJob; }
+    inline UpdateBoundingVolumeJobPtr updateBoundingVolumeJob() const { return m_updateBoundingVolumeJob; }
+    inline FramePreparationJobPtr framePreparationJob() const { return m_framePreparationJob; }
+    inline CalculateBoundingVolumeJobPtr calculateBoundingVolumeJob() const { return m_calculateBoundingVolumeJob; }
+    inline UpdateWorldTransformJobPtr updateWorldTransformJob() const { return m_worldTransformJob; }
 
     Qt3DCore::QAbstractFrameAdvanceService *frameAdvanceService() const Q_DECL_OVERRIDE;
 
@@ -280,6 +293,12 @@ private:
 
     RenderSettings *m_settings;
 
+    FramePreparationJobPtr m_framePreparationJob;
+    FrameCleanupJobPtr m_cleanupJob;
+    UpdateWorldTransformJobPtr m_worldTransformJob;
+    UpdateBoundingVolumeJobPtr m_updateBoundingVolumeJob;
+    CalculateBoundingVolumeJobPtr m_calculateBoundingVolumeJob;
+
     void performDraw(GeometryRenderer *rGeometryRenderer,
                      GLsizei primitiveCount, Attribute *indexAttribute);
     void performCompute(const RenderView *rv, RenderCommand *command);
diff --git a/src/render/framegraph/framegraphvisitor.cpp b/src/render/framegraph/framegraphvisitor.cpp
index 2fedacc22..e31268c2b 100644
--- a/src/render/framegraph/framegraphvisitor.cpp
+++ b/src/render/framegraph/framegraphvisitor.cpp
@@ -289,6 +289,7 @@ void FrameGraphVisitor::visit(Render::FrameGraphNode *node)
         auto syncRenderViewCommandBuildersJob = GenericLambdaJobPtr<decltype(syncRenderViewCommandBuilders)>::create(syncRenderViewCommandBuilders);
 
         // Set dependencies
+        renderViewJob->addDependency(renderer->updateBoundingVolumeJob());
         syncRenderViewInitializationJob->addDependency(renderViewJob);
 
         filterEntityByLayer->addDependency(syncRenderViewInitializationJob);
@@ -308,6 +309,7 @@ void FrameGraphVisitor::visit(Render::FrameGraphNode *node)
             renderViewCommandBuilder->addDependency(syncRenderViewCommandBuildingJob);
             syncRenderViewCommandBuildersJob->addDependency(renderViewCommandBuilder);
         }
+        renderer->frameCleanupJob()->addDependency(syncRenderViewCommandBuildersJob);
 
         // Add jobs
         m_jobs->push_back(renderViewJob);
diff --git a/src/render/frontend/qrenderaspect.cpp b/src/render/frontend/qrenderaspect.cpp
index cf054b2c5..02ebd5a26 100644
--- a/src/render/frontend/qrenderaspect.cpp
+++ b/src/render/frontend/qrenderaspect.cpp
@@ -111,7 +111,6 @@
 #include <Qt3DRender/private/handle_types_p.h>
 #include <Qt3DRender/private/buffermanager_p.h>
 #include <Qt3DRender/private/geometryrenderermanager_p.h>
-#include <Qt3DRender/private/loadbufferjob_p.h>
 #include <Qt3DRender/private/loadgeometryjob_p.h>
 #include <Qt3DRender/private/qsceneiofactory_p.h>
 #include <Qt3DRender/private/frustumculling_p.h>
@@ -157,25 +156,12 @@ QRenderAspectPrivate::QRenderAspectPrivate(QRenderAspect::RenderType type)
     , m_nodeManagers(new Render::NodeManagers())
     , m_renderer(nullptr)
     , m_initialized(false)
-    , m_framePreparationJob(Render::FramePreparationJobPtr::create(m_nodeManagers))
-    , m_cleanupJob(Render::FrameCleanupJobPtr::create(m_nodeManagers))
-    , m_worldTransformJob(Render::UpdateWorldTransformJobPtr::create())
-    , m_updateBoundingVolumeJob(Render::UpdateBoundingVolumeJobPtr::create())
-    , m_calculateBoundingVolumeJob(Render::CalculateBoundingVolumeJobPtr::create(m_nodeManagers))
     , m_renderType(type)
 {
     initResources();
 
     // Load the scene parsers
     loadSceneParsers();
-
-    // Create jobs to update transforms and bounding volumes
-    // We can only update bounding volumes once all world transforms are known
-    m_updateBoundingVolumeJob->addDependency(m_worldTransformJob);
-    m_framePreparationJob->addDependency(m_worldTransformJob);
-
-    // All world stuff depends on the RenderEntity's localBoundingVolume
-    m_worldTransformJob->addDependency(m_calculateBoundingVolumeJob);
 }
 
 /*! \internal */
@@ -385,14 +371,6 @@ QVector<Qt3DCore::QAspectJobPtr> QRenderAspect::jobsToExecute(qint64 time)
         }
 
         Render::NodeManagers *manager = d->m_renderer->nodeManagers();
-        QAspectJobPtr pickBoundingVolumeJob = d->m_renderer->pickBoundingVolumeJob();
-
-        // Create the jobs to build the frame
-        d->m_framePreparationJob->setRoot(d->m_renderer->sceneRoot());
-        d->m_worldTransformJob->setRoot(d->m_renderer->sceneRoot());
-        d->m_updateBoundingVolumeJob->setRoot(d->m_renderer->sceneRoot());
-        d->m_calculateBoundingVolumeJob->setRoot(d->m_renderer->sceneRoot());
-        d->m_cleanupJob->setRoot(d->m_renderer->sceneRoot());
 
         const QVector<QNodeId> texturesPending = std::move(manager->textureDataManager()->texturesPending());
         for (const QNodeId textureId : texturesPending) {
@@ -400,6 +378,7 @@ QVector<Qt3DCore::QAspectJobPtr> QRenderAspect::jobsToExecute(qint64 time)
             loadTextureJob->setNodeManagers(manager);
             jobs.append(loadTextureJob);
         }
+
         // TO DO: Have 2 jobs queue
         // One for urgent jobs that are mandatory for the rendering of a frame
         // Another for jobs that can span across multiple frames (Scene/Mesh loading)
@@ -410,45 +389,20 @@ QVector<Qt3DCore::QAspectJobPtr> QRenderAspect::jobsToExecute(qint64 time)
             jobs.append(job);
         }
 
-        // Clear any previous temporary dependency
-        d->m_calculateBoundingVolumeJob->removeDependency(QWeakPointer<QAspectJob>());
-        const QVector<QAspectJobPtr> bufferJobs = d->createRenderBufferJobs();
-        for (const QAspectJobPtr &bufferJob : bufferJobs)
-            d->m_calculateBoundingVolumeJob->addDependency(bufferJob);
-        jobs.append(bufferJobs);
-
         const QVector<QAspectJobPtr> geometryJobs = d->createGeometryRendererJobs();
         jobs.append(geometryJobs);
 
-        // Only add dependency if not already present
-        const QVector<QWeakPointer<QAspectJob> > dependencies = pickBoundingVolumeJob->dependencies();
-        if (std::find(dependencies.begin(), dependencies.end(), d->m_framePreparationJob) == dependencies.end())
-            pickBoundingVolumeJob->addDependency(d->m_framePreparationJob);
 
         // Add all jobs to queue
-        jobs.append(d->m_calculateBoundingVolumeJob);
-        jobs.append(d->m_worldTransformJob);
-        jobs.append(d->m_updateBoundingVolumeJob);
-        jobs.append(d->m_framePreparationJob);
+        const Qt3DCore::QAspectJobPtr pickBoundingVolumeJob = d->m_renderer->pickBoundingVolumeJob();
         jobs.append(pickBoundingVolumeJob);
 
-        // Clear any old dependencies from previous frames
-        d->m_cleanupJob->removeDependency(QWeakPointer<QAspectJob>());
-
-        // Note: We need the RenderBinJobs to set the surface
-        // so we must create the RenderViews in all cases
-
         // Traverse the current framegraph and create jobs to populate
         // RenderBins with RenderCommands
-        QVector<QAspectJobPtr> renderBinJobs = d->m_renderer->renderBinJobs();
-        for (int i = 0; i < renderBinJobs.size(); ++i) {
-            QAspectJobPtr renderBinJob = renderBinJobs.at(i);
-            renderBinJob->addDependency(d->m_updateBoundingVolumeJob);
-            jobs.append(renderBinJob);
-            d->m_cleanupJob->addDependency(renderBinJob);
-        }
-
-        jobs.append(d->m_cleanupJob);
+        // All jobs needed to create the frame and their dependencies are set by
+        // renderBinJobs()
+        const QVector<QAspectJobPtr> renderBinJobs = d->m_renderer->renderBinJobs();
+        jobs.append(renderBinJobs);
     }
     return jobs;
 }
@@ -514,31 +468,12 @@ void QRenderAspect::onUnregistered()
     d->m_renderer = nullptr;
 }
 
-// Returns a vector of jobs to be performed for dirty buffers
-// 1 dirty buffer == 1 job, all job can be performed in parallel
-QVector<Qt3DCore::QAspectJobPtr> QRenderAspectPrivate::createRenderBufferJobs()
-{
-    const QVector<QNodeId> dirtyBuffers = m_nodeManagers->bufferManager()->dirtyBuffers();
-    QVector<QAspectJobPtr> dirtyBuffersJobs;
-
-    for (const QNodeId bufId : dirtyBuffers) {
-        Render::HBuffer bufferHandle = m_nodeManagers->lookupHandle<Render::Buffer, Render::BufferManager, Render::HBuffer>(bufId);
-        if (!bufferHandle.isNull()) {
-            // Create new buffer job
-            auto job = Render::LoadBufferJobPtr::create(bufferHandle);
-            job->setNodeManager(m_nodeManagers);
-            dirtyBuffersJobs.push_back(job);
-        }
-    }
-
-    return dirtyBuffersJobs;
-}
-
 QVector<Qt3DCore::QAspectJobPtr> QRenderAspectPrivate::createGeometryRendererJobs()
 {
     Render::GeometryRendererManager *geomRendererManager = m_nodeManagers->geometryRendererManager();
     const QVector<QNodeId> dirtyGeometryRenderers = geomRendererManager->dirtyGeometryRenderers();
     QVector<QAspectJobPtr> dirtyGeometryRendererJobs;
+    dirtyGeometryRendererJobs.reserve(dirtyGeometryRenderers.size());
 
     for (const QNodeId geoRendererId : dirtyGeometryRenderers) {
         Render::HGeometryRenderer geometryRendererHandle = geomRendererManager->lookupHandle(geoRendererId);
diff --git a/src/render/frontend/qrenderaspect_p.h b/src/render/frontend/qrenderaspect_p.h
index a71b982c8..f196c2ec2 100644
--- a/src/render/frontend/qrenderaspect_p.h
+++ b/src/render/frontend/qrenderaspect_p.h
@@ -51,14 +51,9 @@
 // We mean it.
 //
 
-#include <Qt3DCore/private/qabstractaspect_p.h>
 #include <Qt3DRender/qrenderaspect.h>
-#include <Qt3DRender/private/updateboundingvolumejob_p.h>
-#include <Qt3DRender/private/updateworldtransformjob_p.h>
-#include <Qt3DRender/private/calcboundingvolumejob_p.h>
-#include <Qt3DRender/private/framepreparationjob_p.h>
-#include <Qt3DRender/private/framecleanupjob_p.h>
-#include <Qt3DRender/private/platformsurfacefilter_p.h>
+#include <Qt3DCore/private/qabstractaspect_p.h>
+#include <Qt3DRender/private/qt3drender_global_p.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -86,18 +81,12 @@ public:
     void renderInitialize(QOpenGLContext *context);
     void renderSynchronous();
     void renderShutdown();
-    QVector<Qt3DCore::QAspectJobPtr> createRenderBufferJobs();
     QVector<Qt3DCore::QAspectJobPtr> createGeometryRendererJobs();
 
     Render::NodeManagers *m_nodeManagers;
     Render::AbstractRenderer *m_renderer;
 
     bool m_initialized;
-    Render::FramePreparationJobPtr m_framePreparationJob;
-    Render::FrameCleanupJobPtr m_cleanupJob;
-    Render::UpdateWorldTransformJobPtr m_worldTransformJob;
-    Render::UpdateBoundingVolumeJobPtr m_updateBoundingVolumeJob;
-    Render::CalculateBoundingVolumeJobPtr m_calculateBoundingVolumeJob;
     QList<QSceneIOHandler *> m_sceneIOHandler;
     QRenderAspect::RenderType m_renderType;
 };
diff --git a/src/render/jobs/calcboundingvolumejob.cpp b/src/render/jobs/calcboundingvolumejob.cpp
index 5c57eb432..3612650d0 100644
--- a/src/render/jobs/calcboundingvolumejob.cpp
+++ b/src/render/jobs/calcboundingvolumejob.cpp
@@ -160,9 +160,9 @@ void calculateLocalBoundingVolume(NodeManagers *manager, Entity *node)
 
 } // anonymous
 
-CalculateBoundingVolumeJob::CalculateBoundingVolumeJob(NodeManagers *manager)
-    : m_manager(manager),
-      m_node(nullptr)
+CalculateBoundingVolumeJob::CalculateBoundingVolumeJob()
+    : m_manager(nullptr)
+    , m_node(nullptr)
 {
     SET_JOB_RUN_STAT_TYPE(this, JobTypes::CalcBoundingVolume, 0);
 }
@@ -177,6 +177,11 @@ void CalculateBoundingVolumeJob::setRoot(Entity *node)
     m_node = node;
 }
 
+void CalculateBoundingVolumeJob::setManagers(NodeManagers *manager)
+{
+    m_manager = manager;
+}
+
 } // namespace Render
 } // namespace Qt3DRender
 
diff --git a/src/render/jobs/calcboundingvolumejob_p.h b/src/render/jobs/calcboundingvolumejob_p.h
index 9a51bf5cf..c507f7f2d 100644
--- a/src/render/jobs/calcboundingvolumejob_p.h
+++ b/src/render/jobs/calcboundingvolumejob_p.h
@@ -68,9 +68,10 @@ class Entity;
 class QT3DRENDERSHARED_PRIVATE_EXPORT CalculateBoundingVolumeJob : public Qt3DCore::QAspectJob
 {
 public:
-    explicit CalculateBoundingVolumeJob(NodeManagers *manager);
+    explicit CalculateBoundingVolumeJob();
 
     void setRoot(Entity *node);
+    void setManagers(NodeManagers *manager);
 
 protected:
     void run() Q_DECL_OVERRIDE;
diff --git a/src/render/jobs/framecleanupjob.cpp b/src/render/jobs/framecleanupjob.cpp
index 7022660c4..ab3a18223 100644
--- a/src/render/jobs/framecleanupjob.cpp
+++ b/src/render/jobs/framecleanupjob.cpp
@@ -52,8 +52,8 @@ QT_BEGIN_NAMESPACE
 namespace Qt3DRender {
 namespace Render {
 
-FrameCleanupJob::FrameCleanupJob(NodeManagers *managers)
-    : m_managers(managers)
+FrameCleanupJob::FrameCleanupJob()
+    : m_managers(nullptr)
     , m_root(nullptr)
 {
     SET_JOB_RUN_STAT_TYPE(this, JobTypes::FrameCleanup, 0);
@@ -102,6 +102,11 @@ void FrameCleanupJob::updateBoundingVolumesDebug(Entity *node)
         updateBoundingVolumesDebug(c);
 }
 
+void FrameCleanupJob::setManagers(NodeManagers *managers)
+{
+    m_managers = managers;
+}
+
 } // namespace Render
 } // namespace Qt3DRender
 
diff --git a/src/render/jobs/framecleanupjob_p.h b/src/render/jobs/framecleanupjob_p.h
index d1a4d19f3..bf5849f5a 100644
--- a/src/render/jobs/framecleanupjob_p.h
+++ b/src/render/jobs/framecleanupjob_p.h
@@ -67,10 +67,11 @@ class Entity;
 class QT3DRENDERSHARED_PRIVATE_EXPORT FrameCleanupJob : public Qt3DCore::QAspectJob
 {
 public:
-    explicit FrameCleanupJob(NodeManagers *managers);
+    explicit FrameCleanupJob();
     ~FrameCleanupJob();
 
     void setRoot(Entity *root);
+    void setManagers(NodeManagers *managers);
 
 protected:
     void run() Q_DECL_FINAL;
diff --git a/src/render/jobs/framepreparationjob.cpp b/src/render/jobs/framepreparationjob.cpp
index ec5d4d552..ef5b4bdb4 100644
--- a/src/render/jobs/framepreparationjob.cpp
+++ b/src/render/jobs/framepreparationjob.cpp
@@ -58,9 +58,9 @@ QT_BEGIN_NAMESPACE
 namespace Qt3DRender {
 namespace Render {
 
-FramePreparationJob::FramePreparationJob(NodeManagers *manager)
+FramePreparationJob::FramePreparationJob()
     : m_root(nullptr)
-    , m_manager(manager)
+    , m_manager(nullptr)
 {
     SET_JOB_RUN_STAT_TYPE(this, JobTypes::FramePreparation, 0);
 }
@@ -74,6 +74,11 @@ void FramePreparationJob::setRoot(Entity *root)
     m_root = root;
 }
 
+void FramePreparationJob::setManagers(NodeManagers *manager)
+{
+    m_manager = manager;
+}
+
 void FramePreparationJob::run()
 {
     parseNodeTree(m_root);
diff --git a/src/render/jobs/framepreparationjob_p.h b/src/render/jobs/framepreparationjob_p.h
index e9eab6a52..35db5862d 100644
--- a/src/render/jobs/framepreparationjob_p.h
+++ b/src/render/jobs/framepreparationjob_p.h
@@ -66,10 +66,11 @@ class Entity;
 class QT3DRENDERSHARED_PRIVATE_EXPORT FramePreparationJob : public Qt3DCore::QAspectJob
 {
 public:
-    FramePreparationJob(NodeManagers *manager);
+    FramePreparationJob();
     ~FramePreparationJob();
 
     void setRoot(Entity *root);
+    void setManagers(NodeManagers *manager);
 
 protected:
     void run() Q_DECL_FINAL;
diff --git a/src/render/jobs/pickboundingvolumejob.cpp b/src/render/jobs/pickboundingvolumejob.cpp
index b095fd4d4..2ec87f3c3 100644
--- a/src/render/jobs/pickboundingvolumejob.cpp
+++ b/src/render/jobs/pickboundingvolumejob.cpp
@@ -324,7 +324,7 @@ CollisionVisitor::HitList reduceToAllHits(CollisionVisitor::HitList &results, co
 
 PickBoundingVolumeJob::PickBoundingVolumeJob(Renderer *renderer)
     : m_renderer(renderer)
-    , m_manager(renderer->nodeManagers())
+    , m_manager(nullptr)
     , m_node(nullptr)
 {
     SET_JOB_RUN_STAT_TYPE(this, JobTypes::PickBoundingVolume, 0);
@@ -347,6 +347,11 @@ QRay3D PickBoundingVolumeJob::intersectionRay(const QPoint &pos, const QMatrix4x
                   (farPos - nearPos).length());
 }
 
+void PickBoundingVolumeJob::setManagers(NodeManagers *manager)
+{
+    m_manager = manager;
+}
+
 void PickBoundingVolumeJob::run()
 {
     const auto mouseEvents = m_renderer->pendingPickingEvents();
diff --git a/src/render/jobs/pickboundingvolumejob_p.h b/src/render/jobs/pickboundingvolumejob_p.h
index 9071b44c7..1baa67fee 100644
--- a/src/render/jobs/pickboundingvolumejob_p.h
+++ b/src/render/jobs/pickboundingvolumejob_p.h
@@ -86,6 +86,7 @@ public:
                                   const QMatrix4x4 &viewMatrix,
                                   const QMatrix4x4 &projectionMatrix,
                                   const QRect &viewport);
+    void setManagers(NodeManagers *manager);
 protected:
     void run() Q_DECL_FINAL;