Rework Renderer to use BufferFunctor

Each buffer when it receives a new functor adds itself with the buffer
manager. This then allows to build LoadBufferJob instances for each buffer to
be loaded. The buffers can then be loaded before a frame is rendered.

The GeometryRendererManager has been moved back with other managers and the
BufferManager takes its place to handle the additional management of dirty
buffers.

Renderer updated accordingly.

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

14 files changed, 122 insertions, 135 deletions

diff --git a/src/render/backend/geometryrenderermanager.cpp b/src/render/backend/buffermanager.cpp
index dc8e43faf..bcf25086d 100644
--- a/src/render/backend/geometryrenderermanager.cpp
+++ b/src/render/backend/buffermanager.cpp
@@ -34,7 +34,7 @@
 **
 ****************************************************************************/
 
-#include "geometryrenderermanager_p.h"
+#include "buffermanager_p.h"
 
 QT_BEGIN_NAMESPACE
 
@@ -43,24 +43,24 @@ namespace Qt3D {
 
 namespace Render {
 
-GeometryRendererManager::GeometryRendererManager()
+BufferManager::BufferManager()
 {
 }
 
-GeometryRendererManager::~GeometryRendererManager()
+BufferManager::~BufferManager()
 {
 }
 
-void GeometryRendererManager::addDirtyGeometryRenderer(const QNodeId &geometryRendererId)
+void BufferManager::addDirtyBuffer(const QNodeId &bufferId)
 {
-    if (!m_geometryRendererDirty.contains(geometryRendererId))
-        m_geometryRendererDirty.push_back(geometryRendererId);
+    if (!m_dirtyBuffers.contains(bufferId))
+        m_dirtyBuffers.push_back(bufferId);
 }
 
-QVector<QNodeId> GeometryRendererManager::dirtyGeometryRenderers()
+QVector<QNodeId> BufferManager::dirtyBuffers()
 {
-    QVector<QNodeId> vector(m_geometryRendererDirty);
-    m_geometryRendererDirty.clear();
+    QVector<QNodeId> vector(m_dirtyBuffers);
+    m_dirtyBuffers.clear();
     return vector;
 }
 
diff --git a/src/render/backend/geometryrenderermanager_p.h b/src/render/backend/buffermanager_p.h
index 1f6c4437b..c7d397ff2 100644
--- a/src/render/backend/geometryrenderermanager_p.h
+++ b/src/render/backend/buffermanager_p.h
@@ -34,11 +34,11 @@
 **
 ****************************************************************************/
 
-#ifndef QT3D_RENDER_GEOMETRYRENDERERMANAGER_H
-#define QT3D_RENDER_GEOMETRYRENDERERMANAGER_H
+#ifndef QT3D_RENDER_BUFFERMANAGER_H
+#define QT3D_RENDER_BUFFERMANAGER_H
 
 #include <Qt3DCore/private/qresourcemanager_p.h>
-#include <Qt3DRenderer/private/rendergeometryrenderer_p.h>
+#include <Qt3DRenderer/private/renderbuffer_p.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -46,32 +46,32 @@ namespace Qt3D {
 
 namespace Render {
 
-class GeometryRendererManager : public QResourceManager<
-        RenderGeometryRenderer,
+class BufferManager : public QResourceManager<
+        RenderBuffer,
         QNodeId,
         16,
         Qt3D::ArrayAllocatingPolicy,
         Qt3D::ObjectLevelLockingPolicy>
 {
 public:
-    GeometryRendererManager();
-    ~GeometryRendererManager();
+    BufferManager();
+    ~BufferManager();
 
     // Aspect Thread
-    void addDirtyGeometryRenderer(const QNodeId &geometryRendererId);
-    QVector<QNodeId> dirtyGeometryRenderers();
+    void addDirtyBuffer(const QNodeId &bufferId);
+    QVector<QNodeId> dirtyBuffers();
 
 private:
-    QVector<QNodeId> m_geometryRendererDirty;
+    QVector<QNodeId> m_dirtyBuffers;
 };
 
 } // Render
 
-Q_DECLARE_RESOURCE_INFO(Render::RenderGeometryRenderer, Q_REQUIRES_CLEANUP);
+Q_DECLARE_RESOURCE_INFO(Render::RenderBuffer, Q_REQUIRES_CLEANUP);
 
 } // Qt3D
 
 QT_END_NAMESPACE
 
 
-#endif // QT3D_RENDER_GEOMETRYRENDERERMANAGER_H
+#endif // QT3D_RENDER_BUFFERMANAGER_H
diff --git a/src/render/backend/jobs/loadbufferjob.cpp b/src/render/backend/jobs/loadbufferjob.cpp
index 32b8cbdf1..8bcdf4347 100644
--- a/src/render/backend/jobs/loadbufferjob.cpp
+++ b/src/render/backend/jobs/loadbufferjob.cpp
@@ -36,7 +36,8 @@
 
 #include "loadbufferjob_p.h"
 #include <Qt3DRenderer/private/renderbuffer_p.h>
-#include <Qt3DRenderer/private/managers_p.h>
+#include <Qt3DRenderer/private/buffermanager_p.h>
+#include <Qt3DRenderer/private/renderer_p.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -58,11 +59,10 @@ LoadBufferJob::~LoadBufferJob()
 
 void LoadBufferJob::run()
 {
-    // TO DO: Load a job functor
-
-    // Unset the dirty flag on the buffer
+    // Let's leave it for the moment until this has been properly tested
+    qDebug() << Q_FUNC_INFO;
     RenderBuffer *buffer = m_renderer->bufferManager()->data(m_handle);
-    buffer->unsetDirty();
+    buffer->executeFunctor();
 }
 
 } // Render
