Added AbstractRenderer pointer to RenderBackendNode

Modified all node functors to pass QRenderAspect's renderer instance
to all newly created backend nodes

Change-Id: Iffa4941bff53f6acf87f46789219c7ae2f123615
Reviewed-by: Sean Harmer <sean.harmer@kdab.com>

22 files changed, 116 insertions, 69 deletions

diff --git a/src/render/backend/backendnode.cpp b/src/render/backend/backendnode.cpp
index 4e8a9e312..3051e6c90 100644
--- a/src/render/backend/backendnode.cpp
+++ b/src/render/backend/backendnode.cpp
@@ -48,6 +48,7 @@ namespace Render {
 
 BackendNode::BackendNode(Mode mode)
     : QBackendNode(mode)
+    , m_renderer(Q_NULLPTR)
 {
 }
 
@@ -55,6 +56,10 @@ BackendNode::~BackendNode()
 {
 }
 
+void BackendNode::setRenderer(AbstractRenderer *renderer)
+{
+    m_renderer = renderer;
+}
 
 } // namespace Render
 } // namespace Qt3DRender
diff --git a/src/render/backend/backendnode_p.h b/src/render/backend/backendnode_p.h
index 23603d28d..b4996051c 100644
--- a/src/render/backend/backendnode_p.h
+++ b/src/render/backend/backendnode_p.h
@@ -53,6 +53,7 @@
 
 #include <Qt3DRender/qt3drender_global.h>
 #include <Qt3DCore/qbackendnode.h>
+#include <Qt3DRender/private/abstractrenderer_p.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -65,6 +66,11 @@ class BackendNode : public Qt3DCore::QBackendNode
 public:
     BackendNode(Qt3DCore::QBackendNode::Mode mode = ReadOnly);
     ~BackendNode();
+
+    void setRenderer(AbstractRenderer *renderer);
+
+private:
+    AbstractRenderer *m_renderer;
 };
 
 } // namespace Render
diff --git a/src/render/backend/entity.cpp b/src/render/backend/entity.cpp
index 214e30b72..728ef17ff 100644
--- a/src/render/backend/entity.cpp
+++ b/src/render/backend/entity.cpp
@@ -517,8 +517,9 @@ QNodeId Entity::componentUuid<ComputeJob>() const { return m_computeComponent; }
 template<>
 QList<Qt3DCore::QNodeId> Entity::componentsUuid<Light>() const { return m_lightComponents; }
 
-RenderEntityFunctor::RenderEntityFunctor(NodeManagers *manager)
+RenderEntityFunctor::RenderEntityFunctor(AbstractRenderer *renderer, NodeManagers *manager)
     : m_nodeManagers(manager)
+    , m_renderer(renderer)
 {
 }
 
@@ -529,6 +530,7 @@ Qt3DCore::QBackendNode *RenderEntityFunctor::create(Qt3DCore::QNode *frontend) c
     entity->setNodeManagers(m_nodeManagers);
     entity->setHandle(renderNodeHandle);
     entity->setPeer(frontend);
+    entity->setRenderer(m_renderer);
     return entity;
 }
 
diff --git a/src/render/backend/entity_p.h b/src/render/backend/entity_p.h
index c49ea533a..fdf4038b1 100644
--- a/src/render/backend/entity_p.h
+++ b/src/render/backend/entity_p.h
@@ -278,13 +278,14 @@ Q_AUTOTEST_EXPORT QList<Qt3DCore::QNodeId> Entity::componentsUuid<Light>() const
 class RenderEntityFunctor : public Qt3DCore::QBackendNodeMapper
 {
 public:
-    explicit RenderEntityFunctor(NodeManagers *manager);
+    explicit RenderEntityFunctor(AbstractRenderer *renderer, NodeManagers *manager);
     Qt3DCore::QBackendNode *create(Qt3DCore::QNode *frontend) const Q_DECL_OVERRIDE;
     Qt3DCore::QBackendNode *get(Qt3DCore::QNodeId id) const Q_DECL_OVERRIDE;
     void destroy(Qt3DCore::QNodeId id) const Q_DECL_OVERRIDE;
 
 private:
     NodeManagers *m_nodeManagers;
+    AbstractRenderer *m_renderer;
 };
 
 } // namespace Render
diff --git a/src/render/backend/nodefunctor_p.h b/src/render/backend/nodefunctor_p.h
index 61bd33173..1fb1a8d82 100644
--- a/src/render/backend/nodefunctor_p.h
+++ b/src/render/backend/nodefunctor_p.h
@@ -53,6 +53,7 @@
 
 #include <Qt3DCore/qbackendnode.h>
 #include <Qt3DCore/qnode.h>
+#include <Qt3DRender/private/backendnode_p.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -60,12 +61,15 @@ namespace Qt3DRender {
 
 namespace Render {
 
+class AbstractRenderer;
+
 template<class Backend, class Manager>
 class NodeFunctor : public Qt3DCore::QBackendNodeMapper
 {
 public:
-    explicit NodeFunctor(Manager *manager)
+    explicit NodeFunctor(AbstractRenderer *renderer, Manager *manager)
         : m_manager(manager)
+        , m_renderer(renderer)
     {
     }
 
@@ -73,6 +77,7 @@ public:
     {
         Backend *backend = m_manager->getOrCreateResource(frontend->id());
         backend->setPeer(frontend);
+        backend->setRenderer(m_renderer);
         return backend;
     }
 
@@ -88,6 +93,7 @@ public:
 
 private:
     Manager *m_manager;
+    AbstractRenderer *m_renderer;
 };
 
 } // namespace Render
