Renderer: use NodeManagers

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

22 files changed, 293 insertions, 379 deletions

diff --git a/src/render/backend/entity.cpp b/src/render/backend/entity.cpp
index 7d31a7645..cba6ef65c 100644
--- a/src/render/backend/entity.cpp
+++ b/src/render/backend/entity.cpp
@@ -36,7 +36,7 @@
 
 #include "entity_p.h"
 #include <Qt3DRender/private/managers_p.h>
-#include <Qt3DRender/private/renderer_p.h>
+#include <Qt3DRender/private/nodemanagers_p.h>
 #include <Qt3DRender/qabstractlight.h>
 #include <Qt3DRender/qlayer.h>
 #include <Qt3DRender/qmaterial.h>
@@ -66,7 +66,7 @@ namespace Render {
 
 Entity::Entity()
     : QBackendNode()
-    , m_renderer(Q_NULLPTR)
+    , m_nodeManagers(Q_NULLPTR)
     , m_enabled(true)
 {
 }
@@ -78,15 +78,15 @@ Entity::~Entity()
 
 void Entity::cleanup()
 {
-    if (m_renderer != Q_NULLPTR) {
+    if (m_nodeManagers != Q_NULLPTR) {
         Entity *parentEntity = parent();
         if (parentEntity != Q_NULLPTR)
             parentEntity->removeChildHandle(m_handle);
         for (int i = 0; i < m_childrenHandles.size(); i++)
-            m_renderer->renderNodesManager()->release(m_childrenHandles[i]);
+            m_nodeManagers->renderNodesManager()->release(m_childrenHandles[i]);
         // We need to release using peerUuid otherwise the handle will be cleared
         // but would still remain in the Id to Handle table
-        m_renderer->worldMatrixManager()->releaseResource(peerUuid());
+        m_nodeManagers->worldMatrixManager()->releaseResource(peerUuid());
 
         qCDebug(Render::RenderNodes) << Q_FUNC_INFO;
 
@@ -111,20 +111,20 @@ void Entity::cleanup()
 
 void Entity::setParentHandle(HEntity parentHandle)
 {
-    Q_ASSERT(m_renderer);
+    Q_ASSERT(m_nodeManagers);
     // Remove ourselves from previous parent children list
-    Entity *parent = m_renderer->renderNodesManager()->data(parentHandle);
+    Entity *parent = m_nodeManagers->renderNodesManager()->data(parentHandle);
     if (parent != Q_NULLPTR && parent->m_childrenHandles.contains(m_handle))
         parent->m_childrenHandles.remove(m_handle);
     m_parentHandle = parentHandle;
-    parent = m_renderer->renderNodesManager()->data(parentHandle);
+    parent = m_nodeManagers->renderNodesManager()->data(parentHandle);
     if (parent != Q_NULLPTR && !parent->m_childrenHandles.contains(m_handle))
         parent->m_childrenHandles.append(m_handle);
 }
 
-void Entity::setRenderer(Renderer *renderer)
+void Entity::setNodeManagers(NodeManagers *manager)
 {
-    m_renderer = renderer;
+    m_nodeManagers = manager;
 }
 
 void Entity::setHandle(HEntity handle)
@@ -138,7 +138,7 @@ void Entity::updateFromPeer(Qt3DCore::QNode *peer)
     const QNodeId parentEntityId = entity->parentEntityId();
 
     m_objectName = peer->objectName();
-    m_worldTransform = m_renderer->worldMatrixManager()->getOrAcquireHandle(peerUuid());
+    m_worldTransform = m_nodeManagers->worldMatrixManager()->getOrAcquireHandle(peerUuid());
 
     // TO DO: Suboptimal -> Maybe have a Hash<QComponent, QEntityList> instead
     m_transformComponent = QNodeId();
@@ -157,7 +157,7 @@ void Entity::updateFromPeer(Qt3DCore::QNode *peer)
         addComponent(comp);
 
     if (!parentEntityId.isNull()) {
-        setParentHandle(m_renderer->renderNodesManager()->lookupHandle(parentEntityId));
+        setParentHandle(m_nodeManagers->renderNodesManager()->lookupHandle(parentEntityId));
     } else {
         qCDebug(Render::RenderNodes) << Q_FUNC_INFO << "No parent entity found for Entity" << peerUuid();
     }
@@ -208,14 +208,14 @@ void Entity::dump() const
 
 Entity *Entity::parent() const
 {
-    return m_renderer->renderNodesManager()->data(m_parentHandle);
+    return m_nodeManagers->renderNodesManager()->data(m_parentHandle);
 }
 
 void Entity::appendChildHandle(HEntity childHandle)
 {
     if (!m_childrenHandles.contains(childHandle)) {
         m_childrenHandles.append(childHandle);
-        Entity *child = m_renderer->renderNodesManager()->data(childHandle);
+        Entity *child = m_nodeManagers->renderNodesManager()->data(childHandle);
         if (child != Q_NULLPTR)
             child->m_parentHandle = m_handle;
     }
@@ -234,7 +234,7 @@ QVector<Entity *> Entity::children() const
     QVector<Entity *> childrenVector;
     childrenVector.reserve(m_childrenHandles.size());
     foreach (HEntity handle, m_childrenHandles) {
-        Entity *child = m_renderer->renderNodesManager()->data(handle);
+        Entity *child = m_nodeManagers->renderNodesManager()->data(handle);
         if (child != Q_NULLPTR)
             childrenVector.append(child);
     }
@@ -243,12 +243,12 @@ QVector<Entity *> Entity::children() const
 
 QMatrix4x4 *Entity::worldTransform()
 {
-    return m_renderer->worldMatrixManager()->data(m_worldTransform);
+    return m_nodeManagers->worldMatrixManager()->data(m_worldTransform);
 }
 
 const QMatrix4x4 *Entity::worldTransform() const
 {
-    return m_renderer->worldMatrixManager()->data(m_worldTransform);
+    return m_nodeManagers->worldMatrixManager()->data(m_worldTransform);
 }
 
 void Entity::addComponent(Qt3DCore::QComponent *component)
@@ -309,31 +309,31 @@ void Entity::setEnabled(bool isEnabled)
 template<>
 HMaterial Entity::componentHandle<Material>() const
 {
-    return m_renderer->materialManager()->lookupHandle(m_materialComponent);
+    return m_nodeManagers->materialManager()->lookupHandle(m_materialComponent);
 }
 
 template<>
 HCamera Entity::componentHandle<CameraLens>() const
 {
-    return m_renderer->cameraManager()->lookupHandle(m_cameraComponent);
+    return m_nodeManagers->cameraManager()->lookupHandle(m_cameraComponent);
 }
 
 template<>
 HTransform Entity::componentHandle<Transform>() const
 {
-    return m_renderer->transformManager()->lookupHandle(m_transformComponent);
+    return m_nodeManagers->transformManager()->lookupHandle(m_transformComponent);
 }
 
 template<>
 HGeometryRenderer Entity::componentHandle<GeometryRenderer>() const
 {
-    return m_renderer->geometryRendererManager()->lookupHandle(m_geometryRendererComponent);
+    return m_nodeManagers->geometryRendererManager()->lookupHandle(m_geometryRendererComponent);
 }
 
 template<>
 HObjectPicker Entity::componentHandle<ObjectPicker>() const
 {
-    return m_renderer->objectPickerManager()->lookupHandle(m_objectPickerComponent);
+    return m_nodeManagers->objectPickerManager()->lookupHandle(m_objectPickerComponent);
 }
 
 template<>
@@ -341,7 +341,7 @@ QList<HLayer> Entity::componentsHandle<Layer>() const
 {
     QList<HLayer> layerHandles;
     Q_FOREACH (const QNodeId &id, m_layerComponents)
-        layerHandles.append(m_renderer->layerManager()->lookupHandle(id));
+        layerHandles.append(m_nodeManagers->layerManager()->lookupHandle(id));
     return layerHandles;
 }
 
@@ -350,14 +350,14 @@ QList<HShaderData> Entity::componentsHandle<ShaderData>() const
 {
     QList<HShaderData> shaderDataHandles;
     Q_FOREACH (const QNodeId &id, m_shaderDataComponents)
-        shaderDataHandles.append(m_renderer->shaderDataManager()->lookupHandle(id));
+        shaderDataHandles.append(m_nodeManagers->shaderDataManager()->lookupHandle(id));
     return shaderDataHandles;
 }
 
 template<>
 HBoundingVolumeDebug Entity::componentHandle<BoundingVolumeDebug>() const
 {
-    return m_renderer->boundingVolumeDebugManager()->lookupHandle(m_boundingVolumeDebugComponent);
+    return m_nodeManagers->boundingVolumeDebugManager()->lookupHandle(m_boundingVolumeDebugComponent);
 }
 
 // Render components
@@ -365,31 +365,31 @@ HBoundingVolumeDebug Entity::componentHandle<BoundingVolumeDebug>() const
 template<>
 Material *Entity::renderComponent<Material>() const
 {
-    return m_renderer->materialManager()->lookupResource(m_materialComponent);
+    return m_nodeManagers->materialManager()->lookupResource(m_materialComponent);
 }
 
 template<>
 CameraLens *Entity::renderComponent<CameraLens>() const
 {
-    return m_renderer->cameraManager()->lookupResource(m_cameraComponent);
+    return m_nodeManagers->cameraManager()->lookupResource(m_cameraComponent);
 }
 
 template<>
 Transform *Entity::renderComponent<Transform>() const
 {
-    return m_renderer->transformManager()->lookupResource(m_transformComponent);
+    return m_nodeManagers->transformManager()->lookupResource(m_transformComponent);
 }
 
 template<>
 GeometryRenderer *Entity::renderComponent<GeometryRenderer>() const
 {
-    return m_renderer->geometryRendererManager()->lookupResource(m_geometryRendererComponent);
+    return m_nodeManagers->geometryRendererManager()->lookupResource(m_geometryRendererComponent);
 }
 
 template<>
 ObjectPicker *Entity::renderComponent<ObjectPicker>() const
 {
-    return m_renderer->objectPickerManager()->lookupResource(m_objectPickerComponent);
+    return m_nodeManagers->objectPickerManager()->lookupResource(m_objectPickerComponent);
 }
 
 template<>
@@ -397,7 +397,7 @@ QList<Layer *> Entity::renderComponents<Layer>() const
 {
     QList<Layer *> layers;
     Q_FOREACH (const QNodeId &id, m_layerComponents)
-        layers.append(m_renderer->layerManager()->lookupResource(id));
+        layers.append(m_nodeManagers->layerManager()->lookupResource(id));
     return layers;
 }
 
@@ -406,14 +406,14 @@ QList<ShaderData *> Entity::renderComponents<ShaderData>() const
 {
     QList<ShaderData *> shaderDatas;
     Q_FOREACH (const QNodeId &id, m_shaderDataComponents)
-        shaderDatas.append(m_renderer->shaderDataManager()->lookupResource(id));
+        shaderDatas.append(m_nodeManagers->shaderDataManager()->lookupResource(id));
     return shaderDatas;
 }
 
 template<>
 BoundingVolumeDebug *Entity::renderComponent<BoundingVolumeDebug>() const
 {
-    return m_renderer->boundingVolumeDebugManager()->lookupResource(m_boundingVolumeDebugComponent);
+    return m_nodeManagers->boundingVolumeDebugManager()->lookupResource(m_boundingVolumeDebugComponent);
 }
 
 // Uuid
@@ -442,17 +442,17 @@ QNodeId Entity::componentUuid<ObjectPicker>() const { return m_objectPickerCompo
 template<>
 QNodeId Entity::componentUuid<BoundingVolumeDebug>() const { return m_boundingVolumeDebugComponent; }
 
-RenderEntityFunctor::RenderEntityFunctor(Renderer *renderer)
-    : m_renderer(renderer)
+RenderEntityFunctor::RenderEntityFunctor(NodeManagers *manager)
+    : m_nodeManagers(manager)
 {
 }
 
 Qt3DCore::QBackendNode *RenderEntityFunctor::create(Qt3DCore::QNode *frontend, const Qt3DCore::QBackendNodeFactory *factory) const
 {
-    HEntity renderNodeHandle = m_renderer->renderNodesManager()->getOrAcquireHandle(frontend->id());
-    Entity *entity = m_renderer->renderNodesManager()->data(renderNodeHandle);
+    HEntity renderNodeHandle = m_nodeManagers->renderNodesManager()->getOrAcquireHandle(frontend->id());
+    Entity *entity = m_nodeManagers->renderNodesManager()->data(renderNodeHandle);
     entity->setFactory(factory);
-    entity->setRenderer(m_renderer);
+    entity->setNodeManagers(m_nodeManagers);
     entity->setHandle(renderNodeHandle);
     entity->setPeer(frontend);
     return entity;
@@ -460,12 +460,12 @@ Qt3DCore::QBackendNode *RenderEntityFunctor::create(Qt3DCore::QNode *frontend, c
 
 Qt3DCore::QBackendNode *RenderEntityFunctor::get(const Qt3DCore::QNodeId &id) const
 {
-    return m_renderer->renderNodesManager()->lookupResource(id);
+    return m_nodeManagers->renderNodesManager()->lookupResource(id);
 }
 
 void RenderEntityFunctor::destroy(const Qt3DCore::QNodeId &id) const
 {
-    m_renderer->renderNodesManager()->releaseResource(id);
+    m_nodeManagers->renderNodesManager()->releaseResource(id);
 }
 
 } // namespace Render
diff --git a/src/render/backend/entity_p.h b/src/render/backend/entity_p.h
index ea8d167ec..4566f749a 100644
--- a/src/render/backend/entity_p.h
+++ b/src/render/backend/entity_p.h
@@ -74,6 +74,7 @@ namespace Render {
 
 class Sphere;
 class Renderer;
+class NodeManagers;
 
 class Q_AUTOTEST_EXPORT Entity : public Qt3DCore::QBackendNode
 {
@@ -83,7 +84,7 @@ public:
     void cleanup();
 
     void setParentHandle(HEntity parentHandle);
-    void setRenderer(Renderer *renderer);
+    void setNodeManagers(NodeManagers *manager);
     void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) Q_DECL_OVERRIDE;
     void updateFromPeer(Qt3DCore::QNode *peer) Q_DECL_OVERRIDE;
 
@@ -148,19 +149,7 @@ public:
     }
 
 private:
-
-    template<class Frontend, class Backend, class Manager>
-    void createRenderComponentHelper(Frontend *frontend, Manager *manager)
-    {
-        // We index using the Frontend id
-        if (!manager->contains(frontend->id())) {
-            Backend *backend = manager->getOrCreateResource(frontend->id());
-            backend->setRenderer(m_renderer);
-            backend->setPeer(frontend);
-        }
-    }
-
-    Renderer *m_renderer;
+    NodeManagers *m_nodeManagers;
     HEntity m_handle;
     HEntity m_parentHandle;
     QVector<HEntity > m_childrenHandles;
@@ -262,13 +251,13 @@ Q_AUTOTEST_EXPORT Qt3DCore::QNodeId Entity::componentUuid<BoundingVolumeDebug>()
 class RenderEntityFunctor : public Qt3DCore::QBackendNodeFunctor
 {
 public:
-    explicit RenderEntityFunctor(Renderer *renderer);
+    explicit RenderEntityFunctor(NodeManagers *manager);
     Qt3DCore::QBackendNode *create(Qt3DCore::QNode *frontend, const Qt3DCore::QBackendNodeFactory *factory) const Q_DECL_OVERRIDE;
     Qt3DCore::QBackendNode *get(const Qt3DCore::QNodeId &id) const Q_DECL_OVERRIDE;
     void destroy(const Qt3DCore::QNodeId &id) const Q_DECL_OVERRIDE;
 
 private:
-    Renderer *m_renderer;
+    NodeManagers *m_nodeManagers;
 };
 
 } // namespace Render
diff --git a/src/render/backend/renderer.cpp b/src/render/backend/renderer.cpp
index 308aa120b..e4bceb724 100644
--- a/src/render/backend/renderer.cpp
+++ b/src/render/backend/renderer.cpp
@@ -62,21 +62,22 @@
 #include <Qt3DRender/private/renderpassfilternode_p.h>
 #include <Qt3DRender/private/renderqueue_p.h>
 #include <Qt3DRender/private/shader_p.h>
+#include <Qt3DRender/private/buffer_p.h>
 #include <Qt3DRender/private/renderstateset_p.h>
 #include <Qt3DRender/private/technique_p.h>
 #include <Qt3DRender/private/renderthread_p.h>
 #include <Qt3DRender/private/renderview_p.h>
 #include <Qt3DRender/private/techniquefilternode_p.h>
-#include <Qt3DRender/private/texturedatamanager_p.h>
-#include <Qt3DRender/private/scenemanager_p.h>
 #include <Qt3DRender/private/viewportnode_p.h>
 #include <Qt3DRender/private/vsyncframeadvanceservice_p.h>
-#include <Qt3DRender/private/buffermanager_p.h>
 #include <Qt3DRender/private/loadbufferjob_p.h>
 #include <Qt3DRender/private/loadgeometryjob_p.h>
-#include <Qt3DRender/private/geometryrenderermanager_p.h>
 #include <Qt3DRender/private/pickeventfilter_p.h>
 #include <Qt3DRender/private/qsceneparserfactory_p.h>
+#include <Qt3DRender/private/managers_p.h>
+#include <Qt3DRender/private/buffermanager_p.h>
+#include <Qt3DRender/private/nodemanagers_p.h>
+#include <Qt3DRender/private/geometryrenderermanager_p.h>
 
 #include <Qt3DCore/qcameralens.h>
 #include <Qt3DCore/qeventfilterservice.h>
@@ -133,38 +134,10 @@ const QString SCENE_PARSERS_PATH = QStringLiteral("/sceneparsers");
 
 Renderer::Renderer(QRenderAspect::RenderType type)
     : m_rendererAspect(Q_NULLPTR)
+    , m_nodesManager(new NodeManagers())
     , m_graphicsContext(Q_NULLPTR)
     , m_surface(Q_NULLPTR)
     , m_eventSource(Q_NULLPTR)
-    , m_cameraManager(new CameraManager())
-    , m_renderNodesManager(new EntityManager())
-    , m_materialManager(new MaterialManager())
-    , m_worldMatrixManager(new MatrixManager())
-    , m_vaoManager(new VAOManager())
-    , m_shaderManager(new ShaderManager())
-    , m_techniqueManager(new TechniqueManager())
-    , m_effectManager(new EffectManager())
-    , m_renderPassManager(new RenderPassManager())
-    , m_textureManager(new TextureManager())
-    , m_textureDataManager(new TextureDataManager())
-    , m_layerManager(new LayerManager())
-    , m_criterionManager(new CriterionManager())
-    , m_frameGraphManager(new FrameGraphManager())
-    , m_transformManager(new TransformManager())
-    , m_renderTargetManager(new RenderTargetManager())
-    , m_sceneManager(new SceneManager())
-    , m_attachmentManager(new AttachmentManager())
-    , m_sortCriterionManager(new SortCriterionManager())
-    , m_parameterManager(new ParameterManager())
-    , m_shaderDataManager(new ShaderDataManager())
-    , m_uboManager(new UBOManager())
-    , m_textureImageManager(new TextureImageManager())
-    , m_bufferManager(new BufferManager())
-    , m_attributeManager(new AttributeManager())
-    , m_geometryManager(new GeometryManager())
-    , m_geometryRendererManager(new GeometryRendererManager)
-    , m_objectPickerManager(new ObjectPickerManager())
-    , m_boundingVolumeDebugManager(new BoundingVolumeDebugManager())
     , m_renderQueue(new RenderQueue())
     , m_renderThread(type == QRenderAspect::Threaded ? new RenderThread(this) : Q_NULLPTR)
     , m_vsyncFrameAdvanceService(new VSyncFrameAdvanceService())
@@ -183,7 +156,12 @@ Renderer::Renderer(QRenderAspect::RenderType type)
 Renderer::~Renderer()
 {
     // Clean up the TLS allocators
-    destroyAllocators();
+    destroyAllocators(rendererAspect()->jobManager());
+}
+
+NodeManagers *Renderer::nodeManagers() const
+{
+    return m_nodesManager;
 }
 
 void Renderer::buildDefaultTechnique()
@@ -268,20 +246,16 @@ void Renderer::buildDefaultMaterial()
 
 }
 
-void Renderer::createAllocators()
+void Renderer::createAllocators(QAbstractAspectJobManager *jobManager)
 {
     // Issue a set of jobs to create an allocator in TLS for each worker thread
-    Q_ASSERT(m_rendererAspect);
-    QAbstractAspectJobManager *jobManager = rendererAspect()->jobManager();
     Q_ASSERT(jobManager);
     jobManager->waitForPerThreadFunction(Renderer::createThreadLocalAllocator, this);
 }
 
-void Renderer::destroyAllocators()
+void Renderer::destroyAllocators(Qt3DCore::QAbstractAspectJobManager *jobManager)
 {
     // Issue a set of jobs to destroy the allocator in TLS for each worker thread
-    Q_ASSERT(m_rendererAspect);
-    QAbstractAspectJobManager *jobManager = rendererAspect()->jobManager();
     Q_ASSERT(jobManager);
     jobManager->waitForPerThreadFunction(Renderer::destroyThreadLocalAllocator, this);
 }
@@ -429,7 +403,7 @@ void Renderer::setFrameGraphRoot(const Qt3DCore::QNodeId &frameGraphRootUuid)
 
 Render::FrameGraphNode *Renderer::frameGraphRoot() const
 {
-    FrameGraphNode **fgRoot = m_frameGraphManager->lookupResource(m_frameGraphRootUuid);
+    FrameGraphNode **fgRoot = m_nodesManager->lookupResource<FrameGraphNode*, FrameGraphManager>(m_frameGraphRootUuid);
     if (fgRoot != Q_NULLPTR)
         return *fgRoot;
     return Q_NULLPTR;
@@ -448,7 +422,6 @@ void Renderer::setSceneGraphRoot(Entity *sgRoot)
     QMutexLocker lock(&m_mutex); // This waits until initialize and setSurface have been called
     if (m_graphicsContext == Q_NULLPTR) // If initialization hasn't been completed we must wait
         m_waitForInitializationToBeCompleted.wait(&m_mutex);
-
     m_renderSceneRoot = sgRoot;
     if (!m_renderSceneRoot)
         qCWarning(Backend) << "Failed to build render scene";
@@ -475,11 +448,11 @@ void Renderer::setSceneGraphRoot(Entity *sgRoot)
         m_rendererAspect->createBackendNode(p);
 
 
-    m_defaultMaterialHandle = m_materialManager->lookupHandle(m_defaultMaterial->id());
-    m_defaultEffectHandle = m_effectManager->lookupHandle(m_defaultMaterial->effect()->id());
-    m_defaultTechniqueHandle = m_techniqueManager->lookupHandle(m_defaultTechnique->id());
-    m_defaultRenderPassHandle = m_renderPassManager->lookupHandle(m_defaultTechnique->renderPasses().first()->id());
-    m_defaultRenderShader = m_shaderManager->lookupResource(m_defaultTechnique->renderPasses().first()->shaderProgram()->id());
+    m_defaultMaterialHandle = nodeManagers()->lookupHandle<Material, MaterialManager, HMaterial>(m_defaultMaterial->id());
+    m_defaultEffectHandle = nodeManagers()->lookupHandle<Effect, EffectManager, HEffect>(m_defaultMaterial->effect()->id());
+    m_defaultTechniqueHandle = nodeManagers()->lookupHandle<Technique, TechniqueManager, HTechnique>(m_defaultTechnique->id());
+    m_defaultRenderPassHandle = nodeManagers()->lookupHandle<RenderPass, RenderPassManager, HRenderPass>(m_defaultTechnique->renderPasses().first()->id());
+    m_defaultRenderShader = nodeManagers()->lookupResource<Shader, ShaderManager>(m_defaultTechnique->renderPasses().first()->shaderProgram()->id());
 }
 
 // Called in RenderAspect Thread context
@@ -710,7 +683,7 @@ bool Renderer::submitRenderViews()
 
         // Set RenderTarget ...
         // Activate RenderTarget
-        m_graphicsContext->activateRenderTarget(m_renderTargetManager->data(renderView->renderTargetHandle()),
+        m_graphicsContext->activateRenderTarget(nodeManagers()->data<RenderTarget, RenderTargetManager>(renderView->renderTargetHandle()),
                                                 renderView->attachmentPack(), boundFboId);
 
         // Set clear color if different
@@ -763,17 +736,13 @@ QVector<Qt3DCore::QAspectJobPtr> Renderer::createRenderBinJobs()
     // 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
-
     QVector<QAspectJobPtr> renderBinJobs;
 
-    // Do not create any more jobs when the platform surface is gone.
-    if (m_surface) {
-        FrameGraphVisitor visitor;
-        visitor.traverse(frameGraphRoot(), this, &renderBinJobs);
+    FrameGraphVisitor visitor;
+    visitor.traverse(frameGraphRoot(), this, &renderBinJobs);
 
-        // Set target number of RenderViews
-        m_renderQueue->setTargetRenderViewCount(renderBinJobs.size());
-    }
+    // Set target number of RenderViews
+    m_renderQueue->setTargetRenderViewCount(renderBinJobs.size());
     return renderBinJobs;
 }
 
@@ -781,15 +750,15 @@ QVector<Qt3DCore::QAspectJobPtr> Renderer::createRenderBinJobs()
 // 1 dirty buffer == 1 job, all job can be performed in parallel
 QVector<Qt3DCore::QAspectJobPtr> Renderer::createRenderBufferJobs()
 {
-    const QVector<QNodeId> dirtyBuffers = m_bufferManager->dirtyBuffers();
+    const QVector<QNodeId> dirtyBuffers = nodeManagers()->bufferManager()->dirtyBuffers();
     QVector<QAspectJobPtr> dirtyBuffersJobs;
 
     Q_FOREACH (const QNodeId &bufId, dirtyBuffers) {
-        HBuffer bufferHandle = m_bufferManager->lookupHandle(bufId);
+        HBuffer bufferHandle = m_nodesManager->lookupHandle<Buffer, BufferManager, HBuffer>(bufId);
         if (!bufferHandle.isNull()) {
             // Create new buffer job
             LoadBufferJobPtr job(new LoadBufferJob(bufferHandle));
-            job->setRenderer(this);
+            job->setNodeManager(m_nodesManager);
             dirtyBuffersJobs.push_back(job);
         }
     }
@@ -799,14 +768,15 @@ QVector<Qt3DCore::QAspectJobPtr> Renderer::createRenderBufferJobs()
 
 QVector<Qt3DCore::QAspectJobPtr> Renderer::createGeometryRendererJobs()
 {
-    const QVector<QNodeId> dirtyGeometryRenderers = m_geometryRendererManager->dirtyGeometryRenderers();
+    GeometryRendererManager *geomRendererManager = m_nodesManager->geometryRendererManager();
+    const QVector<QNodeId> dirtyGeometryRenderers = geomRendererManager->dirtyGeometryRenderers();
     QVector<QAspectJobPtr> dirtyGeometryRendererJobs;
 
     Q_FOREACH (const QNodeId &geoRendererId, dirtyGeometryRenderers) {
-        HGeometryRenderer geometryRendererHandle = m_geometryRendererManager->lookupHandle(geoRendererId);
+        HGeometryRenderer geometryRendererHandle = geomRendererManager->lookupHandle(geoRendererId);
         if (!geometryRendererHandle.isNull()) {
             LoadGeometryJobPtr job(new LoadGeometryJob(geometryRendererHandle));
-            job->setRenderer(this);
+            job->setNodeManagers(m_nodesManager);
             dirtyGeometryRendererJobs.push_back(job);
         }
     }
@@ -819,7 +789,8 @@ Qt3DCore::QAspectJobPtr Renderer::createRenderViewJob(FrameGraphNode *node, int
 {
     RenderViewJobPtr job(new RenderViewJob);
     job->setRenderer(this);
-    job->setSurfaceSize(m_surface->size());
+    if (m_surface)
+        job->setSurfaceSize(m_surface->size());
     job->setFrameGraphLeafNode(node);
     job->setSubmitOrderIndex(submitOrderIndex);
     return job;
@@ -841,8 +812,8 @@ void Renderer::executeCommands(const QVector<RenderCommand *> &commands)
     Q_FOREACH (RenderCommand *command, commands) {
 
         // Check if we have a valid GeometryRenderer + Geometry
-        Geometry *rGeometry = m_geometryManager->data(command->m_geometry);
-        GeometryRenderer *rGeometryRenderer = m_geometryRendererManager->data(command->m_geometryRenderer);
+        Geometry *rGeometry = m_nodesManager->data<Geometry, GeometryManager>(command->m_geometry);
+        GeometryRenderer *rGeometryRenderer = m_nodesManager->data<GeometryRenderer, GeometryRendererManager>(command->m_geometryRenderer);
         const bool hasGeometryRenderer = rGeometry != Q_NULLPTR && rGeometryRenderer != Q_NULLPTR && !rGeometry->attributes().isEmpty();
 
         if (!hasGeometryRenderer) {
@@ -850,7 +821,7 @@ void Renderer::executeCommands(const QVector<RenderCommand *> &commands)
             continue;
         }
 
-        Shader *shader = m_shaderManager->data(command->m_shader);
+        Shader *shader = m_nodesManager->data<Shader, ShaderManager>(command->m_shader);
         if (shader == Q_NULLPTR) {
             shader = m_defaultRenderShader;
             command->m_parameterAttributeToShaderNames = m_defaultParameterToGLSLAttributeNames;
@@ -861,17 +832,18 @@ void Renderer::executeCommands(const QVector<RenderCommand *> &commands)
         // Manager should have a VAO Manager that are indexed by QMeshData and Shader
         // RenderCommand should have a handle to the corresponding VAO for the Mesh and Shader
         bool needsToBindVAO = false;
+        VAOManager *vaoManager = m_nodesManager->vaoManager();
         if (m_graphicsContext->supportsVAO()) {
-            command->m_vao = m_vaoManager->lookupHandle(QPair<HGeometry, HShader>(command->m_geometry, command->m_shader));
+            command->m_vao = vaoManager->lookupHandle(QPair<HGeometry, HShader>(command->m_geometry, command->m_shader));
             if (command->m_vao.isNull()) {
                 qCDebug(Rendering) << Q_FUNC_INFO << "Allocating new VAO";
-                command->m_vao = m_vaoManager->getOrAcquireHandle(QPair<HGeometry, HShader>(command->m_geometry, command->m_shader));
-                *(m_vaoManager->data(command->m_vao)) = new QOpenGLVertexArrayObject();
+                command->m_vao = vaoManager->getOrAcquireHandle(QPair<HGeometry, HShader>(command->m_geometry, command->m_shader));
+                *(vaoManager->data(command->m_vao)) = new QOpenGLVertexArrayObject();
             }
             if (previousVaoHandle != command->m_vao) {
                 needsToBindVAO = true;
                 previousVaoHandle = command->m_vao;
-                vao = *(m_vaoManager->data(command->m_vao));
+                vao = *(vaoManager->data(command->m_vao));
             }
             Q_ASSERT(vao);
             // If the VAO hasn't been created, we create it
@@ -1008,12 +980,12 @@ Attribute *Renderer::updateBuffersAndAttributes(Geometry *geometry, RenderComman
 
     Q_FOREACH (const QNodeId &attributeId, geometry->attributes()) {
         // TO DO: Improvement we could store handles and use the non locking policy on the attributeManager
-        Attribute *attribute = attributeManager()->lookupResource(attributeId);
+        Attribute *attribute = m_nodesManager->attributeManager()->lookupResource(attributeId);
 
         if (attribute == Q_NULLPTR)
             continue;
 
-        Buffer *buffer = bufferManager()->lookupResource(attribute->bufferId());
+        Buffer *buffer = m_nodesManager->bufferManager()->lookupResource(attribute->bufferId());
 
         if (buffer == Q_NULLPTR)
             continue;
diff --git a/src/render/backend/renderer_p.h b/src/render/backend/renderer_p.h
index ee8e79596..7118f9ff1 100644
--- a/src/render/backend/renderer_p.h
+++ b/src/render/backend/renderer_p.h
@@ -102,46 +102,17 @@ class Technique;
 class Shader;
 class Entity;
 class RenderCommand;
-class CameraManager;
-class EntityManager;
 class RenderQueue;
 class RenderView;
-class MaterialManager;
-class MatrixManager;
-class VAOManager;
-class ShaderManager;
-class TechniqueManager;
-class EffectManager;
-class RenderPassManager;
 class Effect;
 class RenderPass;
-class TextureManager;
-class TextureDataManager;
-class LayerManager;
-class LightManager;
 class RenderThread;
-class CriterionManager;
-class FrameGraphManager;
-class TransformManager;
 class RenderStateSet;
-class RenderTargetManager;
-class SceneManager;
-class AttachmentManager;
-class SortCriterionManager;
-class ParameterManager;
-class ShaderDataManager;
-class UBOManager;
-class TextureImageManager;
 class VSyncFrameAdvanceService;
-class BufferManager;
-class AttributeManager;
-class GeometryManager;
-class GeometryRendererManager;
-class ObjectPickerManager;
 class PickEventFilter;
-class BoundingVolumeDebugManager;
+class NodeManagers;
 
-class Renderer
+class Q_AUTOTEST_EXPORT Renderer
 {
 public:
     explicit Renderer(QRenderAspect::RenderType type);
@@ -150,8 +121,10 @@ public:
     void setQRenderAspect(QRenderAspect *aspect) { m_rendererAspect = aspect; }
     QRenderAspect *rendererAspect() const { return m_rendererAspect; }
 
-    void createAllocators();
-    void destroyAllocators();
+    NodeManagers *nodeManagers() const;
+
+    void createAllocators(Qt3DCore::QAbstractAspectJobManager *jobManager);
+    void destroyAllocators(Qt3DCore::QAbstractAspectJobManager *jobManager);
 
     Qt3DCore::QFrameAllocator *currentFrameAllocator();
 
@@ -174,35 +147,6 @@ public:
     Attribute *updateBuffersAndAttributes(Geometry *geometry, RenderCommand *command, GLsizei &count, bool forceUpdate);
     void addAllocator(Qt3DCore::QFrameAllocator *allocator);
 
-    inline CameraManager *cameraManager() const { return m_cameraManager; }
-    inline EntityManager *renderNodesManager() const { return m_renderNodesManager; }
-    inline MaterialManager *materialManager() const { return m_materialManager; }
-    inline MatrixManager *worldMatrixManager() const { return m_worldMatrixManager; }
-    inline VAOManager *vaoManager() const { return m_vaoManager; }
-    inline ShaderManager *shaderManager() const { return m_shaderManager; }
-    inline TechniqueManager *techniqueManager() const { return m_techniqueManager; }
-    inline EffectManager *effectManager() const { return m_effectManager; }
-    inline RenderPassManager *renderPassManager() const { return m_renderPassManager; }
-    inline TextureManager *textureManager() const { return m_textureManager; }
-    inline TextureDataManager *textureDataManager() const { return m_textureDataManager; }
-    inline LayerManager *layerManager() const { return m_layerManager; }
-    inline CriterionManager *criterionManager() const { return m_criterionManager; }
-    inline FrameGraphManager *frameGraphManager() const { return m_frameGraphManager; }
-    inline TransformManager *transformManager() const { return m_transformManager; }
-    inline RenderTargetManager *renderTargetManager() const { return m_renderTargetManager; }
-    inline SceneManager *sceneManager() const { return m_sceneManager; }
-    inline AttachmentManager *attachmentManager() const { return m_attachmentManager; }
-    inline SortCriterionManager *sortCriterionManager() const { return m_sortCriterionManager; }
-    inline ParameterManager *parameterManager() const { return m_parameterManager; }
-    inline ShaderDataManager *shaderDataManager() const { return m_shaderDataManager; }
-    inline UBOManager *uboManager() const { return m_uboManager; }
-    inline TextureImageManager *textureImageManager() const { return m_textureImageManager; }
-    inline BufferManager *bufferManager() const { return m_bufferManager; }
-    inline AttributeManager *attributeManager() const { return m_attributeManager; }
-    inline GeometryManager *geometryManager() const { return m_geometryManager; }
-    inline GeometryRendererManager *geometryRendererManager() const { return m_geometryRendererManager; }
-    inline ObjectPickerManager *objectPickerManager() const { return m_objectPickerManager; }
-    inline BoundingVolumeDebugManager *boundingVolumeDebugManager() const { return m_boundingVolumeDebugManager; }
 
     inline HMaterial defaultMaterialHandle() const { return m_defaultMaterialHandle; }
     inline HEffect defaultEffectHandle() const { return m_defaultEffectHandle; }
@@ -230,10 +174,15 @@ public:
     QMutex* mutex() { return &m_mutex; }
     bool isRunning() const { return m_running.load(); }
 
+#ifdef QT3D_RENDER_UNIT_TESTS
+public:
+#else
 private:
+#endif
     bool canRender() const;
 
     QRenderAspect *m_rendererAspect;
+    NodeManagers *m_nodesManager;
 
     // Frame graph root
     Qt3DCore::QNodeId m_frameGraphRootUuid;
@@ -262,35 +211,7 @@ private:
     QScopedPointer<GraphicsContext> m_graphicsContext;
     QSurface *m_surface;
     QObject *m_eventSource;
-    CameraManager *m_cameraManager;
-    EntityManager *m_renderNodesManager;
-    MaterialManager *m_materialManager;
-    MatrixManager *m_worldMatrixManager;
-    VAOManager *m_vaoManager;
-    ShaderManager *m_shaderManager;
-    TechniqueManager *m_techniqueManager;
-    EffectManager *m_effectManager;
-    RenderPassManager *m_renderPassManager;
-    TextureManager *m_textureManager;
-    TextureDataManager *m_textureDataManager;
-    LayerManager *m_layerManager;
-    CriterionManager *m_criterionManager;
-    FrameGraphManager *m_frameGraphManager;
-    TransformManager *m_transformManager;
-    RenderTargetManager *m_renderTargetManager;
-    SceneManager *m_sceneManager;
-    AttachmentManager *m_attachmentManager;
-    SortCriterionManager *m_sortCriterionManager;
-    ParameterManager *m_parameterManager;
-    ShaderDataManager *m_shaderDataManager;
-    UBOManager *m_uboManager;
-    TextureImageManager *m_textureImageManager;
-    BufferManager *m_bufferManager;
-    AttributeManager *m_attributeManager;
-    GeometryManager *m_geometryManager;
-    GeometryRendererManager *m_geometryRendererManager;
-    ObjectPickerManager *m_objectPickerManager;
-    BoundingVolumeDebugManager *m_boundingVolumeDebugManager;
+
 
     RenderQueue *m_renderQueue;
     QScopedPointer<RenderThread> m_renderThread;
diff --git a/src/render/backend/renderview.cpp b/src/render/backend/renderview.cpp
index c9b76182a..22000713a 100644
--- a/src/render/backend/renderview.cpp
+++ b/src/render/backend/renderview.cpp
@@ -50,6 +50,7 @@
 #include <Qt3DRender/private/effect_p.h>
 #include <Qt3DRender/private/entity_p.h>
 #include <Qt3DRender/private/renderer_p.h>
+#include <Qt3DRender/private/nodemanagers_p.h>
 #include <Qt3DRender/private/layer_p.h>
 #include <Qt3DRender/private/renderlogging_p.h>
 #include <Qt3DRender/private/renderpassfilternode_p.h>
@@ -368,7 +369,8 @@ void RenderView::sort()
 void RenderView::setRenderer(Renderer *renderer)
 {
     m_renderer = renderer;
-    m_data->m_uniformBlockBuilder.shaderDataManager = m_renderer->shaderDataManager();
+    m_manager = renderer->nodeManagers();
+    m_data->m_uniformBlockBuilder.shaderDataManager = m_manager->shaderDataManager();
 }
 
 // Tries to order renderCommand by shader so as to minimize shader changes
@@ -395,7 +397,7 @@ void RenderView::buildRenderCommands(Entity *node)
                 Material *material = Q_NULLPTR;
                 Effect *effect = Q_NULLPTR;
                 if ((material = node->renderComponent<Material>()) != Q_NULLPTR && material->isEnabled())
-                    effect = m_renderer->effectManager()->lookupResource(material->effect());
+                    effect = m_renderer->nodeManagers()->effectManager()->lookupResource(material->effect());
                 Technique *technique = findTechniqueForEffect(m_renderer, this, effect);
 
                 ParameterInfoList parameters;
@@ -410,36 +412,36 @@ void RenderView::buildRenderCommands(Entity *node)
                 // Add Parameters define in techniqueFilter and passFilter
                 // passFilter have priority over techniqueFilter
                 if (m_data->m_passFilter)
-                    parametersFromParametersProvider(&parameters, m_renderer->parameterManager(),
+                    parametersFromParametersProvider(&parameters, m_renderer->nodeManagers()->parameterManager(),
                                                      m_data->m_passFilter);
                 if (m_data->m_techniqueFilter)
-                    parametersFromParametersProvider(&parameters, m_renderer->parameterManager(),
+                    parametersFromParametersProvider(&parameters, m_renderer->nodeManagers()->parameterManager(),
                                                      m_data->m_techniqueFilter);
 
                 RenderRenderPassList passes;
                 if (technique) {
-                    passes = findRenderPassesForTechnique(m_renderer, this, technique);
+                    passes = findRenderPassesForTechnique(m_manager, this, technique);
                 } else {
-                    material = m_renderer->materialManager()->data(m_renderer->defaultMaterialHandle());
-                    effect = m_renderer->effectManager()->data(m_renderer->defaultEffectHandle());
-                    technique = m_renderer->techniqueManager()->data(m_renderer->defaultTechniqueHandle());
-                    passes << m_renderer->renderPassManager()->data(m_renderer->defaultRenderPassHandle());
+                    material = m_manager->data<Material, MaterialManager>(m_renderer->defaultMaterialHandle());
+                    effect = m_manager->data<Effect, EffectManager>(m_renderer->defaultEffectHandle());
+                    technique = m_manager->data<Technique, TechniqueManager>(m_renderer->defaultTechniqueHandle());
+                    passes << m_manager->data<RenderPass, RenderPassManager>(m_renderer->defaultRenderPassHandle());
                 }
 
                 // Get the parameters for our selected rendering setup (override what was defined in the technique/pass filter)
-                parametersFromMaterialEffectTechnique(&parameters, m_renderer->parameterManager(), material, effect, technique);
+                parametersFromMaterialEffectTechnique(&parameters, m_manager->parameterManager(), material, effect, technique);
 
                 // 1 RenderCommand per RenderPass pass on an Entity with a Mesh
                 Q_FOREACH (RenderPass *pass, passes) {
 
                     // Add the RenderPass Parameters
                     ParameterInfoList globalParameters = parameters;
-                    parametersFromParametersProvider(&globalParameters, m_renderer->parameterManager(), pass);
+                    parametersFromParametersProvider(&globalParameters, m_manager->parameterManager(), pass);
 
                     RenderCommand *command = m_allocator->allocate<RenderCommand>();
                     command->m_depth = m_data->m_eyePos.distanceToPoint(node->worldBoundingVolume()->center());
 
-                    command->m_geometry = m_renderer->geometryManager()->lookupHandle(geometryRenderer->geometryId());
+                    command->m_geometry = m_manager->lookupHandle<Geometry, GeometryManager, HGeometry>(geometryRenderer->geometryId());
                     command->m_geometryRenderer = node->componentHandle<GeometryRenderer, 16>();
                     command->m_instancesCount = 0;
                     command->m_stateSet = Q_NULLPTR;
@@ -522,8 +524,8 @@ void RenderView::setUniformBlockValue(QUniformPack &uniformPack, Shader *shader,
         bool uboNeedsUpdate = false;
 
         // build UBO at uboId if not created before
-        if (!m_renderer->uboManager()->contains(uboKey)) {
-            m_renderer->uboManager()->getOrCreateResource(uboKey);
+        if (!m_manager->uboManager()->contains(uboKey)) {
+            m_manager->uboManager()->getOrCreateResource(uboKey);
             uboNeedsUpdate = true;
         }
 
@@ -582,7 +584,7 @@ void RenderView::buildSortingKey(RenderCommand *command)
 
     // Handle at most 4 filters at once
     for (int i = 0; i < sortCount && i < 4; i++) {
-        SortCriterion *sC = m_renderer->sortCriterionManager()->lookupResource(m_data->m_sortingCriteria[i]);
+        SortCriterion *sC = m_manager->lookupResource<SortCriterion, SortCriterionManager>(m_data->m_sortingCriteria[i]);
 
         switch (sC->sortType()) {
         case QSortCriterion::StateChangeCost:
@@ -614,10 +616,9 @@ void RenderView::setShaderAndUniforms(RenderCommand *command, RenderPass *rPass,
 
     if (rPass != Q_NULLPTR) {
         // Index Shader by Shader UUID
-        command->m_shader = m_renderer->shaderManager()->lookupHandle(rPass->shaderProgram());
+        command->m_shader = m_manager->lookupHandle<Shader, ShaderManager, HShader>(rPass->shaderProgram());
         Shader *shader = Q_NULLPTR;
-        if ((shader = m_renderer->shaderManager()->data(command->m_shader)) != Q_NULLPTR) {
-
+        if ((shader = m_manager->data<Shader, ShaderManager>(command->m_shader)) != Q_NULLPTR) {
             command->m_shaderDna = shader->dna();
 
             // Builds the QUniformPack, sets shader standard uniforms and store attributes name / glname bindings
diff --git a/src/render/backend/renderview_p.h b/src/render/backend/renderview_p.h
index 67bed52a3..e585cb7ff 100644
--- a/src/render/backend/renderview_p.h
+++ b/src/render/backend/renderview_p.h
@@ -75,6 +75,7 @@ class QRenderPass;
 namespace Render {
 
 class Renderer;
+class NodeManagers;
 class RenderCommand;
 class RenderPassFilter;
 class TechniqueFilter;
@@ -103,6 +104,7 @@ public:
     void setRenderer(Renderer *renderer);
     inline void setSurfaceSize(const QSize &size) { m_surfaceSize = size; }
     inline Renderer *renderer() const { return m_renderer; }
+    inline NodeManagers *nodeManagers() const { return m_manager; }
 
     inline void setAllocator(Qt3DCore::QFrameAllocator *allocator)
     {
@@ -223,6 +225,7 @@ private:
     void setShaderAndUniforms(RenderCommand *command, RenderPass *pass, ParameterInfoList &parameters, const QMatrix4x4 &worldTransform);
 
     Renderer *m_renderer;
+    NodeManagers *m_manager;
     QSize m_surfaceSize;
     Qt3DCore::QFrameAllocator *m_allocator;
 
diff --git a/src/render/frontend/qrenderaspect.cpp b/src/render/frontend/qrenderaspect.cpp
index 23de69f30..b3148b1e1 100644
--- a/src/render/frontend/qrenderaspect.cpp
+++ b/src/render/frontend/qrenderaspect.cpp
@@ -37,6 +37,7 @@
 #include "qrenderaspect.h"
 #include "qrenderaspect_p.h"
 
+#include <Qt3DRender/private/nodemanagers_p.h>
 #include <Qt3DRender/private/texturedatamanager_p.h>
 #include <Qt3DRender/private/renderer_p.h>
 #include <Qt3DRender/private/scenemanager_p.h>
@@ -100,6 +101,7 @@
 #include <Qt3DRender/private/geometryrenderer_p.h>
 #include <Qt3DRender/private/objectpicker_p.h>
 #include <Qt3DRender/private/boundingvolumedebug_p.h>
+#include <Qt3DRender/private/nodemanagers_p.h>
 
 #include <Qt3DCore/qentity.h>
 #include <Qt3DCore/qtransform.h>
@@ -141,7 +143,7 @@ QRenderAspectPrivate::QRenderAspectPrivate(QRenderAspect::RenderType type)
     , m_cleanupJob(new Render::FrameCleanupJob(m_renderer))
     , m_worldTransformJob(new Render::UpdateWorldTransformJob())
     , m_updateBoundingVolumeJob(new Render::UpdateBoundingVolumeJob())
-    , m_calculateBoundingVolumeJob(new Render::CalculateBoundingVolumeJob(m_renderer))
+    , m_calculateBoundingVolumeJob(new Render::CalculateBoundingVolumeJob(m_renderer->nodeManagers()))
     , m_pickBoundingVolumeJob(new Render::PickBoundingVolumeJob(m_renderer))
 {
     initResources();
@@ -217,42 +219,44 @@ QRenderAspect::QRenderAspect(QRenderAspectPrivate &dd, QObject *parent)
 void QRenderAspect::registerBackendTypes()
 {
     Q_D(QRenderAspect);
-    registerBackendType<Qt3DCore::QEntity>(QBackendNodeFunctorPtr(new Render::RenderEntityFunctor(d->m_renderer)));
-    registerBackendType<Qt3DCore::QTransform>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::Transform, Render::TransformManager>(d->m_renderer->transformManager())));
-    registerBackendType<QMaterial>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::Material, Render::MaterialManager>(d->m_renderer->materialManager())));
-    registerBackendType<QTechnique>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::Technique, Render::TechniqueManager>(d->m_renderer->techniqueManager())));
-    registerBackendType<QAbstractTextureProvider>(QBackendNodeFunctorPtr(new Render::TextureFunctor(d->m_renderer->textureManager(), d->m_renderer->textureImageManager(), d->m_renderer->textureDataManager())));
-    registerBackendType<QShaderProgram>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::Shader, Render::ShaderManager>(d->m_renderer->shaderManager())));
-    registerBackendType<QEffect>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::Effect, Render::EffectManager>(d->m_renderer->effectManager())));
-    registerBackendType<QAnnotation>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::Annotation, Render::CriterionManager>(d->m_renderer->criterionManager())));
-    registerBackendType<Qt3DCore::QCameraLens>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::CameraLens, Render::CameraManager>(d->m_renderer->cameraManager())));
-    registerBackendType<QLayer>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::Layer, Render::LayerManager>(d->m_renderer->layerManager())));
-    registerBackendType<QRenderPass>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::RenderPass, Render::RenderPassManager>(d->m_renderer->renderPassManager())));
-    registerBackendType<QAbstractSceneLoader>(QBackendNodeFunctorPtr(new Render::RenderSceneFunctor(d->m_renderer->sceneManager())));
-    registerBackendType<QRenderTarget>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::RenderTarget, Render::RenderTargetManager>(d->m_renderer->renderTargetManager())));
-    registerBackendType<QRenderAttachment>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::RenderAttachment, Render::AttachmentManager>(d->m_renderer->attachmentManager())));
-    registerBackendType<QSortCriterion>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::SortCriterion, Render::SortCriterionManager>(d->m_renderer->sortCriterionManager())));
-    registerBackendType<QClearBuffer>(QBackendNodeFunctorPtr(new Render::FrameGraphNodeFunctor<Render::ClearBuffer, QClearBuffer>(d->m_renderer->frameGraphManager())));
-    registerBackendType<QTechniqueFilter>(QBackendNodeFunctorPtr(new Render::FrameGraphNodeFunctor<Render::TechniqueFilter, QTechniqueFilter>(d->m_renderer->frameGraphManager())));
-    registerBackendType<QViewport>(QBackendNodeFunctorPtr(new Render::FrameGraphNodeFunctor<Render::ViewportNode, QViewport>(d->m_renderer->frameGraphManager())));
-    registerBackendType<QRenderPassFilter>(QBackendNodeFunctorPtr(new Render::FrameGraphNodeFunctor<Render::RenderPassFilter, QRenderPassFilter>(d->m_renderer->frameGraphManager())));
-    registerBackendType<QCameraSelector>(QBackendNodeFunctorPtr(new Render::FrameGraphNodeFunctor<Render::CameraSelector, QCameraSelector>(d->m_renderer->frameGraphManager())));
-    registerBackendType<QRenderTargetSelector>(QBackendNodeFunctorPtr(new Render::FrameGraphNodeFunctor<Render::RenderTargetSelector, QRenderTargetSelector>(d->m_renderer->frameGraphManager())));
-    registerBackendType<QLayerFilter>(QBackendNodeFunctorPtr(new Render::FrameGraphNodeFunctor<Render::LayerFilterNode, QLayerFilter>(d->m_renderer->frameGraphManager())));
-    registerBackendType<QSortMethod>(QBackendNodeFunctorPtr(new Render::FrameGraphNodeFunctor<Render::SortMethod, QSortMethod>(d->m_renderer->frameGraphManager())));
-    registerBackendType<QFrameGraphSelector>(QBackendNodeFunctorPtr(new Render::FrameGraphNodeFunctor<Render::FrameGraphSubtreeSelector, QFrameGraphSelector>(d->m_renderer->frameGraphManager())));
+    Qt3DRender::Render::NodeManagers *nodeManagers = d->m_renderer->nodeManagers();
+
+    registerBackendType<Qt3DCore::QEntity>(QBackendNodeFunctorPtr(new Render::RenderEntityFunctor(nodeManagers)));
+    registerBackendType<Qt3DCore::QTransform>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::Transform, Render::TransformManager>(nodeManagers->transformManager())));
+    registerBackendType<QMaterial>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::Material, Render::MaterialManager>(nodeManagers->materialManager())));
+    registerBackendType<QTechnique>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::Technique, Render::TechniqueManager>(nodeManagers->techniqueManager())));
+    registerBackendType<QAbstractTextureProvider>(QBackendNodeFunctorPtr(new Render::TextureFunctor(nodeManagers->textureManager(), nodeManagers->textureImageManager(), nodeManagers->textureDataManager())));
+    registerBackendType<QShaderProgram>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::Shader, Render::ShaderManager>(nodeManagers->shaderManager())));
+    registerBackendType<QEffect>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::Effect, Render::EffectManager>(nodeManagers->effectManager())));
+    registerBackendType<QAnnotation>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::Annotation, Render::CriterionManager>(nodeManagers->criterionManager())));
+    registerBackendType<Qt3DCore::QCameraLens>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::CameraLens, Render::CameraManager>(nodeManagers->cameraManager())));
+    registerBackendType<QLayer>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::Layer, Render::LayerManager>(nodeManagers->layerManager())));
+    registerBackendType<QRenderPass>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::RenderPass, Render::RenderPassManager>(nodeManagers->renderPassManager())));
+    registerBackendType<QAbstractSceneLoader>(QBackendNodeFunctorPtr(new Render::RenderSceneFunctor(nodeManagers->sceneManager())));
+    registerBackendType<QRenderTarget>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::RenderTarget, Render::RenderTargetManager>(nodeManagers->renderTargetManager())));
+    registerBackendType<QRenderAttachment>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::RenderAttachment, Render::AttachmentManager>(nodeManagers->attachmentManager())));
+    registerBackendType<QSortCriterion>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::SortCriterion, Render::SortCriterionManager>(nodeManagers->sortCriterionManager())));
+    registerBackendType<QClearBuffer>(QBackendNodeFunctorPtr(new Render::FrameGraphNodeFunctor<Render::ClearBuffer, QClearBuffer>(nodeManagers->frameGraphManager())));
+    registerBackendType<QTechniqueFilter>(QBackendNodeFunctorPtr(new Render::FrameGraphNodeFunctor<Render::TechniqueFilter, QTechniqueFilter>(nodeManagers->frameGraphManager())));
+    registerBackendType<QViewport>(QBackendNodeFunctorPtr(new Render::FrameGraphNodeFunctor<Render::ViewportNode, QViewport>(nodeManagers->frameGraphManager())));
+    registerBackendType<QRenderPassFilter>(QBackendNodeFunctorPtr(new Render::FrameGraphNodeFunctor<Render::RenderPassFilter, QRenderPassFilter>(nodeManagers->frameGraphManager())));
+    registerBackendType<QCameraSelector>(QBackendNodeFunctorPtr(new Render::FrameGraphNodeFunctor<Render::CameraSelector, QCameraSelector>(nodeManagers->frameGraphManager())));
+    registerBackendType<QRenderTargetSelector>(QBackendNodeFunctorPtr(new Render::FrameGraphNodeFunctor<Render::RenderTargetSelector, QRenderTargetSelector>(nodeManagers->frameGraphManager())));
+    registerBackendType<QLayerFilter>(QBackendNodeFunctorPtr(new Render::FrameGraphNodeFunctor<Render::LayerFilterNode, QLayerFilter>(nodeManagers->frameGraphManager())));
+    registerBackendType<QSortMethod>(QBackendNodeFunctorPtr(new Render::FrameGraphNodeFunctor<Render::SortMethod, QSortMethod>(nodeManagers->frameGraphManager())));
+    registerBackendType<QFrameGraphSelector>(QBackendNodeFunctorPtr(new Render::FrameGraphNodeFunctor<Render::FrameGraphSubtreeSelector, QFrameGraphSelector>(nodeManagers->frameGraphManager())));
     registerBackendType<QFrameGraph>(QBackendNodeFunctorPtr(new Render::FrameGraphComponentFunctor(d->m_renderer)));