diff --git a/src/render/backend/jobs/loadbufferjob_p.h b/src/render/backend/jobs/loadbufferjob_p.h
index af1f32b37..b8e342b90 100644
--- a/src/render/backend/jobs/loadbufferjob_p.h
+++ b/src/render/backend/jobs/loadbufferjob_p.h
@@ -57,8 +57,6 @@ public:
 
     void setRenderer(Renderer *renderer) { m_renderer = renderer; }
 
-    // TO DO: Add a set functor method in here
-
 protected:
     void run() Q_DECL_OVERRIDE;
     HBuffer m_handle;
diff --git a/src/render/backend/managers_p.h b/src/render/backend/managers_p.h
index 5afe57390..b0a8cc8b4 100644
--- a/src/render/backend/managers_p.h
+++ b/src/render/backend/managers_p.h
@@ -58,9 +58,9 @@
 #include <Qt3DRenderer/private/handle_types_p.h>
 #include <Qt3DRenderer/private/uniformbuffer_p.h>
 #include <Qt3DRenderer/private/rendertextureimage_p.h>
-#include <Qt3DRenderer/private/renderbuffer_p.h>
 #include <Qt3DRenderer/private/renderattribute_p.h>
 #include <Qt3DRenderer/private/rendergeometry_p.h>
+#include <Qt3DRenderer/private/rendergeometryrenderer_p.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -296,8 +296,8 @@ class TextureImageManager : public QResourceManager<
 {
 };
 
-class BufferManager : public QResourceManager<
-        RenderBuffer,
+class AttributeManager : public QResourceManager<
+        RenderAttribute,
         QNodeId,
         16,
         Qt3D::ArrayAllocatingPolicy,
@@ -305,8 +305,8 @@ class BufferManager : public QResourceManager<
 {
 };
 
-class AttributeManager : public QResourceManager<
-        RenderAttribute,
+class GeometryManager : public QResourceManager<
+        RenderGeometry,
         QNodeId,
         16,
         Qt3D::ArrayAllocatingPolicy,
@@ -314,8 +314,8 @@ class AttributeManager : public QResourceManager<
 {
 };
 
-class GeometryManager : public QResourceManager<
-        RenderGeometry,
+class GeometryRendererManager : public QResourceManager<
+        RenderGeometryRenderer,
         QNodeId,
         16,
         Qt3D::ArrayAllocatingPolicy,