diff --git a/src/render/backend/renderersettings.cpp b/src/render/backend/renderersettings.cpp
index 973ef3f17..148ce16fb 100644
--- a/src/render/backend/renderersettings.cpp
+++ b/src/render/backend/renderersettings.cpp
@@ -94,6 +94,7 @@ Qt3DCore::QBackendNode *RendererSettingsFunctor::create(Qt3DCore::QNode *fronten
 
     RendererSettings *settings = new RendererSettings;
     settings->setPeer(settingsFrontend);
+    settings->setRenderer(m_renderer);
     m_renderer->setSettings(settings);
     return settings;
 }
diff --git a/src/render/framegraph/framegraphnode_p.h b/src/render/framegraph/framegraphnode_p.h
index 2effeb385..77ceb1a5a 100644
--- a/src/render/framegraph/framegraphnode_p.h
+++ b/src/render/framegraph/framegraphnode_p.h
@@ -126,8 +126,9 @@ template<typename Backend, typename Frontend>
 class FrameGraphNodeFunctor : public Qt3DCore::QBackendNodeMapper
 {
 public:
-    explicit FrameGraphNodeFunctor(FrameGraphManager *manager)
+    explicit FrameGraphNodeFunctor(AbstractRenderer *renderer, FrameGraphManager *manager)
         : m_manager(manager)
+        , m_renderer(renderer)
     {
     }
 
@@ -155,6 +156,7 @@ protected:
                 Backend *backend = new Backend();
                 backend->setFrameGraphManager(m_manager);
                 backend->setPeer(f);
+                backend->setRenderer(m_renderer);
                 QFrameGraphNode *parentFGNode = static_cast<QFrameGraphNode *>(n)->parentFrameGraphNode();
                 if (parentFGNode)
                     backend->setParentId(parentFGNode->id());
@@ -168,6 +170,7 @@ protected:
 
 private:
     FrameGraphManager *m_manager;
+    AbstractRenderer *m_renderer;
 };
 
 class FrameGraphComponentFunctor : public Qt3DCore::QBackendNodeMapper