-    registerBackendType<QParameter>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::Parameter, Render::ParameterManager>(d->m_renderer->parameterManager())));
-    registerBackendType<QShaderData>(QBackendNodeFunctorPtr(new Render::RenderShaderDataFunctor(d->m_renderer->shaderDataManager())));
-    registerBackendType<QAbstractTextureImage>(QBackendNodeFunctorPtr(new Render::TextureImageFunctor(d->m_renderer->textureManager(), d->m_renderer->textureImageManager(), d->m_renderer->textureDataManager())));
-    registerBackendType<QStateSet>(QBackendNodeFunctorPtr(new Render::FrameGraphNodeFunctor<Render::StateSetNode, QStateSet>(d->m_renderer->frameGraphManager())));
-    registerBackendType<QNoDraw>(QBackendNodeFunctorPtr(new Render::FrameGraphNodeFunctor<Render::NoDraw, QNoDraw>(d->m_renderer->frameGraphManager())));
-    registerBackendType<QBuffer>(QBackendNodeFunctorPtr(new Render::BufferFunctor(d->m_renderer->bufferManager())));
-    registerBackendType<QAttribute>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::Attribute, Render::AttributeManager>(d->m_renderer->attributeManager())));
-    registerBackendType<QGeometry>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::Geometry, Render::GeometryManager>(d->m_renderer->geometryManager())));
-    registerBackendType<QGeometryRenderer>(QBackendNodeFunctorPtr(new Render::GeometryRendererFunctor(d->m_renderer->geometryRendererManager())));
-    registerBackendType<QObjectPicker>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::ObjectPicker, Render::ObjectPickerManager>(d->m_renderer->objectPickerManager())));
-    registerBackendType<QBoundingVolumeDebug>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::BoundingVolumeDebug, Render::BoundingVolumeDebugManager>(d->m_renderer->boundingVolumeDebugManager())));
+    registerBackendType<QParameter>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::Parameter, Render::ParameterManager>(nodeManagers->parameterManager())));
+    registerBackendType<QShaderData>(QBackendNodeFunctorPtr(new Render::RenderShaderDataFunctor(nodeManagers->shaderDataManager())));
+    registerBackendType<QAbstractTextureImage>(QBackendNodeFunctorPtr(new Render::TextureImageFunctor(nodeManagers->textureManager(), nodeManagers->textureImageManager(), nodeManagers->textureDataManager())));
+    registerBackendType<QStateSet>(QBackendNodeFunctorPtr(new Render::FrameGraphNodeFunctor<Render::StateSetNode, QStateSet>(nodeManagers->frameGraphManager())));
+    registerBackendType<QNoDraw>(QBackendNodeFunctorPtr(new Render::FrameGraphNodeFunctor<Render::NoDraw, QNoDraw>(nodeManagers->frameGraphManager())));
+    registerBackendType<QBuffer>(QBackendNodeFunctorPtr(new Render::BufferFunctor(nodeManagers->bufferManager())));
+    registerBackendType<QAttribute>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::Attribute, Render::AttributeManager>(nodeManagers->attributeManager())));
+    registerBackendType<QGeometry>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::Geometry, Render::GeometryManager>(nodeManagers->geometryManager())));
+    registerBackendType<QGeometryRenderer>(QBackendNodeFunctorPtr(new Render::GeometryRendererFunctor(nodeManagers->geometryRendererManager())));
+    registerBackendType<QObjectPicker>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::ObjectPicker, Render::ObjectPickerManager>(nodeManagers->objectPickerManager())));
+    registerBackendType<QBoundingVolumeDebug>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::BoundingVolumeDebug, Render::BoundingVolumeDebugManager>(nodeManagers->boundingVolumeDebugManager())));
 }
 
 void QRenderAspect::renderInitialize(QOpenGLContext *context)