@@ -338,9 +338,9 @@ Q_DECLARE_RESOURCE_INFO(Render::RenderTechnique, Q_REQUIRES_CLEANUP);
 Q_DECLARE_RESOURCE_INFO(Render::RenderTexture, Q_REQUIRES_CLEANUP);
 Q_DECLARE_RESOURCE_INFO(Render::RenderRenderPass, Q_REQUIRES_CLEANUP);
 Q_DECLARE_RESOURCE_INFO(Render::RenderTextureImage, Q_REQUIRES_CLEANUP);
-Q_DECLARE_RESOURCE_INFO(Render::RenderBuffer, Q_REQUIRES_CLEANUP);
 Q_DECLARE_RESOURCE_INFO(Render::RenderAttribute, Q_REQUIRES_CLEANUP);
 Q_DECLARE_RESOURCE_INFO(Render::RenderGeometry, Q_REQUIRES_CLEANUP);
+Q_DECLARE_RESOURCE_INFO(Render::RenderGeometryRenderer, Q_REQUIRES_CLEANUP);
 
 } // Qt3D
 
diff --git a/src/render/backend/qrenderaspect.cpp b/src/render/backend/qrenderaspect.cpp
index daf34970b..955a88f6a 100644
--- a/src/render/backend/qrenderaspect.cpp
+++ b/src/render/backend/qrenderaspect.cpp
@@ -233,10 +233,10 @@ void QRenderAspect::registerBackendTypes()
     registerBackendType<QAbstractTextureImage>(QBackendNodeFunctorPtr(new Render::RenderTextureImageFunctor(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::RenderNodeFunctor<Render::RenderBuffer, Render::BufferManager>(d->m_renderer->bufferManager())));
+    registerBackendType<QBuffer>(QBackendNodeFunctorPtr(new Render::RenderBufferFunctor(d->m_renderer->bufferManager())));
     registerBackendType<QAttribute>(QBackendNodeFunctorPtr(new Render::RenderNodeFunctor<Render::RenderAttribute, Render::AttributeManager>(d->m_renderer->attributeManager())));
     registerBackendType<QGeometry>(QBackendNodeFunctorPtr(new Render::RenderNodeFunctor<Render::RenderGeometry, Render::GeometryManager>(d->m_renderer->geometryManager())));
-    registerBackendType<QGeometryRenderer>(QBackendNodeFunctorPtr(new Render::RenderGeometryRendererFunctor(d->m_renderer->geometryRendererManager())));
+    registerBackendType<QGeometryRenderer>(QBackendNodeFunctorPtr(new Render::RenderNodeFunctor<Render::RenderGeometryRenderer, Render::GeometryRendererManager>(d->m_renderer->geometryRendererManager())));
 }
 
 void QRenderAspect::renderInitialize(QOpenGLContext *context)
diff --git a/src/render/backend/render-backend.pri b/src/render/backend/render-backend.pri
index 8198b1c39..bb44cacae 100644
--- a/src/render/backend/render-backend.pri
+++ b/src/render/backend/render-backend.pri
@@ -56,7 +56,7 @@ HEADERS += \
     $$PWD/renderattribute_p.h \
     $$PWD/rendergeometry_p.h \
     $$PWD/rendergeometryrenderer_p.h \
-    $$PWD/geometryrenderermanager_p.h
+    $$PWD/buffermanager_p.h
 
 SOURCES += \
     $$PWD/qrenderaspect.cpp \
@@ -103,4 +103,4 @@ SOURCES += \
     $$PWD/renderattribute.cpp \
     $$PWD/rendergeometry.cpp \
     $$PWD/rendergeometryrenderer.cpp \
-    $$PWD/geometryrenderermanager.cpp
+    $$PWD/buffermanager.cpp
diff --git a/src/render/backend/renderbuffer.cpp b/src/render/backend/renderbuffer.cpp
index 81556322c..7fd576290 100644
--- a/src/render/backend/renderbuffer.cpp
+++ b/src/render/backend/renderbuffer.cpp
@@ -36,6 +36,7 @@
 
 #include "renderbuffer_p.h"
 #include <Qt3DCore/qscenepropertychange.h>