diff --git a/src/render/frontend/qrenderaspect.cpp b/src/render/frontend/qrenderaspect.cpp
index ca1c4e604..80e7b8488 100644
--- a/src/render/frontend/qrenderaspect.cpp
+++ b/src/render/frontend/qrenderaspect.cpp
@@ -247,50 +247,50 @@ void QRenderAspect::registerBackendTypes()
 {
     Q_D(QRenderAspect);
 
-    registerBackendType<Qt3DCore::QEntity>(QBackendNodeMapperPtr(new Render::RenderEntityFunctor(d->m_nodeManagers)));
-    registerBackendType<Qt3DCore::QTransform>(QBackendNodeMapperPtr(new Render::NodeFunctor<Render::Transform, Render::TransformManager>(d->m_nodeManagers->transformManager())));
-    registerBackendType<QMaterial>(QBackendNodeMapperPtr(new Render::NodeFunctor<Render::Material, Render::MaterialManager>(d->m_nodeManagers->materialManager())));
-    registerBackendType<QTechnique>(QBackendNodeMapperPtr(new Render::NodeFunctor<Render::Technique, Render::TechniqueManager>(d->m_nodeManagers->techniqueManager())));
-    registerBackendType<QAbstractTextureProvider>(QBackendNodeMapperPtr(new Render::TextureFunctor(d->m_nodeManagers->textureManager(), d->m_nodeManagers->textureImageManager(), d->m_nodeManagers->textureDataManager())));
-    registerBackendType<QShaderProgram>(QBackendNodeMapperPtr(new Render::NodeFunctor<Render::Shader, Render::ShaderManager>(d->m_nodeManagers->shaderManager())));
-    registerBackendType<QEffect>(QBackendNodeMapperPtr(new Render::NodeFunctor<Render::Effect, Render::EffectManager>(d->m_nodeManagers->effectManager())));
-    registerBackendType<QAnnotation>(QBackendNodeMapperPtr(new Render::NodeFunctor<Render::Annotation, Render::CriterionManager>(d->m_nodeManagers->criterionManager())));
-    registerBackendType<Qt3DRender::QCameraLens>(QBackendNodeMapperPtr(new Render::NodeFunctor<Render::CameraLens, Render::CameraManager>(d->m_nodeManagers->cameraManager())));
-    registerBackendType<QLayer>(QBackendNodeMapperPtr(new Render::NodeFunctor<Render::Layer, Render::LayerManager>(d->m_nodeManagers->layerManager())));
-    registerBackendType<QRenderPass>(QBackendNodeMapperPtr(new Render::NodeFunctor<Render::RenderPass, Render::RenderPassManager>(d->m_nodeManagers->renderPassManager())));
-    registerBackendType<QAbstractSceneLoader>(QBackendNodeMapperPtr(new Render::RenderSceneFunctor(d->m_nodeManagers->sceneManager())));
-    registerBackendType<QRenderTarget>(QBackendNodeMapperPtr(new Render::NodeFunctor<Render::RenderTarget, Render::RenderTargetManager>(d->m_nodeManagers->renderTargetManager())));
-    registerBackendType<QRenderAttachment>(QBackendNodeMapperPtr(new Render::NodeFunctor<Render::RenderAttachment, Render::AttachmentManager>(d->m_nodeManagers->attachmentManager())));
-    registerBackendType<QSortCriterion>(QBackendNodeMapperPtr(new Render::NodeFunctor<Render::SortCriterion, Render::SortCriterionManager>(d->m_nodeManagers->sortCriterionManager())));
-    registerBackendType<QClearBuffer>(QBackendNodeMapperPtr(new Render::FrameGraphNodeFunctor<Render::ClearBuffer, QClearBuffer>(d->m_nodeManagers->frameGraphManager())));
-    registerBackendType<QTechniqueFilter>(QBackendNodeMapperPtr(new Render::FrameGraphNodeFunctor<Render::TechniqueFilter, QTechniqueFilter>(d->m_nodeManagers->frameGraphManager())));
-    registerBackendType<QViewport>(QBackendNodeMapperPtr(new Render::FrameGraphNodeFunctor<Render::ViewportNode, QViewport>(d->m_nodeManagers->frameGraphManager())));
-    registerBackendType<QRenderPassFilter>(QBackendNodeMapperPtr(new Render::FrameGraphNodeFunctor<Render::RenderPassFilter, QRenderPassFilter>(d->m_nodeManagers->frameGraphManager())));
-    registerBackendType<QCameraSelector>(QBackendNodeMapperPtr(new Render::FrameGraphNodeFunctor<Render::CameraSelector, QCameraSelector>(d->m_nodeManagers->frameGraphManager())));
-    registerBackendType<QRenderTargetSelector>(QBackendNodeMapperPtr(new Render::FrameGraphNodeFunctor<Render::RenderTargetSelector, QRenderTargetSelector>(d->m_nodeManagers->frameGraphManager())));
-    registerBackendType<QRenderSurfaceSelector>(QBackendNodeMapperPtr(new Render::FrameGraphNodeFunctor<Render::RenderSurfaceSelector, QRenderSurfaceSelector>(d->m_nodeManagers->frameGraphManager())));
-    registerBackendType<QLayerFilter>(QBackendNodeMapperPtr(new Render::FrameGraphNodeFunctor<Render::LayerFilterNode, QLayerFilter>(d->m_nodeManagers->frameGraphManager())));
-    registerBackendType<QSortMethod>(QBackendNodeMapperPtr(new Render::FrameGraphNodeFunctor<Render::SortMethod, QSortMethod>(d->m_nodeManagers->frameGraphManager())));
-    registerBackendType<QFrameGraphSelector>(QBackendNodeMapperPtr(new Render::FrameGraphNodeFunctor<Render::FrameGraphSubtreeSelector, QFrameGraphSelector>(d->m_nodeManagers->frameGraphManager())));
+    registerBackendType<Qt3DCore::QEntity>(QBackendNodeMapperPtr(new Render::RenderEntityFunctor(d->m_renderer, d->m_nodeManagers)));
+    registerBackendType<Qt3DCore::QTransform>(QBackendNodeMapperPtr(new Render::NodeFunctor<Render::Transform, Render::TransformManager>(d->m_renderer, d->m_nodeManagers->transformManager())));
+    registerBackendType<QMaterial>(QBackendNodeMapperPtr(new Render::NodeFunctor<Render::Material, Render::MaterialManager>(d->m_renderer, d->m_nodeManagers->materialManager())));
+    registerBackendType<QTechnique>(QBackendNodeMapperPtr(new Render::NodeFunctor<Render::Technique, Render::TechniqueManager>(d->m_renderer, d->m_nodeManagers->techniqueManager())));
+    registerBackendType<QAbstractTextureProvider>(QBackendNodeMapperPtr(new Render::TextureFunctor(d->m_renderer, d->m_nodeManagers->textureManager(), d->m_nodeManagers->textureImageManager(), d->m_nodeManagers->textureDataManager())));
+    registerBackendType<QShaderProgram>(QBackendNodeMapperPtr(new Render::NodeFunctor<Render::Shader, Render::ShaderManager>(d->m_renderer, d->m_nodeManagers->shaderManager())));
+    registerBackendType<QEffect>(QBackendNodeMapperPtr(new Render::NodeFunctor<Render::Effect, Render::EffectManager>(d->m_renderer, d->m_nodeManagers->effectManager())));
+    registerBackendType<QAnnotation>(QBackendNodeMapperPtr(new Render::NodeFunctor<Render::Annotation, Render::CriterionManager>(d->m_renderer, d->m_nodeManagers->criterionManager())));
+    registerBackendType<Qt3DRender::QCameraLens>(QBackendNodeMapperPtr(new Render::NodeFunctor<Render::CameraLens, Render::CameraManager>(d->m_renderer, d->m_nodeManagers->cameraManager())));
+    registerBackendType<QLayer>(QBackendNodeMapperPtr(new Render::NodeFunctor<Render::Layer, Render::LayerManager>(d->m_renderer, d->m_nodeManagers->layerManager())));
+    registerBackendType<QRenderPass>(QBackendNodeMapperPtr(new Render::NodeFunctor<Render::RenderPass, Render::RenderPassManager>(d->m_renderer, d->m_nodeManagers->renderPassManager())));
+    registerBackendType<QAbstractSceneLoader>(QBackendNodeMapperPtr(new Render::RenderSceneFunctor(d->m_renderer, d->m_nodeManagers->sceneManager())));
+    registerBackendType<QRenderTarget>(QBackendNodeMapperPtr(new Render::NodeFunctor<Render::RenderTarget, Render::RenderTargetManager>(d->m_renderer, d->m_nodeManagers->renderTargetManager())));
+    registerBackendType<QRenderAttachment>(QBackendNodeMapperPtr(new Render::NodeFunctor<Render::RenderAttachment, Render::AttachmentManager>(d->m_renderer, d->m_nodeManagers->attachmentManager())));
+    registerBackendType<QSortCriterion>(QBackendNodeMapperPtr(new Render::NodeFunctor<Render::SortCriterion, Render::SortCriterionManager>(d->m_renderer, d->m_nodeManagers->sortCriterionManager())));
+    registerBackendType<QClearBuffer>(QBackendNodeMapperPtr(new Render::FrameGraphNodeFunctor<Render::ClearBuffer, QClearBuffer>(d->m_renderer, d->m_nodeManagers->frameGraphManager())));
+    registerBackendType<QTechniqueFilter>(QBackendNodeMapperPtr(new Render::FrameGraphNodeFunctor<Render::TechniqueFilter, QTechniqueFilter>(d->m_renderer, d->m_nodeManagers->frameGraphManager())));
+    registerBackendType<QViewport>(QBackendNodeMapperPtr(new Render::FrameGraphNodeFunctor<Render::ViewportNode, QViewport>(d->m_renderer, d->m_nodeManagers->frameGraphManager())));
+    registerBackendType<QRenderPassFilter>(QBackendNodeMapperPtr(new Render::FrameGraphNodeFunctor<Render::RenderPassFilter, QRenderPassFilter>(d->m_renderer, d->m_nodeManagers->frameGraphManager())));
+    registerBackendType<QCameraSelector>(QBackendNodeMapperPtr(new Render::FrameGraphNodeFunctor<Render::CameraSelector, QCameraSelector>(d->m_renderer, d->m_nodeManagers->frameGraphManager())));
+    registerBackendType<QRenderTargetSelector>(QBackendNodeMapperPtr(new Render::FrameGraphNodeFunctor<Render::RenderTargetSelector, QRenderTargetSelector>(d->m_renderer, d->m_nodeManagers->frameGraphManager())));
+    registerBackendType<QRenderSurfaceSelector>(QBackendNodeMapperPtr(new Render::FrameGraphNodeFunctor<Render::RenderSurfaceSelector, QRenderSurfaceSelector>(d->m_renderer, d->m_nodeManagers->frameGraphManager())));
+    registerBackendType<QLayerFilter>(QBackendNodeMapperPtr(new Render::FrameGraphNodeFunctor<Render::LayerFilterNode, QLayerFilter>(d->m_renderer, d->m_nodeManagers->frameGraphManager())));
+    registerBackendType<QSortMethod>(QBackendNodeMapperPtr(new Render::FrameGraphNodeFunctor<Render::SortMethod, QSortMethod>(d->m_renderer, d->m_nodeManagers->frameGraphManager())));
+    registerBackendType<QFrameGraphSelector>(QBackendNodeMapperPtr(new Render::FrameGraphNodeFunctor<Render::FrameGraphSubtreeSelector, QFrameGraphSelector>(d->m_renderer, d->m_nodeManagers->frameGraphManager())));
     registerBackendType<QFrameGraph>(QBackendNodeMapperPtr(new Render::FrameGraphComponentFunctor(d->m_renderer)));
-    registerBackendType<QParameter>(QBackendNodeMapperPtr(new Render::NodeFunctor<Render::Parameter, Render::ParameterManager>(d->m_nodeManagers->parameterManager())));
-    registerBackendType<QShaderData>(QBackendNodeMapperPtr(new Render::RenderShaderDataFunctor(d->m_nodeManagers)));
-    registerBackendType<QAbstractTextureImage>(QBackendNodeMapperPtr(new Render::TextureImageFunctor(d->m_nodeManagers->textureManager(), d->m_nodeManagers->textureImageManager(), d->m_nodeManagers->textureDataManager())));
-    registerBackendType<QStateSet>(QBackendNodeMapperPtr(new Render::FrameGraphNodeFunctor<Render::StateSetNode, QStateSet>(d->m_nodeManagers->frameGraphManager())));
-    registerBackendType<QNoDraw>(QBackendNodeMapperPtr(new Render::FrameGraphNodeFunctor<Render::NoDraw, QNoDraw>(d->m_nodeManagers->frameGraphManager())));
-    registerBackendType<QBuffer>(QBackendNodeMapperPtr(new Render::BufferFunctor(d->m_nodeManagers->bufferManager())));
-    registerBackendType<QAttribute>(QBackendNodeMapperPtr(new Render::NodeFunctor<Render::Attribute, Render::AttributeManager>(d->m_nodeManagers->attributeManager())));
-    registerBackendType<QGeometry>(QBackendNodeMapperPtr(new Render::NodeFunctor<Render::Geometry, Render::GeometryManager>(d->m_nodeManagers->geometryManager())));
-    registerBackendType<QGeometryRenderer>(QBackendNodeMapperPtr(new Render::GeometryRendererFunctor(d->m_nodeManagers->geometryRendererManager())));
-    registerBackendType<QObjectPicker>(QBackendNodeMapperPtr(new Render::NodeFunctor<Render::ObjectPicker, Render::ObjectPickerManager>(d->m_nodeManagers->objectPickerManager())));
-    registerBackendType<QBoundingVolumeDebug>(QBackendNodeMapperPtr(new Render::NodeFunctor<Render::BoundingVolumeDebug, Render::BoundingVolumeDebugManager>(d->m_nodeManagers->boundingVolumeDebugManager())));
-    registerBackendType<QFrustumCulling>(QBackendNodeMapperPtr(new Render::FrameGraphNodeFunctor<Render::FrustumCulling, QFrustumCulling>(d->m_nodeManagers->frameGraphManager())));
-    registerBackendType<QLight>(QBackendNodeMapperPtr(new Render::RenderLightFunctor(d->m_nodeManagers)));
-    registerBackendType<QLighting>(QBackendNodeMapperPtr(new Render::FrameGraphNodeFunctor<Render::Lighting, QLighting>(d->m_nodeManagers->frameGraphManager())));
-    registerBackendType<QDispatchCompute>(QBackendNodeMapperPtr(new Render::FrameGraphNodeFunctor<Render::DispatchCompute, QDispatchCompute>(d->m_nodeManagers->frameGraphManager())));
-    registerBackendType<QComputeJob>(QBackendNodeMapperPtr(new Render::NodeFunctor<Render::ComputeJob, Render::ComputeJobManager>(d->m_nodeManagers->computeJobManager())));
+    registerBackendType<QParameter>(QBackendNodeMapperPtr(new Render::NodeFunctor<Render::Parameter, Render::ParameterManager>(d->m_renderer, d->m_nodeManagers->parameterManager())));
+    registerBackendType<QShaderData>(QBackendNodeMapperPtr(new Render::RenderShaderDataFunctor(d->m_renderer, d->m_nodeManagers)));
+    registerBackendType<QAbstractTextureImage>(QBackendNodeMapperPtr(new Render::TextureImageFunctor(d->m_renderer, d->m_nodeManagers->textureManager(), d->m_nodeManagers->textureImageManager(), d->m_nodeManagers->textureDataManager())));
+    registerBackendType<QStateSet>(QBackendNodeMapperPtr(new Render::FrameGraphNodeFunctor<Render::StateSetNode, QStateSet>(d->m_renderer, d->m_nodeManagers->frameGraphManager())));
+    registerBackendType<QNoDraw>(QBackendNodeMapperPtr(new Render::FrameGraphNodeFunctor<Render::NoDraw, QNoDraw>(d->m_renderer, d->m_nodeManagers->frameGraphManager())));
+    registerBackendType<QBuffer>(QBackendNodeMapperPtr(new Render::BufferFunctor(d->m_renderer, d->m_nodeManagers->bufferManager())));
+    registerBackendType<QAttribute>(QBackendNodeMapperPtr(new Render::NodeFunctor<Render::Attribute, Render::AttributeManager>(d->m_renderer, d->m_nodeManagers->attributeManager())));
+    registerBackendType<QGeometry>(QBackendNodeMapperPtr(new Render::NodeFunctor<Render::Geometry, Render::GeometryManager>(d->m_renderer, d->m_nodeManagers->geometryManager())));
+    registerBackendType<QGeometryRenderer>(QBackendNodeMapperPtr(new Render::GeometryRendererFunctor(d->m_renderer, d->m_nodeManagers->geometryRendererManager())));
+    registerBackendType<QObjectPicker>(QBackendNodeMapperPtr(new Render::NodeFunctor<Render::ObjectPicker, Render::ObjectPickerManager>(d->m_renderer, d->m_nodeManagers->objectPickerManager())));
+    registerBackendType<QBoundingVolumeDebug>(QBackendNodeMapperPtr(new Render::NodeFunctor<Render::BoundingVolumeDebug, Render::BoundingVolumeDebugManager>(d->m_renderer, d->m_nodeManagers->boundingVolumeDebugManager())));
+    registerBackendType<QFrustumCulling>(QBackendNodeMapperPtr(new Render::FrameGraphNodeFunctor<Render::FrustumCulling, QFrustumCulling>(d->m_renderer, d->m_nodeManagers->frameGraphManager())));
+    registerBackendType<QLight>(QBackendNodeMapperPtr(new Render::RenderLightFunctor(d->m_renderer, d->m_nodeManagers)));
+    registerBackendType<QLighting>(QBackendNodeMapperPtr(new Render::FrameGraphNodeFunctor<Render::Lighting, QLighting>(d->m_renderer, d->m_nodeManagers->frameGraphManager())));
+    registerBackendType<QDispatchCompute>(QBackendNodeMapperPtr(new Render::FrameGraphNodeFunctor<Render::DispatchCompute, QDispatchCompute>(d->m_renderer, d->m_nodeManagers->frameGraphManager())));
+    registerBackendType<QComputeJob>(QBackendNodeMapperPtr(new Render::NodeFunctor<Render::ComputeJob, Render::ComputeJobManager>(d->m_renderer, d->m_nodeManagers->computeJobManager())));
     registerBackendType<QRendererSettings>(QBackendNodeMapperPtr(new Render::RendererSettingsFunctor(d->m_renderer)));
-    registerBackendType<QRenderState>(QBackendNodeMapperPtr(new Render::NodeFunctor<Render::RenderStateNode, Render::RenderStateManager>(d->m_nodeManagers->renderStateManager())));
+    registerBackendType<QRenderState>(QBackendNodeMapperPtr(new Render::NodeFunctor<Render::RenderStateNode, Render::RenderStateManager>(d->m_renderer, d->m_nodeManagers->renderStateManager())));
 }
 
 void QRenderAspect::renderInitialize(QOpenGLContext *context)