@@ -287,6 +291,8 @@ QVector<Qt3DCore::QAspectJobPtr> QRenderAspect::jobsToExecute(qint64 time)
     // Create jobs to load in any meshes that are pending
     if (d->m_renderer != Q_NULLPTR && d->m_renderer->isRunning()) {
 
+        Render::NodeManagers *manager = d->m_renderer->nodeManagers();
+
         // Create the jobs to build the frame
         d->m_framePreparationJob->setRoot(d->m_renderer->renderSceneRoot());
         d->m_worldTransformJob->setRoot(d->m_renderer->renderSceneRoot());
@@ -294,16 +300,16 @@ QVector<Qt3DCore::QAspectJobPtr> QRenderAspect::jobsToExecute(qint64 time)
         d->m_calculateBoundingVolumeJob->setRoot(d->m_renderer->renderSceneRoot());
         d->m_pickBoundingVolumeJob->setRoot(d->m_renderer->renderSceneRoot());
 
-        const QVector<QNodeId> texturesPending = d->m_renderer->textureDataManager()->texturesPending();
+        const QVector<QNodeId> texturesPending = manager->textureDataManager()->texturesPending();
         Q_FOREACH (const QNodeId &textureId, texturesPending) {
             Render::LoadTextureDataJobPtr loadTextureJob(new Render::LoadTextureDataJob(textureId));
-            loadTextureJob->setRenderer(d->m_renderer);
+            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)
-        const QVector<Render::LoadSceneJobPtr> sceneJobs = d->m_renderer->sceneManager()->pendingSceneLoaderJobs();
+        const QVector<Render::LoadSceneJobPtr> sceneJobs = manager->sceneManager()->pendingSceneLoaderJobs();
         Q_FOREACH (Render::LoadSceneJobPtr job, sceneJobs) {
             job->setRenderer(d->m_renderer);
             jobs.append(job);
@@ -322,16 +328,18 @@ QVector<Qt3DCore::QAspectJobPtr> QRenderAspect::jobsToExecute(qint64 time)
         jobs.append(d->m_framePreparationJob);
         jobs.append(d->m_pickBoundingVolumeJob);
 
-
-        // Traverse the current framegraph and create jobs to populate
-        // RenderBins with RenderCommands
-        QVector<QAspectJobPtr> renderBinJobs = d->m_renderer->createRenderBinJobs();
-        // TODO: Add wrapper around ThreadWeaver::Collection
-        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);
+        // Do not create any more jobs when the platform surface is gone.
+        if (d->m_renderer->surface()) {
+            // Traverse the current framegraph and create jobs to populate
+            // RenderBins with RenderCommands
+            QVector<QAspectJobPtr> renderBinJobs = d->m_renderer->createRenderBinJobs();
+            // TODO: Add wrapper around ThreadWeaver::Collection
+            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);
     }