+#include <Qt3DRenderer/private/buffermanager_p.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -48,6 +49,7 @@ RenderBuffer::RenderBuffer()
     , m_type(QBuffer::VertexBuffer)
     , m_usage(QBuffer::StaticDraw)
     , m_bufferDirty(false)
+    , m_manager(Q_NULLPTR)
 {
     // Maybe it could become read write if we want to inform
     // the frontend QBuffer node of any backend issue
@@ -65,6 +67,17 @@ void RenderBuffer::cleanup()
     m_bufferDirty = false;
 }
 
+
+void RenderBuffer::setManager(BufferManager *manager)
+{
+    m_manager = manager;
+}
+
+void RenderBuffer::executeFunctor()
+{
+    m_data = (*m_functor)();
+}
+
 void RenderBuffer::updateFromPeer(QNode *peer)
 {
     QBuffer *buffer = static_cast<QBuffer *>(peer);
@@ -73,6 +86,9 @@ void RenderBuffer::updateFromPeer(QNode *peer)
         m_usage = buffer->usage();
         m_data = buffer->data();
         m_functor = buffer->bufferFunctor();
+        // Add to dirty list in the manager
+        if (m_functor)
+            m_manager->addDirtyBuffer(peerUuid());
         m_bufferDirty = true;
     }
 }
@@ -96,6 +112,8 @@ void RenderBuffer::sceneChangeEvent(const QSceneChangePtr &e)
             QBufferFunctorPtr newFunctor = propertyChange->value().value<QBufferFunctorPtr>();
             m_bufferDirty |= !(*newFunctor == *m_functor);
             m_functor = newFunctor;
+            if (m_functor)
+                m_manager->addDirtyBuffer(peerUuid());
         }
     }
 }
@@ -105,6 +123,30 @@ void RenderBuffer::unsetDirty()
     m_bufferDirty = false;
 }
 
+RenderBufferFunctor::RenderBufferFunctor(BufferManager *manager)
+    : m_manager(manager)
+{
+}
+
+QBackendNode *RenderBufferFunctor::create(QNode *frontend, const QBackendNodeFactory *factory) const
+{
+    RenderBuffer *buffer = m_manager->getOrCreateResource(frontend->id());
+    buffer->setFactory(factory);
+    buffer->setManager(m_manager);
+    buffer->setPeer(frontend);
+    return buffer;
+}
+
+QBackendNode *RenderBufferFunctor::get(const QNodeId &id) const
+{
+    return m_manager->lookupResource(id);
+}
+
+void RenderBufferFunctor::destroy(const QNodeId &id) const
+{
+    return m_manager->releaseResource(id);
+}
+
 } // Render
 
 } // Qt3D