diff --git a/src/render/geometry/buffer.cpp b/src/render/geometry/buffer.cpp
index 4246880b8..3389172e0 100644
--- a/src/render/geometry/buffer.cpp
+++ b/src/render/geometry/buffer.cpp
@@ -144,8 +144,9 @@ void Buffer::unsetDirty()
     m_bufferDirty = false;
 }
 
-BufferFunctor::BufferFunctor(BufferManager *manager)
+BufferFunctor::BufferFunctor(AbstractRenderer *renderer, BufferManager *manager)
     : m_manager(manager)
+    , m_renderer(renderer)
 {
 }
 
@@ -154,6 +155,7 @@ Qt3DCore::QBackendNode *BufferFunctor::create(Qt3DCore::QNode *frontend) const
     Buffer *buffer = m_manager->getOrCreateResource(frontend->id());
     buffer->setManager(m_manager);
     buffer->setPeer(frontend);
+    buffer->setRenderer(m_renderer);
     return buffer;
 }
 
diff --git a/src/render/geometry/buffer_p.h b/src/render/geometry/buffer_p.h
index 96b720634..ccf88bbc0 100644
--- a/src/render/geometry/buffer_p.h
+++ b/src/render/geometry/buffer_p.h
@@ -97,12 +97,13 @@ private:
 class BufferFunctor : public Qt3DCore::QBackendNodeMapper
 {
 public:
-    explicit BufferFunctor(BufferManager *manager);
+    explicit BufferFunctor(AbstractRenderer *renderer, BufferManager *manager);
     Qt3DCore::QBackendNode *create(Qt3DCore::QNode *frontend) const Q_DECL_OVERRIDE;
     Qt3DCore::QBackendNode *get(Qt3DCore::QNodeId id) const Q_DECL_OVERRIDE;
     void destroy(Qt3DCore::QNodeId id) const Q_DECL_OVERRIDE;
 private:
     BufferManager *m_manager;
+    AbstractRenderer *m_renderer;
 };
 
 } // namespace Render