@@ -367,7 +375,7 @@ void QRenderAspect::setRootEntity(Qt3DCore::QEntity *rootObject)
     Q_D(QRenderAspect);
     QNodeVisitor visitor;
     visitor.traverse(rootObject, this, &QRenderAspect::visitNode);
-    d->m_renderer->setSceneGraphRoot(d->m_renderer->renderNodesManager()->lookupResource(rootObject->id()));
+    d->m_renderer->setSceneGraphRoot(d->m_renderer->nodeManagers()->lookupResource<Render::Entity, Render::EntityManager>(rootObject->id()));
 }
 
 void QRenderAspect::onInitialize(const QVariantMap &data)
@@ -379,11 +387,13 @@ void QRenderAspect::onInitialize(const QVariantMap &data)
 
         // Register the VSyncFrameAdvanceService to drive the aspect manager loop
         // depending on the vsync
-        services()->registerServiceProvider(Qt3DCore::QServiceLocator::FrameAdvanceService,
-                                            d->m_renderer->vsyncFrameAdvanceService());
+        if (d->m_aspectManager) {
+            services()->registerServiceProvider(Qt3DCore::QServiceLocator::FrameAdvanceService,
+                                                d->m_renderer->vsyncFrameAdvanceService());
+        }
 
         d->m_renderer->setQRenderAspect(this);