diff --git a/src/render/backend/renderbuffer_p.h b/src/render/backend/renderbuffer_p.h
index 1fd4fd76f..d71548e18 100644
--- a/src/render/backend/renderbuffer_p.h
+++ b/src/render/backend/renderbuffer_p.h
@@ -47,6 +47,8 @@ namespace Qt3D {
 
 namespace Render {
 
+class BufferManager;
+
 class Q_AUTOTEST_EXPORT RenderBuffer : public QBackendNode
 {
 public:
@@ -57,6 +59,9 @@ public:
     void updateFromPeer(QNode *peer) Q_DECL_OVERRIDE;
     void sceneChangeEvent(const QSceneChangePtr &e) Q_DECL_OVERRIDE;
 
+    void setManager(BufferManager *manager);
+    void executeFunctor();
+
     inline QBuffer::BufferType type() const { return m_type; }
     inline QBuffer::UsageType usage() const { return m_usage; }
     inline QByteArray data() const { return m_data; }
@@ -69,6 +74,18 @@ private:
     QByteArray m_data;
     bool m_bufferDirty;
     QBufferFunctorPtr m_functor;
+    BufferManager *m_manager;
+};
+
+class RenderBufferFunctor : public QBackendNodeFunctor
+{
+public:
+    explicit RenderBufferFunctor(BufferManager *manager);
+    QBackendNode *create(QNode *frontend, const QBackendNodeFactory *factory) const Q_DECL_OVERRIDE;
+    QBackendNode *get(const QNodeId &id) const Q_DECL_OVERRIDE;
+    void destroy(const QNodeId &id) const Q_DECL_OVERRIDE;
+private:
+    BufferManager *m_manager;
 };
 
 } // Render
diff --git a/src/render/backend/renderentity.cpp b/src/render/backend/renderentity.cpp
index 1de9fbc34..51b7902ae 100644
--- a/src/render/backend/renderentity.cpp
+++ b/src/render/backend/renderentity.cpp
@@ -46,7 +46,6 @@
 #include <Qt3DRenderer/sphere.h>
 #include <Qt3DRenderer/qshaderdata.h>
 #include <Qt3DRenderer/qgeometryrenderer.h>
-#include <Qt3DRenderer/private/geometryrenderermanager_p.h>
 
 #include <Qt3DCore/qcameralens.h>
 #include <Qt3DCore/qentity.h>
diff --git a/src/render/backend/renderer.cpp b/src/render/backend/renderer.cpp
index 255284efe..cd2d2e17e 100644
--- a/src/render/backend/renderer.cpp
+++ b/src/render/backend/renderer.cpp
@@ -74,7 +74,7 @@
 #include <Qt3DRenderer/private/viewportnode_p.h>
 #include <Qt3DRenderer/private/abstractsceneparser_p.h>
 #include <Qt3DRenderer/private/vsyncframeadvanceservice_p.h>
-#include <Qt3DRenderer/private/geometryrenderermanager_p.h>
+#include <Qt3DRenderer/private/buffermanager_p.h>
 #include <Qt3DRenderer/private/loadbufferjob_p.h>
 
 #include <Qt3DCore/qcameralens.h>
@@ -769,31 +769,20 @@ QVector<QAspectJobPtr> Renderer::createRenderBinJobs()
 // 1 dirty buffer == 1 job, all job can be performed in parallel
 QVector<QAspectJobPtr> Renderer::createRenderBufferJobs()
 {
-    const QVector<QNodeId> dirtyGeometryRenderers = m_geometryRendererManager->dirtyGeometryRenderers();
+    const QVector<QNodeId> dirtyBuffers = m_bufferManager->dirtyBuffers();
     QVector<QAspectJobPtr> dirtyBuffersJobs;
-    QVector<HBuffer> dirtyBuffers;
-    Q_FOREACH (const QNodeId &geomRendererId, dirtyGeometryRenderers) {
-        // Find the geometry, and find all unique dirty buffers for the attributes;
-        Render::RenderGeometryRenderer *geometryRenderer = m_geometryRendererManager->lookupResource(geomRendererId);
-        Q_ASSERT(geometryRenderer);
-        Render::RenderGeometry *geometry = m_geometryManager->lookupResource(geometryRenderer->geometryId());
-        if (geometry != Q_NULLPTR) {
-            Q_FOREACH (const QNodeId &attributeId, geometry->attributes()) {
-                Render::RenderAttribute *attribute = m_attributeManager->lookupResource(attributeId);
-                if (attribute != Q_NULLPTR) {
-                    HBuffer bufferHandle = m_bufferManager->lookupHandle(attribute->bufferId());
-                    RenderBuffer *buffer = m_bufferManager->data(bufferHandle);
-                    if (buffer != Q_NULLPTR && !dirtyBuffers.contains(bufferHandle)) {
-                        // Create new buffer job
-                        LoadBufferJobPtr job(new LoadBufferJob(bufferHandle));
-                        job->setRenderer(this);
-                        dirtyBuffersJobs.push_back(job);
-                        dirtyBuffers.push_back(bufferHandle);
-                    }
-                }
-            }
+
+    Q_FOREACH (const QNodeId &bufId, dirtyBuffers) {
+        HBuffer bufferHandle = m_bufferManager->lookupHandle(bufId);
+        RenderBuffer *buffer = m_bufferManager->data(bufferHandle);
+        if (buffer != Q_NULLPTR) {
+            // Create new buffer job
+            LoadBufferJobPtr job(new LoadBufferJob(bufferHandle));
+            job->setRenderer(this);
+            dirtyBuffersJobs.push_back(job);
         }
     }
+
     return dirtyBuffersJobs;
 }
 
@@ -953,11 +942,7 @@ void Renderer::executeCommands(const QVector<RenderCommand *> &commands)
     // Reset to the state we were in before executing the render commands
     m_graphicsContext->setCurrentStateSet(globalState);
 
-    // Unset dirtiness on Geometry, Attributes and Buffers
-    Q_FOREACH (RenderBuffer *buffer, m_dirtyBuffers)
-        buffer->unsetDirty();
-    m_dirtyBuffers.clear();
-
+    // Unset dirtiness on Geometry and Attributes
     Q_FOREACH (RenderAttribute *attribute, m_dirtyAttributes)
         attribute->unsetDirty();
     m_dirtyAttributes.clear();
@@ -983,6 +968,15 @@ RenderAttribute *Renderer::updateBuffersAndAttributes(RenderGeometry *geometry,
         if (buffer == Q_NULLPTR)
             continue;
 
+        if (buffer->isDirty()) {
+            // Reupload buffer data
+            m_graphicsContext->updateBuffer(buffer);
+
+            // Append buffer to temporary vector so that its dirtiness
+            // can be cleared at the end of the frame
+            buffer->unsetDirty();
+        }
+
         int estimatedCount = 0;
 
         // Update attribute and create buffer if needed
@@ -993,7 +987,7 @@ RenderAttribute *Renderer::updateBuffersAndAttributes(RenderGeometry *geometry,
                 m_graphicsContext->specifyIndices(buffer);
             estimatedCount = attribute->count();
             indexAttribute = attribute;
-        // Vertex Attribute
+            // Vertex Attribute
         } else if (command->m_parameterAttributeToShaderNames.contains(attribute->name())) {
             if (attribute->isDirty() || forceUpdate)
                 m_graphicsContext->specifyAttribute(attribute, buffer);
@@ -1010,17 +1004,8 @@ RenderAttribute *Renderer::updateBuffersAndAttributes(RenderGeometry *geometry,
         // can be cleared at the end of the frame
         m_dirtyAttributes.push_back(attribute);
 
-        if (buffer->isDirty()) {
-            // Reupload buffer data
-            m_graphicsContext->updateBuffer(buffer);
-
-            // Append buffer to temporary vector so that its dirtiness
-            // can be cleared at the end of the frame
-            m_dirtyBuffers.push_back(buffer);
-        }
-
-        // Note: We cannont call unsertDirty on the Attribute or Buffer at this
-        // point as we don't know if the attributes or buffers are being shared
+        // Note: We cannont call unsertDirty on the Attributeat this
+        // point as we don't know if the attributes are being shared
         // with other geometry / geometryRenderer in which case they still
         // should remain dirty so that VAO for these commands are properly
         // updated
diff --git a/src/render/backend/renderer_p.h b/src/render/backend/renderer_p.h
index 39674b01e..48a3e6309 100644
--- a/src/render/backend/renderer_p.h
+++ b/src/render/backend/renderer_p.h
@@ -294,7 +294,6 @@ private:
 
     QVector<RenderAttribute *> m_dirtyAttributes;
     QVector<RenderGeometry *> m_dirtyGeometry;
-    QVector<RenderBuffer *> m_dirtyBuffers;
 };
 
 } // namespace Render
diff --git a/src/render/backend/rendergeometryrenderer.cpp b/src/render/backend/rendergeometryrenderer.cpp
index 0cf9bc7ed..4625ae45c 100644
--- a/src/render/backend/rendergeometryrenderer.cpp
+++ b/src/render/backend/rendergeometryrenderer.cpp
@@ -36,7 +36,6 @@
 
 #include "rendergeometryrenderer_p.h"
 #include <Qt3DCore/qscenepropertychange.h>
-#include <Qt3DRenderer/private/geometryrenderermanager_p.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -54,7 +53,6 @@ RenderGeometryRenderer::RenderGeometryRenderer()
     , m_primitiveRestart(false)
     , m_primitiveType(QGeometryRenderer::Triangles)
     , m_dirty(false)
-    , m_manager(Q_NULLPTR)
 {
 }
 
@@ -75,11 +73,6 @@ void RenderGeometryRenderer::cleanup()
     m_dirty = false;
 }
 
-void RenderGeometryRenderer::setManager(GeometryRendererManager *manager)
-{
-    m_manager = manager;
-}
-
 void RenderGeometryRenderer::updateFromPeer(QNode *peer)
 {
     QGeometryRenderer *geometryRenderer = static_cast<QGeometryRenderer *>(peer);
@@ -94,9 +87,6 @@ void RenderGeometryRenderer::updateFromPeer(QNode *peer)
         if (geometryRenderer->geometry() != Q_NULLPTR)
             m_geometryId = geometryRenderer->geometry()->id();
         m_dirty = true;
-        // Add to dirty list in the manager
-        if (m_manager != Q_NULLPTR)
-            m_manager->addDirtyGeometryRenderer(peerUuid());
     }
 }
 
@@ -152,10 +142,6 @@ void RenderGeometryRenderer::sceneChangeEvent(const QSceneChangePtr &e)
     default:
         break;
     }
-
-    // Add to dirty list in manager
-    if (m_dirty && m_manager != Q_NULLPTR)
-        m_manager->addDirtyGeometryRenderer(peerUuid());
 }
 
 void RenderGeometryRenderer::unsetDirty()