diff --git a/src/render/geometry/geometryrenderer.cpp b/src/render/geometry/geometryrenderer.cpp
index 728a1a99e..a20bb87cf 100644
--- a/src/render/geometry/geometryrenderer.cpp
+++ b/src/render/geometry/geometryrenderer.cpp
@@ -209,8 +209,9 @@ QVector<QBoundingVolume *> GeometryRenderer::triangleData() const
     return m_triangleVolumes;
 }
 
-GeometryRendererFunctor::GeometryRendererFunctor(GeometryRendererManager *manager)
+GeometryRendererFunctor::GeometryRendererFunctor(AbstractRenderer *renderer, GeometryRendererManager *manager)
     : m_manager(manager)
+    , m_renderer(renderer)
 {
 }
 
@@ -219,6 +220,7 @@ Qt3DCore::QBackendNode *GeometryRendererFunctor::create(Qt3DCore::QNode *fronten
     GeometryRenderer *geometryRenderer = m_manager->getOrCreateResource(frontend->id());
     geometryRenderer->setManager(m_manager);
     geometryRenderer->setPeer(frontend);
+    geometryRenderer->setRenderer(m_renderer);
     return geometryRenderer;
 }
 
diff --git a/src/render/geometry/geometryrenderer_p.h b/src/render/geometry/geometryrenderer_p.h
index a291ac309..8a1b4bd5f 100644
--- a/src/render/geometry/geometryrenderer_p.h
+++ b/src/render/geometry/geometryrenderer_p.h
@@ -114,12 +114,13 @@ private:
 class GeometryRendererFunctor : public Qt3DCore::QBackendNodeMapper
 {
 public:
-    explicit GeometryRendererFunctor(GeometryRendererManager *manager);
+    explicit GeometryRendererFunctor(AbstractRenderer *renderer, GeometryRendererManager *manager);
     Qt3DCore::QBackendNode *create(Qt3DCore::QNode *frontend) const Q_DECL_OVERRIDE;
     Qt3DCore::QBackendNode *get(Qt3DCore::QNodeId id) const Q_DECL_OVERRIDE;
     void destroy(Qt3DCore::QNodeId id) const Q_DECL_OVERRIDE;
 private:
     GeometryRendererManager *m_manager;
+    AbstractRenderer *m_renderer;
 };
 
 } // namespace Render
