Renderer: use NodeManagers

Change-Id: I8d505034b24c3ec00b93ace02e5a4fe450939478
Reviewed-by: Andy Nichols <andy.nichols@theqtcompany.com>

14 files changed, 80 insertions, 68 deletions

diff --git a/src/render/jobs/calcboundingvolumejob.cpp b/src/render/jobs/calcboundingvolumejob.cpp
index ca91ac547..b0a30210e 100644
--- a/src/render/jobs/calcboundingvolumejob.cpp
+++ b/src/render/jobs/calcboundingvolumejob.cpp
@@ -37,7 +37,7 @@
 
 #include "calcboundingvolumejob_p.h"
 
-#include <Qt3DRender/private/renderer_p.h>
+#include <Qt3DRender/private/nodemanagers_p.h>
 #include <Qt3DRender/private/entity_p.h>
 #include <Qt3DRender/private/renderlogging_p.h>
 #include <Qt3DRender/private/managers_p.h>
@@ -58,7 +58,7 @@ namespace Render {
 
 namespace {
 
-void calculateLocalBoundingVolume(Renderer *renderer, Entity *node)
+void calculateLocalBoundingVolume(NodeManagers *manager, Entity *node)
 {
     // TO DO: How do we set the object picker to dirty when the buffer
     // referenced by the pickVolumeAttribute changes or has its internal buffer
@@ -66,18 +66,18 @@ void calculateLocalBoundingVolume(Renderer *renderer, Entity *node)
 
     GeometryRenderer *gRenderer = node->renderComponent<GeometryRenderer>();
     if (gRenderer) {
-        Geometry *geom = renderer->geometryManager()->lookupResource(gRenderer->geometryId());
+        Geometry *geom = manager->lookupResource<Geometry, GeometryManager>(gRenderer->geometryId());
 
         // TO DO: We must not recompute this every frame
         // Find a way to detect that the bounding volume attribute or its buffer have changed
 
         if (geom) {
-            Qt3DRender::Render::Attribute *pickVolumeAttribute = renderer->attributeManager()->lookupResource(geom->boundingPositionAttribute());
+            Qt3DRender::Render::Attribute *pickVolumeAttribute = manager->lookupResource<Attribute, AttributeManager>(geom->boundingPositionAttribute());
 
             // Use the default position attribute if attribute is null
             if (!pickVolumeAttribute) {
                 Q_FOREACH (const Qt3DCore::QNodeId attrId, geom->attributes()) {
-                    pickVolumeAttribute = renderer->attributeManager()->lookupResource(attrId);
+                    pickVolumeAttribute = manager->lookupResource<Attribute, AttributeManager>(attrId);
                     if (pickVolumeAttribute &&
                             pickVolumeAttribute->name() == QAttribute::defaultPositionAttributeName())
                         break;
@@ -93,7 +93,7 @@ void calculateLocalBoundingVolume(Renderer *renderer, Entity *node)
                     return;
                 }
 
-                Buffer *buf = renderer->bufferManager()->lookupResource(pickVolumeAttribute->bufferId());
+                Buffer *buf = manager->lookupResource<Buffer, BufferManager>(pickVolumeAttribute->bufferId());
                 // No point in continuing if the positionAttribute doesn't have a suitable buffer
                 if (!buf) {
                     qWarning() << "ObjectPicker pickVolume Attribute not referencing a valid buffer";
@@ -121,20 +121,20 @@ void calculateLocalBoundingVolume(Renderer *renderer, Entity *node)
     }
 
     Q_FOREACH (Entity *child, node->children())
-        calculateLocalBoundingVolume(renderer, child);
+        calculateLocalBoundingVolume(manager, child);
 }
 
 } // anonymous
 
-CalculateBoundingVolumeJob::CalculateBoundingVolumeJob(Renderer *renderer)
-    : m_renderer(renderer),
+CalculateBoundingVolumeJob::CalculateBoundingVolumeJob(NodeManagers *manager)
+    : m_manager(manager),
       m_node(Q_NULLPTR)
 {
 }
 
 void CalculateBoundingVolumeJob::run()
 {
-    calculateLocalBoundingVolume(m_renderer, m_node);
+    calculateLocalBoundingVolume(m_manager, m_node);
 }
 
 void CalculateBoundingVolumeJob::setRoot(Entity *node)
diff --git a/src/render/jobs/calcboundingvolumejob_p.h b/src/render/jobs/calcboundingvolumejob_p.h
index f8317419c..02a9a5481 100644
--- a/src/render/jobs/calcboundingvolumejob_p.h
+++ b/src/render/jobs/calcboundingvolumejob_p.h
@@ -58,13 +58,13 @@ QT_BEGIN_NAMESPACE
 namespace Qt3DRender {
 namespace Render {
 
-class Renderer;
+class NodeManagers;
 class Entity;
 
-class CalculateBoundingVolumeJob : public Qt3DCore::QAspectJob
+class Q_AUTOTEST_EXPORT CalculateBoundingVolumeJob : public Qt3DCore::QAspectJob
 {
 public:
-    explicit CalculateBoundingVolumeJob(Renderer *renderer);
+    explicit CalculateBoundingVolumeJob(NodeManagers *manager);
 
     void setRoot(Entity *node);
 
@@ -72,7 +72,7 @@ protected:
     void run() Q_DECL_OVERRIDE;
 
 private:
-    Renderer *m_renderer;
+    NodeManagers *m_manager;
     Entity *m_node;
 };
 
diff --git a/src/render/jobs/framecleanupjob.cpp b/src/render/jobs/framecleanupjob.cpp
index 34ded2f81..715ad03e6 100644
--- a/src/render/jobs/framecleanupjob.cpp
+++ b/src/render/jobs/framecleanupjob.cpp
@@ -36,6 +36,7 @@
 
 #include "framecleanupjob_p.h"
 #include <private/renderer_p.h>
+#include <private/nodemanagers_p.h>
 #include <private/entity_p.h>
 #include <private/shaderdata_p.h>
 #include <private/managers_p.h>
@@ -60,14 +61,14 @@ void FrameCleanupJob::run()
 {
     // set each ShaderData to not need an update
     Q_FOREACH (const Qt3DCore::QNodeId &id, ShaderData::updatedShaderDataList()) {
-        ShaderData *shaderData = m_renderer->shaderDataManager()->lookupResource(id);
+        ShaderData *shaderData = m_renderer->nodeManagers()->shaderDataManager()->lookupResource(id);
         if (shaderData != Q_NULLPTR)
             shaderData->clearUpdate();
     }
     ShaderData::clearShaderDataList();
 
     // Cleanup texture handles
-    TextureDataManager *textureDataManager = m_renderer->textureDataManager();
+    TextureDataManager *textureDataManager = m_renderer->nodeManagers()->textureDataManager();
     textureDataManager->cleanup();
 
     // Debug bounding volume debug
diff --git a/src/render/jobs/loadbufferjob.cpp b/src/render/jobs/loadbufferjob.cpp
index 64b0dad3d..8a7bbdc1e 100644
--- a/src/render/jobs/loadbufferjob.cpp
+++ b/src/render/jobs/loadbufferjob.cpp
@@ -49,7 +49,7 @@ namespace Render {
 LoadBufferJob::LoadBufferJob(const HBuffer &handle)
     : QAspectJob()
     , m_handle(handle)
-    , m_renderer(Q_NULLPTR)
+    , m_nodeManagers(Q_NULLPTR)
 {
 }
 
@@ -61,7 +61,7 @@ void LoadBufferJob::run()
 {
     // Let's leave it for the moment until this has been properly tested
     qDebug() << Q_FUNC_INFO;
-    Buffer *buffer = m_renderer->bufferManager()->data(m_handle);
+    Buffer *buffer = m_nodeManagers->data<Buffer, BufferManager>(m_handle);
     buffer->executeFunctor();
 }
 
diff --git a/src/render/jobs/loadbufferjob_p.h b/src/render/jobs/loadbufferjob_p.h
index ce7e31eba..34ee5f552 100644
--- a/src/render/jobs/loadbufferjob_p.h
+++ b/src/render/jobs/loadbufferjob_p.h
@@ -51,6 +51,7 @@
 #include <QSharedPointer>
 #include <Qt3DCore/qaspectjob.h>
 #include <Qt3DRender/private/handle_types_p.h>
+#include <Qt3DRender/private/nodemanagers_p.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -58,7 +59,7 @@ namespace Qt3DRender {
 
 namespace Render {
 
-class Renderer;
+class NodeManagers;
 
 class LoadBufferJob : public Qt3DCore::QAspectJob
 {
@@ -66,12 +67,12 @@ public:
     explicit LoadBufferJob(const HBuffer &handle);
     ~LoadBufferJob();
 
-    void setRenderer(Renderer *renderer) { m_renderer = renderer; }
+    void setNodeManager(NodeManagers *nodeManagers) { m_nodeManagers = nodeManagers; }
 
 protected:
     void run() Q_DECL_OVERRIDE;
     HBuffer m_handle;
-    Renderer *m_renderer;
+    NodeManagers *m_nodeManagers;
 };
 
 typedef QSharedPointer<LoadBufferJob> LoadBufferJobPtr;
diff --git a/src/render/jobs/loadgeometryjob.cpp b/src/render/jobs/loadgeometryjob.cpp
index 11dc2b3f3..2a11b08e0 100644
--- a/src/render/jobs/loadgeometryjob.cpp
+++ b/src/render/jobs/loadgeometryjob.cpp
@@ -35,7 +35,7 @@
 ****************************************************************************/
 
 #include "loadgeometryjob_p.h"
-#include <Qt3DRender/private/renderer_p.h>
+#include <Qt3DRender/private/nodemanagers_p.h>
 #include <Qt3DRender/private/geometryrenderermanager_p.h>
 
 QT_BEGIN_NAMESPACE
@@ -56,7 +56,7 @@ LoadGeometryJob::~LoadGeometryJob()
 
 void LoadGeometryJob::run()
 {
-    GeometryRenderer *geometryRenderer = m_renderer->geometryRendererManager()->data(m_handle);
+    GeometryRenderer *geometryRenderer = m_nodeManagers->geometryRendererManager()->data(m_handle);
     if (geometryRenderer != Q_NULLPTR)
         geometryRenderer->executeFunctor();
 }
diff --git a/src/render/jobs/loadgeometryjob_p.h b/src/render/jobs/loadgeometryjob_p.h
index 1ae5f4f8d..f94ae7284 100644
--- a/src/render/jobs/loadgeometryjob_p.h
+++ b/src/render/jobs/loadgeometryjob_p.h
@@ -58,7 +58,7 @@ namespace Qt3DRender {
 
 namespace Render {
 
-class Renderer;
+class NodeManagers;
 
 class LoadGeometryJob : public Qt3DCore::QAspectJob
 {
@@ -66,12 +66,12 @@ public:
     explicit LoadGeometryJob(const HGeometryRenderer &handle);
     ~LoadGeometryJob();
 
-    void setRenderer(Renderer *renderer) { m_renderer = renderer; }
+    void setNodeManagers(NodeManagers *nodeManagers) { m_nodeManagers = nodeManagers; }
 
 protected:
     void run() Q_DECL_OVERRIDE;
     HGeometryRenderer m_handle;
-    Renderer *m_renderer;
+    NodeManagers *m_nodeManagers;
 };
 
 typedef QSharedPointer<LoadGeometryJob> LoadGeometryJobPtr;
diff --git a/src/render/jobs/loadscenejob.cpp b/src/render/jobs/loadscenejob.cpp
index 10358c3b9..4eb857775 100644
--- a/src/render/jobs/loadscenejob.cpp
+++ b/src/render/jobs/loadscenejob.cpp
@@ -36,6 +36,7 @@
 
 #include "loadscenejob_p.h"
 #include <private/renderer_p.h>
+#include <private/nodemanagers_p.h>
 #include <private/scenemanager_p.h>
 #include <Qt3DCore/qentity.h>
 #include <Qt3DRender/qabstractsceneparser.h>
@@ -55,18 +56,18 @@ LoadSceneJob::LoadSceneJob(const QUrl &source, const Qt3DCore::QNodeId &m_sceneC
 
 void LoadSceneJob::run()
 {
-    Qt3DCore::QEntity *sceneTree = m_renderer->sceneManager()->sceneTreeFromSource(m_source);
+    Qt3DCore::QEntity *sceneTree = m_renderer->nodeManagers()->sceneManager()->sceneTreeFromSource(m_source);
     if (sceneTree == Q_NULLPTR) {
         Q_FOREACH (QAbstractSceneParser *parser, m_renderer->sceneParsers()) {
             if (parser->isExtensionSupported(m_source)) {
                 parser->setSource(m_source);
                 sceneTree = parser->scene();
-                m_renderer->sceneManager()->addLoadedSceneTree(m_source, sceneTree);
+                m_renderer->nodeManagers()->sceneManager()->addLoadedSceneTree(m_source, sceneTree);
             }
         }
     }
     // set clone of sceneTree in sceneComponent
-    Scene *scene = m_renderer->sceneManager()->lookupResource(m_sceneComponent);
+    Scene *scene = m_renderer->nodeManagers()->sceneManager()->lookupResource(m_sceneComponent);
     scene->setSceneSubtree(sceneTree);
 }
 
diff --git a/src/render/jobs/loadtexturedatajob.cpp b/src/render/jobs/loadtexturedatajob.cpp
index 4b34690ef..5f4a9801b 100644
--- a/src/render/jobs/loadtexturedatajob.cpp
+++ b/src/render/jobs/loadtexturedatajob.cpp
@@ -35,9 +35,10 @@
 ****************************************************************************/
 
 #include "loadtexturedatajob_p.h"
-#include <Qt3DRender/private/renderer_p.h>
+#include <Qt3DRender/private/nodemanagers_p.h>
 #include <Qt3DRender/private/managers_p.h>
 #include <Qt3DRender/private/texturedatamanager_p.h>
+#include <Qt3DRender/qtexturedata.h>
 #include <QThread>
 
 QT_BEGIN_NAMESPACE
@@ -58,12 +59,13 @@ void LoadTextureDataJob::run()
 {
     qCDebug(Jobs) << "Entering" << Q_FUNC_INFO << QThread::currentThread();
 
-    Texture *txt = m_renderer->textureManager()->lookupResource(m_textureId);
+    Texture *txt = m_manager->textureManager()->lookupResource(m_textureId);
+    TextureDataManager *textureDataManager = m_manager->manager<QTexImageData, TextureDataManager>();
 
     if (txt != Q_NULLPTR) {
         // Load update each TextureImage
         Q_FOREACH (HTextureImage texImgHandle, txt->textureImages()) {
-            TextureImage *texImg = m_renderer->textureImageManager()->data(texImgHandle);
+            TextureImage *texImg = m_manager->textureImageManager()->data(texImgHandle);
             if (texImg != Q_NULLPTR && texImg->isDirty() && !texImg->dataFunctor().isNull()) {
                 QTextureDataFunctorPtr functor = texImg->dataFunctor();
                 HTextureData textureDataHandle;
@@ -71,29 +73,29 @@ void LoadTextureDataJob::run()
 
                 // scoped for locker
                 {
-                    QMutexLocker locker(m_renderer->textureDataManager()->mutex());
+                    QMutexLocker locker(textureDataManager->mutex());
                     // We don't want to take the chance of having two jobs uploading the same functor
                     // because of sync issues
-                    textureDataHandle = m_renderer->textureDataManager()->textureDataFromFunctor(functor);
+                    textureDataHandle = textureDataManager->textureDataFromFunctor(functor);
 
                     // Texture data handle isn't null == there's already a matching TextureData
                     if (!textureDataHandle.isNull()) {
-                        data = m_renderer->textureDataManager()->data(textureDataHandle);
+                        data = textureDataManager->data(textureDataHandle);
                     } else {
                         QTexImageDataPtr dataPtr = functor->operator ()();
                         if (dataPtr.isNull()) {
                             qCDebug(Jobs) << Q_FUNC_INFO << "Texture has no raw data";
                         } else {
                             // Save the QTexImageDataPtr with it's functor as a key
-                            textureDataHandle = m_renderer->textureDataManager()->acquire();
-                            data = m_renderer->textureDataManager()->data(textureDataHandle);
+                            textureDataHandle = textureDataManager->acquire();
+                            data = textureDataManager->data(textureDataHandle);
                             *data = *(dataPtr.data());
-                            m_renderer->textureDataManager()->addTextureDataForFunctor(textureDataHandle, functor);
+                            textureDataManager->addTextureDataForFunctor(textureDataHandle, functor);
                         }
                     }
 
                     // Update HTextureImage Functor to release TextureData when needed
-                    m_renderer->textureDataManager()->assignFunctorToTextureImage(functor, texImgHandle);
+                    textureDataManager->assignFunctorToTextureImage(functor, texImgHandle);
                 }
 
                 // Set texture size of texture if the first layer / level / face has a valid size
diff --git a/src/render/jobs/loadtexturedatajob_p.h b/src/render/jobs/loadtexturedatajob_p.h
index 9826181b1..0c1061390 100644
--- a/src/render/jobs/loadtexturedatajob_p.h
+++ b/src/render/jobs/loadtexturedatajob_p.h
@@ -58,21 +58,21 @@ namespace Qt3DRender {
 
 namespace Render {
 
-class Renderer;
+class NodeManagers;
 
 class LoadTextureDataJob : public Qt3DCore::QAspectJob
 {
 public:
     LoadTextureDataJob(const Qt3DCore::QNodeId &textureId);
     ~LoadTextureDataJob();
-    inline void setRenderer(Renderer *renderer) { m_renderer = renderer; }
+    inline void setNodeManagers(NodeManagers *manager) { m_manager = manager; }
 
 protected:
     void run() Q_DECL_FINAL;
 
 private:
     Qt3DCore::QNodeId m_textureId;
-    Renderer *m_renderer;
+    NodeManagers *m_manager;
 };
 
 typedef QSharedPointer<LoadTextureDataJob> LoadTextureDataJobPtr;
diff --git a/src/render/jobs/pickboundingvolumejob.cpp b/src/render/jobs/pickboundingvolumejob.cpp
index 2140d5cd3..f6c2acfff 100644
--- a/src/render/jobs/pickboundingvolumejob.cpp
+++ b/src/render/jobs/pickboundingvolumejob.cpp
@@ -36,6 +36,7 @@
 
 #include "pickboundingvolumejob_p.h"
 #include <Qt3DRender/private/renderer_p.h>
+#include <Qt3DRender/private/nodemanagers_p.h>
 #include <Qt3DRender/private/framegraphnode_p.h>
 #include <Qt3DRender/private/cameralens_p.h>
 #include <Qt3DRender/private/cameraselectornode_p.h>
@@ -123,6 +124,7 @@ public:
 
 PickBoundingVolumeJob::PickBoundingVolumeJob(Renderer *renderer)
     : m_renderer(renderer)
+    , m_manager(renderer->nodeManagers())
     , m_node(Q_NULLPTR)
 {
 }
@@ -173,7 +175,7 @@ void PickBoundingVolumeJob::run()
         if (!vcPairs.empty()) {
             Q_FOREACH (const QMouseEvent &event, m_mouseEvents) {
                 m_hoveredPickersToClear = m_hoveredPickers;
-                ObjectPicker *lastCurrentPicker = m_renderer->objectPickerManager()->data(m_currentPicker);
+                ObjectPicker *lastCurrentPicker = m_manager->objectPickerManager()->data(m_currentPicker);
                 Q_FOREACH (const ViewportCameraPair &vc, vcPairs) {
                     const QVector<Qt3DCore::QNodeId> hits = hitsForViewportAndCamera(event.pos(),
                                                                                      vc.viewport,
@@ -183,7 +185,7 @@ void PickBoundingVolumeJob::run()
                     // If we have hits
                     if (!hits.isEmpty()) {
                         Q_FOREACH (const Qt3DCore::QNodeId &entityId, hits) {
-                            Entity *entity = m_renderer->renderNodesManager()->lookupResource(entityId);
+                            Entity *entity = m_manager->renderNodesManager()->lookupResource(entityId);
                             HObjectPicker objectPickerHandle = entity->componentHandle<ObjectPicker, 16>();
 
                             // If the Entity which actually received the hit doesn't have
@@ -194,7 +196,7 @@ void PickBoundingVolumeJob::run()
                                     objectPickerHandle = entity->componentHandle<ObjectPicker, 16>();
                             }
 
-                            ObjectPicker *objectPicker = m_renderer->objectPickerManager()->data(objectPickerHandle);
+                            ObjectPicker *objectPicker = m_manager->objectPickerManager()->data(objectPickerHandle);
 
                             if (objectPicker != Q_NULLPTR) {
                                 // Send the corresponding event
@@ -242,7 +244,7 @@ void PickBoundingVolumeJob::run()
                             // The ObjectPicker was hit -> it is still being hovered
                             m_hoveredPickersToClear.removeAll(objectPickerHandle);
 
-                            lastCurrentPicker = m_renderer->objectPickerManager()->data(m_currentPicker);
+                            lastCurrentPicker = m_manager->objectPickerManager()->data(m_currentPicker);
                         }
 
                         // Otherwise no hits
@@ -292,7 +294,7 @@ void PickBoundingVolumeJob::viewMatrixForCamera(const Qt3DCore::QNodeId &cameraI
                                                 QMatrix4x4 &projectionMatrix) const
 {
     Render::CameraLens *lens = Q_NULLPTR;
-    Entity *camNode = m_renderer->renderNodesManager()->lookupResource(cameraId);
+    Entity *camNode = m_manager->renderNodesManager()->lookupResource(cameraId);
     if (camNode != Q_NULLPTR &&
             (lens = camNode->renderComponent<CameraLens>()) != Q_NULLPTR &&
             lens->isEnabled()) {
@@ -340,7 +342,7 @@ QVector<Qt3DCore::QNodeId> PickBoundingVolumeJob::hitsForViewportAndCamera(const
 void PickBoundingVolumeJob::clearPreviouslyHoveredPickers()
 {
     Q_FOREACH (const HObjectPicker &pickHandle, m_hoveredPickersToClear) {
-        ObjectPicker *pick = m_renderer->objectPickerManager()->data(pickHandle);
+        ObjectPicker *pick = m_manager->objectPickerManager()->data(pickHandle);
         if (pick)
             pick->onExited();
         m_hoveredPickers.removeAll(pickHandle);
diff --git a/src/render/jobs/pickboundingvolumejob_p.h b/src/render/jobs/pickboundingvolumejob_p.h
index e52fcccf4..6edfa23b4 100644
--- a/src/render/jobs/pickboundingvolumejob_p.h
+++ b/src/render/jobs/pickboundingvolumejob_p.h
@@ -68,6 +68,7 @@ namespace Render {
 
 class Entity;
 class Renderer;
+class NodeManagers;
 
 class Q_AUTOTEST_EXPORT PickBoundingVolumeJob : public Qt3DCore::QAspectJob, public Qt3DCore::QBoundingVolumeProvider
 {
@@ -86,6 +87,7 @@ protected:
 
 private:
     Renderer *m_renderer;
+    NodeManagers *m_manager;
     Entity *m_node;
     QList<QMouseEvent> m_mouseEvents;
 
diff --git a/src/render/jobs/renderviewjobutils.cpp b/src/render/jobs/renderviewjobutils.cpp
index 1e80cb87c..ab5247098 100644
--- a/src/render/jobs/renderviewjobutils.cpp
+++ b/src/render/jobs/renderviewjobutils.cpp
@@ -44,7 +44,7 @@
 #include <Qt3DRender/private/cameraselectornode_p.h>
 #include <Qt3DRender/private/clearbuffer_p.h>
 #include <Qt3DRender/private/layerfilternode_p.h>
-#include <Qt3DRender/private/managers_p.h>
+#include <Qt3DRender/private/nodemanagers_p.h>
 #include <Qt3DRender/private/effect_p.h>
 #include <Qt3DRender/private/renderpassfilternode_p.h>
 #include <Qt3DRender/private/renderstateset_p.h>
@@ -78,7 +78,7 @@ void setRenderViewConfigFromFrameGraphLeafNode(RenderView *rv, const FrameGraphN
     // which is referenced by the Material which is referenced by the RenderMesh. So we can
     // only store the filter info in the RenderView structure and use it to do the resolving
     // when we build the RenderCommand list.
-    const Renderer *renderer = rv->renderer();
+    const NodeManagers *manager = rv->nodeManagers();
     const FrameGraphNode *node = fgLeaf;
 
     while (node) {
@@ -89,7 +89,7 @@ void setRenderViewConfigFromFrameGraphLeafNode(RenderView *rv, const FrameGraphN
                 // Can be set only once and we take camera nearest to the leaf node
                 if (!rv->renderCamera()) {
                     const CameraSelector *cameraSelector = static_cast<const CameraSelector *>(node);
-                    Entity *camNode = renderer->renderNodesManager()->lookupResource(cameraSelector->cameraUuid());
+                    Entity *camNode = manager->renderNodesManager()->lookupResource(cameraSelector->cameraUuid());
                     if (camNode) {
                         CameraLens *lens = camNode->renderComponent<CameraLens>();
                         if (lens && lens->isEnabled()) {
@@ -121,11 +121,11 @@ void setRenderViewConfigFromFrameGraphLeafNode(RenderView *rv, const FrameGraphN
                 // Can be set once and we take render target nearest to the leaf node
                 const RenderTargetSelector *targetSelector = static_cast<const RenderTargetSelector *>(node);
                 QNodeId renderTargetUid = targetSelector->renderTargetUuid();
-                HTarget renderTargetHandle = renderer->renderTargetManager()->lookupHandle(renderTargetUid);
+                HTarget renderTargetHandle = manager->renderTargetManager()->lookupHandle(renderTargetUid);
                 if (rv->renderTargetHandle().isNull()) {
                     rv->setRenderTargetHandle(renderTargetHandle);
 
-                    RenderTarget *renderTarget = renderer->renderTargetManager()->data(renderTargetHandle);
+                    RenderTarget *renderTarget = manager->renderTargetManager()->data(renderTargetHandle);
                     if (renderTarget) {
                         // Add renderTarget Handle and build renderCommand AttachmentPack
 
@@ -134,7 +134,7 @@ void setRenderViewConfigFromFrameGraphLeafNode(RenderView *rv, const FrameGraphN
 
                         // Copy attachments
                         Q_FOREACH (const QNodeId &attachmentId, renderTarget->renderAttachments()) {
-                            RenderAttachment *attachment = renderer->attachmentManager()->lookupResource(attachmentId);
+                            RenderAttachment *attachment = manager->attachmentManager()->lookupResource(attachmentId);
                             if (attachment)
                                 rv->addRenderAttachment(attachment->attachment());
                         }
@@ -216,15 +216,17 @@ void setRenderViewConfigFromFrameGraphLeafNode(RenderView *rv, const FrameGraphN
     \a effect specified by the \a renderView.
 */
 Technique *findTechniqueForEffect(Renderer *renderer,
-                                        RenderView *renderView,
-                                        Effect *effect)
+                                  RenderView *renderView,
+                                  Effect *effect)
 {
     if (!effect)
         return Q_NULLPTR;
 
+    NodeManagers *manager = renderer->nodeManagers();
+
     // Iterate through the techniques in the effect
     Q_FOREACH (const QNodeId &techniqueId, effect->techniques()) {
-        Technique *technique = renderer->techniqueManager()->lookupResource(techniqueId);
+        Technique *technique = manager->techniqueManager()->lookupResource(techniqueId);
 
         if (!technique)
             continue;
@@ -248,10 +250,10 @@ Technique *findTechniqueForEffect(Renderer *renderer,
             // technique that satisfies it
             Q_FOREACH (const QNodeId &filterAnnotationId, techniqueFilter->filters()) {
                 foundMatch = false;
-                Annotation *filterAnnotation = renderer->criterionManager()->lookupResource(filterAnnotationId);
+                Annotation *filterAnnotation = manager->criterionManager()->lookupResource(filterAnnotationId);
 
                 Q_FOREACH (const QNodeId &techniqueAnnotationId, technique->annotations()) {
-                    Annotation *techniqueAnnotation = renderer->criterionManager()->lookupResource(techniqueAnnotationId);
+                    Annotation *techniqueAnnotation = manager->criterionManager()->lookupResource(techniqueAnnotationId);
                     if ((foundMatch = (*techniqueAnnotation == *filterAnnotation)))
                         break;
                 }
@@ -273,16 +275,16 @@ Technique *findTechniqueForEffect(Renderer *renderer,
 }
 
 
-RenderRenderPassList findRenderPassesForTechnique(Renderer *renderer,
+RenderRenderPassList findRenderPassesForTechnique(NodeManagers *manager,
                                                   RenderView *renderView,
                                                   Technique *technique)
 {
-    Q_ASSERT(renderer);
+    Q_ASSERT(manager);
     Q_ASSERT(technique);
 
     RenderRenderPassList passes;
     Q_FOREACH (const QNodeId &passId, technique->renderPasses()) {
-        RenderPass *renderPass = renderer->renderPassManager()->lookupResource(passId);
+        RenderPass *renderPass = manager->renderPassManager()->lookupResource(passId);
 
         if (renderPass) {
             const RenderPassFilter *passFilter = renderView->renderPassFilter();
@@ -294,10 +296,10 @@ RenderRenderPassList findRenderPassesForTechnique(Renderer *renderer,
                 // Iterate through the filter criteria and look for render passes with criteria that satisfy them
                 Q_FOREACH (const QNodeId &filterAnnotationId, passFilter->filters()) {
                     foundMatch = false;
-                    Annotation *filterAnnotation = renderer->criterionManager()->lookupResource(filterAnnotationId);
+                    Annotation *filterAnnotation = manager->criterionManager()->lookupResource(filterAnnotationId);
 
                     Q_FOREACH (const QNodeId &passAnnotationId, renderPass->annotations()) {
-                        Annotation *passAnnotation = renderer->criterionManager()->lookupResource(passAnnotationId);
+                        Annotation *passAnnotation = manager->criterionManager()->lookupResource(passAnnotationId);
                         if ((foundMatch = (*passAnnotation == *filterAnnotation)))
                             break;
                     }
@@ -329,7 +331,7 @@ ParameterInfoList::iterator findParamInfo(ParameterInfoList *params, const QStri
 }
 
 void addParametersForIds(ParameterInfoList *params, ParameterManager *manager,
-                                const QList<Qt3DCore::QNodeId> &parameterIds)
+                         const QList<Qt3DCore::QNodeId> &parameterIds)
 {
     Q_FOREACH (const QNodeId &paramId, parameterIds) {
         Parameter *param = manager->lookupResource(paramId);
diff --git a/src/render/jobs/renderviewjobutils_p.h b/src/render/jobs/renderviewjobutils_p.h
index 9064ab02c..aeca32268 100644
--- a/src/render/jobs/renderviewjobutils_p.h
+++ b/src/render/jobs/renderviewjobutils_p.h
@@ -72,6 +72,7 @@ class RenderStateSet;
 class Technique;
 class RenderView;
 class Renderer;
+class NodeManagers;
 class ShaderDataManager;
 struct ShaderUniform;
 class ShaderData;
@@ -81,11 +82,11 @@ Q_AUTOTEST_EXPORT void setRenderViewConfigFromFrameGraphLeafNode(RenderView *rv,
                                                                  const FrameGraphNode *fgLeaf);
 
 Q_AUTOTEST_EXPORT Technique *findTechniqueForEffect(Renderer *renderer,
-                                                          RenderView *renderView,
-                                                          Effect *effect);
+                                                    RenderView *renderView,
+                                                    Effect *effect);
 
 typedef QVarLengthArray<RenderPass*, 4> RenderRenderPassList;
-Q_AUTOTEST_EXPORT RenderRenderPassList findRenderPassesForTechnique(Renderer *renderer,
+Q_AUTOTEST_EXPORT RenderRenderPassList findRenderPassesForTechnique(NodeManagers *manager,
                                                                     RenderView *renderView,
                                                                     Technique *technique);