@@ -163,30 +149,6 @@ void RenderGeometryRenderer::unsetDirty()
     m_dirty = false;
 }
 
-RenderGeometryRendererFunctor::RenderGeometryRendererFunctor(GeometryRendererManager *manager)
-    : m_manager(manager)
-{
-}
-
-QBackendNode *RenderGeometryRendererFunctor::create(QNode *frontend, const QBackendNodeFactory *factory) const
-{
-    RenderGeometryRenderer *geometryRenderer = m_manager->getOrCreateResource(frontend->id());
-    geometryRenderer->setFactory(factory);
-    geometryRenderer->setManager(m_manager);
-    geometryRenderer->setPeer(frontend);
-    return geometryRenderer;
-}
-
-QBackendNode *RenderGeometryRendererFunctor::get(const QNodeId &id) const
-{
-    return m_manager->lookupResource(id);
-}
-
-void RenderGeometryRendererFunctor::destroy(const QNodeId &id) const
-{
-    return m_manager->releaseResource(id);
-}
-
 } // Render
 
 } // Qt3D
diff --git a/src/render/backend/rendergeometryrenderer_p.h b/src/render/backend/rendergeometryrenderer_p.h
index 587727fc4..40f8f2c85 100644
--- a/src/render/backend/rendergeometryrenderer_p.h
+++ b/src/render/backend/rendergeometryrenderer_p.h
@@ -46,8 +46,6 @@ namespace Qt3D {
 
 namespace Render {
 
-class GeometryRendererManager;
-
 class Q_AUTOTEST_EXPORT RenderGeometryRenderer : public QBackendNode
 {
 public:
@@ -55,7 +53,6 @@ public:
     ~RenderGeometryRenderer();
 
     void cleanup();
-    void setManager(GeometryRendererManager *manager);
     void updateFromPeer(QNode *peer) Q_DECL_OVERRIDE;
     void sceneChangeEvent(const QSceneChangePtr &e) Q_DECL_OVERRIDE;
 
@@ -80,18 +77,6 @@ private:
     bool m_primitiveRestart;
     QGeometryRenderer::PrimitiveType m_primitiveType;
     bool m_dirty;
-    GeometryRendererManager *m_manager;
-};
-
-class RenderGeometryRendererFunctor : public QBackendNodeFunctor
-{
-public:
-    explicit RenderGeometryRendererFunctor(GeometryRendererManager *manager);
-    QBackendNode *create(QNode *frontend, const QBackendNodeFactory *factory) const Q_DECL_OVERRIDE;
-    QBackendNode *get(const QNodeId &id) const Q_DECL_OVERRIDE;
-    void destroy(const QNodeId &id) const Q_DECL_OVERRIDE;
-private:
-    GeometryRendererManager *m_manager;
 };
 
 } // Render