-        d->m_renderer->createAllocators();
+        d->m_renderer->createAllocators(jobManager());
         d->m_initialized = true;
     }
 
@@ -395,7 +405,8 @@ void QRenderAspect::onInitialize(const QVariantMap &data)
     if (surface)
         d->setSurface(surface);
 
-    d->m_renderer->registerEventFilter(services()->eventFilterService());
+    if (d->m_aspectManager)
+        d->m_renderer->registerEventFilter(services()->eventFilterService());
 }
 
 void QRenderAspect::onStartup()
diff --git a/src/render/graphicshelpers/graphicscontext.cpp b/src/render/graphicshelpers/graphicscontext.cpp
index 7972e85e3..7d29a784a 100644
--- a/src/render/graphicshelpers/graphicscontext.cpp
+++ b/src/render/graphicshelpers/graphicscontext.cpp
@@ -50,6 +50,7 @@
 #include <Qt3DRender/private/rendertarget_p.h>
 #include <Qt3DRender/private/graphicshelperinterface_p.h>
 #include <Qt3DRender/private/renderer_p.h>
+#include <Qt3DRender/private/nodemanagers_p.h>
 #include <Qt3DRender/private/managers_p.h>
 #include <Qt3DRender/private/attachmentpack_p.h>
 #include <QOpenGLShaderProgram>