diff --git a/src/render/io/scene.cpp b/src/render/io/scene.cpp
index e1afa7cce..772a49837 100644
--- a/src/render/io/scene.cpp
+++ b/src/render/io/scene.cpp
@@ -103,8 +103,9 @@ void Scene::setSceneManager(SceneManager *manager)
         m_sceneManager = manager;
 }
 
-RenderSceneFunctor::RenderSceneFunctor(SceneManager *sceneManager)
+RenderSceneFunctor::RenderSceneFunctor(AbstractRenderer *renderer, SceneManager *sceneManager)
     : m_sceneManager(sceneManager)
+    , m_renderer(renderer)
 {
 }
 
@@ -113,6 +114,7 @@ Qt3DCore::QBackendNode *RenderSceneFunctor::create(Qt3DCore::QNode *frontend) co
     Scene *scene = m_sceneManager->getOrCreateResource(frontend->id());
     scene->setSceneManager(m_sceneManager);
     scene->setPeer(frontend);
+    scene->setRenderer(m_renderer);
     return scene;
 }
 
diff --git a/src/render/io/scene_p.h b/src/render/io/scene_p.h
index 1218bbf49..b407ec112 100644
--- a/src/render/io/scene_p.h
+++ b/src/render/io/scene_p.h
@@ -87,13 +87,14 @@ private:
 class RenderSceneFunctor : public Qt3DCore::QBackendNodeMapper
 {
 public:
-    explicit RenderSceneFunctor(SceneManager *sceneManager);
+    explicit RenderSceneFunctor(AbstractRenderer *renderer, SceneManager *sceneManager);
     Qt3DCore::QBackendNode *create(Qt3DCore::QNode *frontend) const Q_DECL_OVERRIDE;
     Qt3DCore::QBackendNode *get(Qt3DCore::QNodeId id) const Q_DECL_OVERRIDE;
     void destroy(Qt3DCore::QNodeId id) const Q_DECL_OVERRIDE;
 
 private:
     SceneManager *m_sceneManager;
+    AbstractRenderer *m_renderer;
 };
 
 } // namespace Render
diff --git a/src/render/lights/light.cpp b/src/render/lights/light.cpp
index 3d8e6615b..03194a4fb 100644
--- a/src/render/lights/light.cpp
+++ b/src/render/lights/light.cpp
@@ -52,8 +52,9 @@ using namespace Qt3DCore;
 namespace Qt3DRender {
 namespace Render {
 
-RenderLightFunctor::RenderLightFunctor(NodeManagers *managers)
+RenderLightFunctor::RenderLightFunctor(AbstractRenderer *renderer, NodeManagers *managers)
     : m_managers(managers)
+    , m_renderer(renderer)
 {
 }
 
@@ -62,6 +63,7 @@ Qt3DCore::QBackendNode *RenderLightFunctor::create(Qt3DCore::QNode *frontend) co
     Light *backend = m_managers->lightManager()->getOrCreateResource(frontend->id());
     backend->setManagers(m_managers);
     backend->setPeer(frontend);
+    backend->setRenderer(m_renderer);
     return backend;
 }
 
diff --git a/src/render/lights/light_p.h b/src/render/lights/light_p.h
index 5cf469a7d..dd93ca0e8 100644
--- a/src/render/lights/light_p.h
+++ b/src/render/lights/light_p.h
@@ -70,7 +70,7 @@ public:
 class RenderLightFunctor : public Qt3DCore::QBackendNodeMapper
 {
 public:
-    explicit RenderLightFunctor(NodeManagers *managers);
+    explicit RenderLightFunctor(AbstractRenderer *renderer, NodeManagers *managers);
 
     Qt3DCore::QBackendNode *create(Qt3DCore::QNode *frontend) const Q_DECL_FINAL;
     Qt3DCore::QBackendNode *get(Qt3DCore::QNodeId id) const Q_DECL_FINAL;
@@ -78,6 +78,7 @@ public:
 
 private:
     NodeManagers *m_managers;
+    AbstractRenderer *m_renderer;
 };
 
 } // namespace Render
diff --git a/src/render/materialsystem/shaderdata.cpp b/src/render/materialsystem/shaderdata.cpp
index b4a226221..9694ea159 100644
--- a/src/render/materialsystem/shaderdata.cpp
+++ b/src/render/materialsystem/shaderdata.cpp
@@ -325,8 +325,9 @@ void ShaderData::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
     }
 }
 
-RenderShaderDataFunctor::RenderShaderDataFunctor(NodeManagers *managers)
+RenderShaderDataFunctor::RenderShaderDataFunctor(AbstractRenderer *renderer, NodeManagers *managers)
     : m_managers(managers)
+    , m_renderer(renderer)
 {
 }
 
@@ -335,6 +336,7 @@ Qt3DCore::QBackendNode *RenderShaderDataFunctor::create(Qt3DCore::QNode *fronten
     ShaderData *backend = m_managers->shaderDataManager()->getOrCreateResource(frontend->id());
     backend->setManagers(m_managers);
     backend->setPeer(frontend);
+    backend->setRenderer(m_renderer);
     return backend;
 }
 
diff --git a/src/render/materialsystem/shaderdata_p.h b/src/render/materialsystem/shaderdata_p.h
index 4a153f51e..aff28fc2c 100644
--- a/src/render/materialsystem/shaderdata_p.h
+++ b/src/render/materialsystem/shaderdata_p.h
@@ -120,7 +120,7 @@ protected:
 class RenderShaderDataFunctor : public Qt3DCore::QBackendNodeMapper
 {
 public:
-    explicit RenderShaderDataFunctor(NodeManagers *managers);
+    explicit RenderShaderDataFunctor(AbstractRenderer *renderer, NodeManagers *managers);
 
     Qt3DCore::QBackendNode *create(Qt3DCore::QNode *frontend) const Q_DECL_FINAL;
     Qt3DCore::QBackendNode *get(Qt3DCore::QNodeId id) const Q_DECL_FINAL;
@@ -128,6 +128,7 @@ public:
 
 private:
     NodeManagers *m_managers;
+    AbstractRenderer *m_renderer;
 };
 
 } // namespace Render