@@ -400,9 +401,10 @@ void GraphicsContext::activateRenderTarget(RenderTarget *renderTarget, const Att
             fboId = m_renderTargets.value(renderTarget->peerUuid());
 
             // We need to check if  one of the attachment was resized
+            TextureManager *textureManager = m_renderer->nodeManagers()->textureManager();
             bool needsResize = false;
             Q_FOREACH (const Attachment &attachment, attachments.attachments()) {
-                Texture *rTex = m_renderer->textureManager()->lookupResource(attachment.m_textureUuid);
+                Texture *rTex = textureManager->lookupResource(attachment.m_textureUuid);
                 if (rTex != Q_NULLPTR)
                     needsResize |= rTex->isTextureReset();
             }
@@ -423,8 +425,9 @@ void GraphicsContext::bindFrameBufferAttachmentHelper(GLuint fboId, const Attach
     // Set FBO attachments
 
     QSize fboSize;
+    TextureManager *textureManager = m_renderer->nodeManagers()->textureManager();
     Q_FOREACH (const Attachment &attachment, attachments.attachments()) {
-        Texture *rTex = m_renderer->textureManager()->lookupResource(attachment.m_textureUuid);
+        Texture *rTex =textureManager->lookupResource(attachment.m_textureUuid);
         if (rTex != Q_NULLPTR) {
             QOpenGLTexture *glTex = rTex->getOrCreateGLTexture();
             if (glTex != Q_NULLPTR) {
@@ -612,12 +615,12 @@ QGraphicsApiFilter *GraphicsContext::contextInfo() const
  * it is simulated with a loop.
  */
 void GraphicsContext::drawElementsInstanced(GLenum primitiveType,
-                                             GLsizei primitiveCount,
-                                             GLint indexType,
-                                             void *indices,
-                                             GLsizei instances,
-                                             GLint baseVertex,
-                                             GLint baseInstance)
+                                            GLsizei primitiveCount,
+                                            GLint indexType,
+                                            void *indices,
+                                            GLsizei instances,
+                                            GLint baseVertex,
+                                            GLint baseInstance)
 {
     m_glHelper->drawElementsInstanced(primitiveType,
                                       primitiveCount,
@@ -632,9 +635,9 @@ void GraphicsContext::drawElementsInstanced(GLenum primitiveType,
  * Wraps an OpenGL call to glDrawArraysInstanced.
  */
 void GraphicsContext::drawArraysInstanced(GLenum primitiveType,
-                                           GLint first,
-                                           GLsizei count,
-                                           GLsizei instances)
+                                          GLint first,
+                                          GLsizei count,
+                                          GLsizei instances)
 {
     m_glHelper->drawArraysInstanced(primitiveType,
                                     first,
@@ -646,10 +649,10 @@ void GraphicsContext::drawArraysInstanced(GLenum primitiveType,
  * Wraps an OpenGL call to glDrawElements.
  */
 void GraphicsContext::drawElements(GLenum primitiveType,
-                                    GLsizei primitiveCount,
-                                    GLint indexType,
-                                    void *indices,
-                                    GLint baseVertex)
+                                   GLsizei primitiveCount,
+                                   GLint indexType,
+                                   void *indices,
+                                   GLint baseVertex)
 {
     m_glHelper->drawElements(primitiveType,
                              primitiveCount,
@@ -662,8 +665,8 @@ void GraphicsContext::drawElements(GLenum primitiveType,
  * Wraps an OpenGL call to glDrawArrays.
  */
 void GraphicsContext::drawArrays(GLenum primitiveType,
-                                  GLint first,
-                                  GLsizei count)
+                                 GLint first,
+                                 GLsizei count)
 {
     m_glHelper->drawArrays(primitiveType,
                            first,
@@ -848,12 +851,14 @@ void GraphicsContext::setUniforms(QUniformPack &uniforms)
 
     // Set the pinned texture of the previous material texture
     // to pinable so that we should easily find an available texture unit
+    NodeManagers *manager = m_renderer->nodeManagers();
+
     deactivateTexturesWithScope(TextureScopeMaterial);
     // Update the uniforms with the correct texture unit id's
     const QHash<QString, const QUniformValue *> &uniformValues = uniforms.uniforms();
     for (int i = 0; i < uniforms.textures().size(); ++i) {
         const QUniformPack::NamedTexture &namedTex = uniforms.textures().at(i);
-        Texture *t = m_renderer->textureManager()->lookupResource(namedTex.texId);
+        Texture *t = manager->lookupResource<Texture, TextureManager>(namedTex.texId);
         const TextureUniform *texUniform = Q_NULLPTR;
         // TO DO : Rework the way textures are loaded
         if (t != Q_NULLPTR) {
@@ -873,8 +878,8 @@ void GraphicsContext::setUniforms(QUniformPack &uniforms)
     for (int i = 0; i < blockToUbos.length(); ++i) {
         const ShaderUniformBlock &block = m_activeShader->uniformBlock(blockToUbos[i].m_blockIndex);
         if (block.m_index != -1 && block.m_size > 0) {
-            ubo = m_renderer->uboManager()->lookupResource(ShaderDataShaderUboKey(blockToUbos[i].m_shaderDataID,
-                                                                                                 m_activeShader->peerUuid()));
+            ubo = manager->lookupResource<UniformBuffer, UBOManager>(ShaderDataShaderUboKey(blockToUbos[i].m_shaderDataID,
+                                                                                            m_activeShader->peerUuid()));
             // bind Uniform Block of index ubos[i].m_index to binding point i
             bindUniformBlock(m_activeShader->getOrCreateProgram(this)->programId(), block.m_index, i);
             // bind the UBO to the binding point i
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);