diff --git a/src/render/texture/texture.cpp b/src/render/texture/texture.cpp
index 862d78a3e..7a4b238e4 100644
--- a/src/render/texture/texture.cpp
+++ b/src/render/texture/texture.cpp
@@ -673,12 +673,14 @@ void Texture::addToPendingTextureJobs()
     m_textureDataManager->addToPendingTextures(peerUuid());
 }
 
-TextureFunctor::TextureFunctor(TextureManager *textureManager,
-                                           TextureImageManager *textureImageManager,
-                                           TextureDataManager *textureDataManager)
+TextureFunctor::TextureFunctor(AbstractRenderer *renderer,
+                               TextureManager *textureManager,
+                               TextureImageManager *textureImageManager,
+                               TextureDataManager *textureDataManager)
     : m_textureManager(textureManager)
     , m_textureImageManager(textureImageManager)
     , m_textureDataManager(textureDataManager)
+    , m_renderer(renderer)
 {
 }
 
@@ -689,6 +691,7 @@ Qt3DCore::QBackendNode *TextureFunctor::create(Qt3DCore::QNode *frontend) const
     backend->setTextureImageManager(m_textureImageManager);
     backend->setTextureDataManager(m_textureDataManager);
     backend->setPeer(frontend);
+    backend->setRenderer(m_renderer);
     return backend;
 }
 
diff --git a/src/render/texture/texture_p.h b/src/render/texture/texture_p.h
index f51aec81b..29bc27f61 100644
--- a/src/render/texture/texture_p.h
+++ b/src/render/texture/texture_p.h
@@ -164,15 +164,16 @@ private:
 class TextureFunctor : public Qt3DCore::QBackendNodeMapper
 {
 public:
-    explicit TextureFunctor(TextureManager *textureManager,
-                                  TextureImageManager *textureImageManager,
-                                  TextureDataManager *textureDataManager);
-
+    explicit TextureFunctor(AbstractRenderer *renderer,
+                            TextureManager *textureManager,
+                            TextureImageManager *textureImageManager,
+                            TextureDataManager *textureDataManager);
     Qt3DCore::QBackendNode *create(Qt3DCore::QNode *frontend) const Q_DECL_FINAL;
     Qt3DCore::QBackendNode *get(Qt3DCore::QNodeId id) const Q_DECL_FINAL;
     void destroy(Qt3DCore::QNodeId id) const Q_DECL_FINAL;
 
 private:
+    AbstractRenderer *m_renderer;
     TextureManager *m_textureManager;
     TextureImageManager *m_textureImageManager;
     TextureDataManager *m_textureDataManager;
diff --git a/src/render/texture/textureimage.cpp b/src/render/texture/textureimage.cpp
index 47a0dbd17..7ce782e6d 100644
--- a/src/render/texture/textureimage.cpp
+++ b/src/render/texture/textureimage.cpp
@@ -158,12 +158,13 @@ void TextureImage::updateDNA()
                     + (m_textureDataHandle.handle() << 12));
 }
 
-TextureImageFunctor::TextureImageFunctor(TextureManager *textureManager,
-                                                     TextureImageManager *textureImageManager,
-                                                     TextureDataManager *textureDataManager)
+TextureImageFunctor::TextureImageFunctor(AbstractRenderer *renderer, TextureManager *textureManager,
+                                         TextureImageManager *textureImageManager,
+                                         TextureDataManager *textureDataManager)
     : m_textureManager(textureManager)
     , m_textureImageManager(textureImageManager)
     , m_textureDataManager(textureDataManager)
+    , m_renderer(renderer)
 {
 }
 
@@ -174,6 +175,7 @@ Qt3DCore::QBackendNode *TextureImageFunctor::create(Qt3DCore::QNode *frontend) c
     backend->setTextureImageManager(m_textureImageManager);
     backend->setTextureDataManager(m_textureDataManager);
     backend->setPeer(frontend);
+    backend->setRenderer(m_renderer);
     return backend;
 }
 
diff --git a/src/render/texture/textureimage_p.h b/src/render/texture/textureimage_p.h
index 0e19c8614..bb5cd1d16 100644
--- a/src/render/texture/textureimage_p.h
+++ b/src/render/texture/textureimage_p.h
@@ -117,9 +117,10 @@ private:
 class TextureImageFunctor : public Qt3DCore::QBackendNodeMapper
 {
 public:
-    explicit TextureImageFunctor(TextureManager *textureManager,
-                                  TextureImageManager *textureImageManager,
-                                  TextureDataManager *textureDataManager);
+    explicit TextureImageFunctor(AbstractRenderer *renderer,
+                                 TextureManager *textureManager,
+                                 TextureImageManager *textureImageManager,
+                                 TextureDataManager *textureDataManager);
 
     Qt3DCore::QBackendNode *create(Qt3DCore::QNode *frontend) const Q_DECL_FINAL;
     Qt3DCore::QBackendNode *get(Qt3DCore::QNodeId id) const Q_DECL_FINAL;
@@ -129,6 +130,7 @@ private:
     TextureManager *m_textureManager;
     TextureImageManager *m_textureImageManager;
     TextureDataManager *m_textureDataManager;
+    AbstractRenderer *m_renderer;
 };