Renderer: render using GeometryRenderer and Geometry

Note: This breaks rendering with QMeshData. All the default meshes will be
ported to QGeometryRenderer in follow up commits.

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

7 files changed, 233 insertions, 84 deletions

diff --git a/src/render/backend/managers_p.h b/src/render/backend/managers_p.h
index 5da9daaf8..5afe57390 100644
--- a/src/render/backend/managers_p.h
+++ b/src/render/backend/managers_p.h
@@ -226,7 +226,7 @@ public:
 
 class VAOManager : public QResourceManager<
         QOpenGLVertexArrayObject *,
-        QPair<HMeshData, HShader>,
+        QPair<HGeometry, HShader>,
         16>
 {
 public:
diff --git a/src/render/backend/qgraphicscontext.cpp b/src/render/backend/qgraphicscontext.cpp
index e3e925ec3..affa7dd56 100644
--- a/src/render/backend/qgraphicscontext.cpp
+++ b/src/render/backend/qgraphicscontext.cpp
@@ -43,6 +43,8 @@
 #include <Qt3DRenderer/private/rendershader_p.h>
 #include <Qt3DRenderer/private/rendermaterial_p.h>
 #include <Qt3DRenderer/private/rendertexture_p.h>
+#include <Qt3DRenderer/private/renderbuffer_p.h>
+#include <Qt3DRenderer/private/renderattribute_p.h>
 #include <Qt3DRenderer/private/rendercommand_p.h>
 #include <Qt3DRenderer/private/renderstate_p.h>
 #include <Qt3DRenderer/private/rendertarget_p.h>
@@ -71,6 +73,36 @@ namespace Render {
 
 static QHash<unsigned int, QGraphicsContext*> static_contexts;
 
+namespace {
+
+QOpenGLBuffer createGLBufferFor(RenderBuffer *buffer)
+{
+    QOpenGLBuffer b(static_cast<QOpenGLBuffer::Type>(buffer->type()));
+    b.setUsagePattern(static_cast<QOpenGLBuffer::UsagePattern>(buffer->usage()));
+    if (!b.create())
+        qCWarning(Render::Io) << Q_FUNC_INFO << "buffer creation failed";
+
+    if (!b.bind())
+        qCWarning(Render::Io) << Q_FUNC_INFO << "buffer binding failed";
+
+    b.allocate(buffer->data().constData(), buffer->data().size());
+    b.release();
+    return b;
+}
+
+void uploadDataToGLBuffer(RenderBuffer *buffer, QOpenGLBuffer &b)
+{
+    if (!b.bind())
+        qCWarning(Render::Io) << Q_FUNC_INFO << "buffer bind failed";
+    const int bufferSize = buffer->data().size();
+    b.allocate(NULL, bufferSize); // orphan the buffer
+    b.allocate(buffer->data().constData(), bufferSize);
+    b.release();
+    qCDebug(Render::Io) << "uploaded buffer size=" << buffer->data().size();
+}
+
+} // anonymous
+
 unsigned int nextFreeContextId()
 {
     for (unsigned int i=0; i < 0xffff; ++i) {
@@ -232,8 +264,8 @@ void QGraphicsContext::setViewport(const QRectF &viewport)
 
 void QGraphicsContext::releaseOpenGL()
 {
-    // m_shaderHash.clear
-    m_bufferHash.clear();
+    m_renderShaderHash.clear();
+    m_renderBufferHash.clear();
 }
 
 void QGraphicsContext::setOpenGLContext(QOpenGLContext* ctx, QSurface *surface)
@@ -553,13 +585,17 @@ void QGraphicsContext::drawElementsInstanced(GLenum primitiveType,
                                              GLsizei primitiveCount,
                                              GLint indexType,
                                              void *indices,
-                                             GLsizei instances)
+                                             GLsizei instances,
+                                             GLint baseVertex,
+                                             GLint baseInstance)
 {
     m_glHelper->drawElementsInstanced(primitiveType,
                                       primitiveCount,
                                       indexType,
                                       indices,
-                                      instances);
+                                      instances,
+                                      baseVertex,
+                                      baseInstance);
 }
 
 /*!
@@ -582,12 +618,14 @@ void QGraphicsContext::drawArraysInstanced(GLenum primitiveType,
 void QGraphicsContext::drawElements(GLenum primitiveType,
                                     GLsizei primitiveCount,
                                     GLint indexType,
-                                    void *indices)
+                                    void *indices,
+                                    GLint baseVertex)
 {
     m_glHelper->drawElements(primitiveType,
                              primitiveCount,
                              indexType,
-                             indices);
+                             indices,
+                             baseVertex);
 }
 
 /*!
@@ -831,58 +869,60 @@ void QGraphicsContext::setUniforms(QUniformPack &uniforms)
     m_activeShader->updateUniforms(this, uniforms);
 }
 
-void QGraphicsContext::specifyAttribute(QString nm, QAttribute *attr)
+void QGraphicsContext::specifyAttribute(const RenderAttribute *attribute, RenderBuffer *buffer)
 {
-    if (attr == Q_NULLPTR)
+    if (attribute == Q_NULLPTR || buffer == Q_NULLPTR)
         return;
 
-    QOpenGLBuffer buf = glBufferFor(attr->buffer());
+    QOpenGLBuffer buf = glBufferForRenderBuffer(buffer);
     buf.bind();
 
     QOpenGLShaderProgram* prog = activeShader();
-    int location = prog->attributeLocation(nm);
+    int location = prog->attributeLocation(attribute->name());
     if (location < 0) {
-        qCWarning(Backend) << "failed to resolve location for attribute:" << nm;
+        qCWarning(Backend) << "failed to resolve location for attribute:" << attribute->name();
         return;
     }
     prog->enableAttributeArray(location);
     prog->setAttributeBuffer(location,
-                             QGraphicsContext::elementType(attr->type()),
-                             attr->byteOffset(),
-                             QGraphicsContext::tupleSizeFromType(attr->type()),
-                             attr->byteStride());
+                             QGraphicsContext::elementType(attribute->type()),
+                             attribute->byteOffset(),
+                             QGraphicsContext::tupleSizeFromType(attribute->type()),
+                             attribute->byteStride());
 
-    if (attr->divisor() != 0) {
+    if (attribute->divisor() != 0) {
         // Done by the helper if it supports it
-        m_glHelper->vertexAttribDivisor(location, attr->divisor());
+        m_glHelper->vertexAttribDivisor(location, attribute->divisor());
     }
 
     buf.release();
 }
 
-void QGraphicsContext::specifyIndices(QAttribute *attr)
+void QGraphicsContext::specifyIndices(RenderBuffer *buffer)
 {
-    if (static_cast<QBuffer *>(attr->buffer())->type() != QBuffer::IndexBuffer) {
-        qCWarning(Backend) << Q_FUNC_INFO << "provided buffer is not correct type";
-        return;
-    }
+    Q_ASSERT(buffer->type() == QBuffer::IndexBuffer);
 
-    QOpenGLBuffer buf = glBufferFor(attr->buffer());
+    QOpenGLBuffer buf = glBufferForRenderBuffer(buffer);
     if (!buf.bind())
         qCWarning(Backend) << Q_FUNC_INFO << "binding index buffer failed";
 
     // bind within the current VAO
 }
 
-QOpenGLBuffer QGraphicsContext::glBufferFor(QBuffer *buf)
+void QGraphicsContext::updateBuffer(RenderBuffer *buffer)
 {
-    if (m_bufferHash.contains(buf))
-        return m_bufferHash.value(buf);
+    const QHash<RenderBuffer *, QOpenGLBuffer>::iterator it = m_renderBufferHash.find(buffer);
+    if (it != m_renderBufferHash.end())
+        uploadDataToGLBuffer(buffer, it.value());
+}
 
-    QOpenGLBuffer glbuf = buf->createGL();
-    m_bufferHash[buf] = glbuf;
-    buf->upload(glbuf);
+QOpenGLBuffer QGraphicsContext::glBufferForRenderBuffer(RenderBuffer *buf)
+{
+    if (m_renderBufferHash.contains(buf))
+        return m_renderBufferHash.value(buf);
 
+    QOpenGLBuffer glbuf = createGLBufferFor(buf);
+    m_renderBufferHash.insert(buf, glbuf);
     return glbuf;
 }
 
diff --git a/src/render/backend/qgraphicscontext_p.h b/src/render/backend/qgraphicscontext_p.h
index 7585fc951..bd516e145 100644
--- a/src/render/backend/qgraphicscontext_p.h
+++ b/src/render/backend/qgraphicscontext_p.h
@@ -47,9 +47,6 @@
 #include <QMatrix4x4>
 #include <QBitArray>
 #include <Qt3DRenderer/private/quniformvalue_p.h>
-#include <Qt3DRenderer/private/qmeshdata_p.h>
-#include <Qt3DRenderer/qattribute.h>
-#include <Qt3DRenderer/qbuffer.h>
 #include <Qt3DRenderer/qclearbuffer.h>
 #include <Qt3DRenderer/private/rendershader_p.h>
 
@@ -72,6 +69,8 @@ class RenderTexture;
 class RenderCommand;
 class RenderTarget;
 class AttachmentPack;
+class RenderAttribute;
+class RenderBuffer;
 
 enum TextureScope
 {
@@ -128,9 +127,9 @@ public:
 
     void setRenderer(Renderer *renderer);
 
-    void specifyAttribute(QString nm, QAttribute *attr);
-
-    void specifyIndices(QAttribute *attr);
+    void specifyAttribute(const RenderAttribute *attribute, RenderBuffer *buffer);
+    void specifyIndices(RenderBuffer *buffer);
+    void updateBuffer(RenderBuffer *buffer);
 
     void setUniforms(QUniformPack &uniforms);
 
@@ -140,7 +139,8 @@ public:
      * @param buf
      * @return
      */
-    QOpenGLBuffer glBufferFor(QBuffer *buf);
+    QOpenGLBuffer glBufferForRenderBuffer(RenderBuffer *buf);
+
 
     /**
      * @brief activateTexture - make a texture active on a hardware unit
@@ -157,9 +157,9 @@ public:
     QOpenGLFilter *contextInfo() const;
 
     // Wrapper methods
-    void    drawElementsInstanced(GLenum primitiveType, GLsizei primitiveCount, GLint indexType, void * indices, GLsizei instances);
+    void    drawElementsInstanced(GLenum primitiveType, GLsizei primitiveCount, GLint indexType, void * indices, GLsizei instances, GLint baseVertex = 0, GLint baseInstance = 0);
     void    drawArraysInstanced(GLenum primitiveType, GLint first, GLsizei count, GLsizei instances);
-    void    drawElements(GLenum primitiveType, GLsizei primitiveCount, GLint indexType, void * indices);
+    void    drawElements(GLenum primitiveType, GLsizei primitiveCount, GLint indexType, void * indices, GLint baseVertex = 0);
     void    drawArrays(GLenum primitiveType, GLint first, GLsizei count);
     void    setVerticesPerPatch(GLint verticesPerPatch);
     void    blendEquation(GLenum mode);
@@ -210,7 +210,7 @@ private:
 
     RenderShader *m_activeShader;
     QHash<ProgramDNA, RenderShader *> m_renderShaderHash;
-    QHash<QBuffer *, QOpenGLBuffer> m_bufferHash;
+    QHash<RenderBuffer *, QOpenGLBuffer> m_renderBufferHash;
     QHash<QNodeId, GLuint> m_renderTargets;
     QHash<GLuint, QSize> m_renderTargetsSize;
 
diff --git a/src/render/backend/rendercommand_p.h b/src/render/backend/rendercommand_p.h
index b0a036d99..64d714efa 100644
--- a/src/render/backend/rendercommand_p.h
+++ b/src/render/backend/rendercommand_p.h
@@ -62,13 +62,15 @@ public:
     RenderCommand();
 
     HVao m_vao; // VAO used during the submission step to store all states and VBOs
-    HMeshData m_meshData;
     HShader m_shader; // Shader for given pass and mesh
     QUniformPack m_uniforms; // Might need to be reworked so as to be able to destroy the
                             // RenderTexture while submission is happening.
     GLint m_instancesCount; // Number of instances of the mesh, if 0 regular draw otherwise glDrawArraysInstanced or glDrawElementsInstanced
     RenderStateSet *m_stateSet;
 
+    HGeometry m_geometry;
+    HGeometryRenderer m_geometryRenderer;
+
     // A QAttribute pack might be interesting
     // This is a temporary fix in the meantime, to remove the hacked methods in RenderTechnique
     QHash<QString, QString> m_parameterAttributeToShaderNames;
diff --git a/src/render/backend/renderer.cpp b/src/render/backend/renderer.cpp
index fb8797159..939fc1931 100644
--- a/src/render/backend/renderer.cpp
+++ b/src/render/backend/renderer.cpp
@@ -821,11 +821,16 @@ void Renderer::executeCommands(const QVector<RenderCommand *> &commands)
 
     Q_FOREACH (RenderCommand *command, commands) {
 
-        QMeshData *meshData = m_meshDataManager->data(command->m_meshData);
-        if (meshData == Q_NULLPTR || meshData->attributeNames().empty()) {
-            qCWarning(Rendering) << "RenderCommand should have a mesh";
-            continue ;
+        // Check if we have a valid GeometryRenderer + Geometry
+        RenderGeometry *rGeometry = m_geometryManager->data(command->m_geometry);
+        RenderGeometryRenderer *rGeometryRenderer = m_geometryRendererManager->data(command->m_geometryRenderer);
+        const bool hasGeometryRenderer = rGeometry != Q_NULLPTR && rGeometryRenderer != Q_NULLPTR && !rGeometry->attributes().isEmpty();
+
+        if (!hasGeometryRenderer) {
+            qCWarning(Rendering) << "RenderCommand should have a mesh to render";
+            continue;
         }
+
         RenderShader *shader = m_shaderManager->data(command->m_shader);
         if (shader == Q_NULLPTR) {
             shader = m_defaultRenderShader;
@@ -833,24 +838,21 @@ void Renderer::executeCommands(const QVector<RenderCommand *> &commands)
             command->m_uniforms = m_defaultUniformPack;
         }
 
+        // The VAO should be created only once for a QGeometry and a ShaderProgram
+        // 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
         QOpenGLVertexArrayObject *vao = Q_NULLPTR;
         if (m_graphicsContext->supportsVAO()) {
-            command->m_vao = m_vaoManager->lookupHandle(QPair<HMeshData, HShader>(command->m_meshData, command->m_shader));
+            command->m_vao = m_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<HMeshData, HShader>(command->m_meshData, command->m_shader));
+                command->m_vao = m_vaoManager->getOrAcquireHandle(QPair<HGeometry, HShader>(command->m_geometry, command->m_shader));
                 *(m_vaoManager->data(command->m_vao)) = new QOpenGLVertexArrayObject();
             }
             vao = *(m_vaoManager->data(command->m_vao));
             Q_ASSERT(vao);
         }
 
-        // The VAO should be created only once for a QMeshData and a ShaderProgram
-        // 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 drawIndexed = (meshData->indexAttribute() != Q_NULLPTR);
-
         //// We activate the shader here
         // This will fill the attributes & uniforms info the first time the shader is loaded
         m_graphicsContext->activateShader(shader);
@@ -861,25 +863,27 @@ void Renderer::executeCommands(const QVector<RenderCommand *> &commands)
         // Uniform and Attributes info from the shader
         // Otherwise we might create a VAO without attribute bindings as the RenderCommand had no way to know about attributes
         // Before the shader was loader
+        RenderAttribute *indexAttribute = Q_NULLPTR;
         bool specified = false;
-        if (!command->m_parameterAttributeToShaderNames.isEmpty() && (!vao || !vao->isCreated())) {
+        const bool requiresVAOUpdate = (!vao || !vao->isCreated()) || (rGeometry->isDirty() || rGeometryRenderer->isDirty());
+        GLuint primitiveCount = rGeometryRenderer->primitiveCount();
+
+        // Append dirty Geometry to temporary vector
+        // so that its dirtiness can be unset later
+        if (rGeometry->isDirty())
+            m_dirtyGeometry.push_back(rGeometry);
+
+        if (!command->m_parameterAttributeToShaderNames.isEmpty()) {
             specified = true;
             if (vao) {
-                vao->create();
+                if (!vao->isCreated())
+                    vao->create();
                 vao->bind();
                 qCDebug(Rendering) << Q_FUNC_INFO << "Creating new VAO";
             }
 
-            // TO DO : Do that in a better / nicer way
-            Q_FOREACH (QString nm, meshData->attributeNames()) {
-                QAttribute *attr(static_cast<QAttribute *>(meshData->attributeByName(nm)));
-                if (command->m_parameterAttributeToShaderNames.contains(nm))
-                    m_graphicsContext->specifyAttribute(command->m_parameterAttributeToShaderNames[nm], attr);
-                else
-                    qCDebug(Render::Rendering) << "Couldn't find a Parameter attribute named " << nm;
-            }
-            if (drawIndexed)
-                m_graphicsContext->specifyIndices(static_cast<QAttribute *>(meshData->indexAttribute()));
+            // Update or set Attributes and Buffers for the given rGeometry and Command
+            indexAttribute = updateBuffersAndAttributes(rGeometry, command, primitiveCount, requiresVAOUpdate);
 
             if (vao)
                 vao->release();
@@ -907,20 +911,34 @@ void Renderer::executeCommands(const QVector<RenderCommand *> &commands)
             if (vao && vao->isCreated())
                 vao->bind();
 
-            GLint primType = meshData->primitiveType();
-            GLint primCount = meshData->primitiveCount();
-            GLint indexType = drawIndexed ? meshData->indexAttribute()->type() : 0;
+            const GLint primType = rGeometryRenderer->primitiveType();
+            const bool drawInstanced = rGeometryRenderer->instanceCount() > 1;
+            const bool drawIndexed = indexAttribute != Q_NULLPTR;
+            const GLint indexType = drawIndexed ? indexAttribute->type() : 0;
 
-            if (primType == QMeshData::Patches && meshData->verticesPerPatch() != 0)
-                m_graphicsContext->setVerticesPerPatch(meshData->verticesPerPatch());
+            // TO DO: Add glMulti Draw variants
+            if (!drawInstanced) { // Non instanced Rendering
+                if (drawIndexed)
+                    m_graphicsContext->drawElements(primType,
+                                                    primitiveCount,
+                                                    indexType,
+                                                    reinterpret_cast<void*>(indexAttribute->byteOffset()),
+                                                    rGeometryRenderer->baseVertex());
 
-            if (drawIndexed) {
-                m_graphicsContext->drawElements(primType,
-                                                primCount,
-                                                indexType,
-                                                reinterpret_cast<void*>(meshData->indexAttribute()->byteOffset()));
-            } else {
-                m_graphicsContext->drawArrays(primType, 0, primCount);
+                else
+                    m_graphicsContext->drawArrays(primType, 0, primitiveCount);
+            } else { // Instanced Rendering
+                if (drawIndexed)
+                    m_graphicsContext->drawElementsInstanced(primType,
+                                                             primitiveCount,
+                                                             indexType,
+                                                             reinterpret_cast<void*>(indexAttribute->byteOffset()),
+                                                             rGeometryRenderer->instanceCount());
+                else
+                    m_graphicsContext->drawArraysInstanced(primType,
+                                                           rGeometryRenderer->baseInstance(),
+                                                           primitiveCount,
+                                                           rGeometryRenderer->instanceCount());
             }
 
             int err = m_graphicsContext->openGLContext()->functions()->glGetError();
@@ -929,11 +947,91 @@ void Renderer::executeCommands(const QVector<RenderCommand *> &commands)
 
             if (vao && vao->isCreated())
                 vao->release();
+
+            // Unset dirtiness on rGeometryRenderer only
+            // The rGeometry may be shared by several rGeometryRenderer
+            // so we cannot unset its dirtiness at this point
+            rGeometryRenderer->unsetDirty();
+
         }
-    }
+    } // end of RenderCommands loop
 
     // 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();
+
+    Q_FOREACH (RenderAttribute *attribute, m_dirtyAttributes)
+        attribute->unsetDirty();
+    m_dirtyAttributes.clear();
+
+    Q_FOREACH (RenderGeometry *geometry, m_dirtyGeometry)
+        geometry->unsetDirty();
+    m_dirtyGeometry.clear();
+}
+
+RenderAttribute *Renderer::updateBuffersAndAttributes(RenderGeometry *geometry, RenderCommand *command, GLuint &count, bool forceUpdate)
+{
+    RenderAttribute *indexAttribute = Q_NULLPTR;
+
+    Q_FOREACH (const QNodeId &attributeId, geometry->attributes()) {
+        // TO DO: Improvement we could store handles and use the non locking policy on the attributeManager
+        RenderAttribute *attribute = attributeManager()->lookupResource(attributeId);
+
+        if (attribute == Q_NULLPTR)
+            continue;
+
+        RenderBuffer *buffer = bufferManager()->lookupResource(attribute->bufferId());
+
+        if (buffer == Q_NULLPTR)
+            continue;
+
+        int estimatedCount = 0;
+
+        // Update attribute and create buffer if needed
+
+        // Index Attribute
+        if (attribute->attributeType() == QAttribute::IndexAttribute) {
+            if (attribute->isDirty() || forceUpdate)
+                m_graphicsContext->specifyIndices(buffer);
+            estimatedCount = attribute->count();
+            indexAttribute = attribute;
+        // Vertex Attribute
+        } else if (command->m_parameterAttributeToShaderNames.contains(attribute->name())) {
+            if (attribute->isDirty() || forceUpdate)
+                m_graphicsContext->specifyAttribute(attribute, buffer);
+            if (estimatedCount == 0)
+                estimatedCount = attribute->count();
+        }
+
+        // If the count was not specified by the geometry renderer
+        // we set it to what we estimated it to be
+        if (count == 0)
+            count = estimatedCount;
+
+        // Append attribute to temporary vector so that its dirtiness
+        // 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
+        // with other geometry / geometryRenderer in which case they still
+        // should remain dirty so that VAO for these commands are properly
+        // updated
+    }
+    return indexAttribute;
 }
 
 void Renderer::addAllocator(QFrameAllocator *allocator)
diff --git a/src/render/backend/renderer_p.h b/src/render/backend/renderer_p.h
index d1c3f98a2..39674b01e 100644
--- a/src/render/backend/renderer_p.h
+++ b/src/render/backend/renderer_p.h
@@ -153,6 +153,7 @@ public:
     QVector<QAspectJobPtr> createRenderBufferJobs();
     QAspectJobPtr createRenderViewJob(FrameGraphNode *node, int submitOrderIndex);
     void executeCommands(const QVector<RenderCommand *> &commands);
+    RenderAttribute *updateBuffersAndAttributes(RenderGeometry *geometry, RenderCommand *command, GLuint &count, bool forceUpdate);
     void addAllocator(QFrameAllocator *allocator);
 
     inline MeshDataManager *meshDataManager() const { return m_meshDataManager; }
@@ -290,6 +291,10 @@ private:
     QScopedPointer<QOpenGLDebugLogger> m_debugLogger;
     QList<AbstractSceneParser *> m_sceneParsers;
     QVector<QFrameAllocator *> m_allocators;
+
+    QVector<RenderAttribute *> m_dirtyAttributes;
+    QVector<RenderGeometry *> m_dirtyGeometry;
+    QVector<RenderBuffer *> m_dirtyBuffers;
 };
 
 } // namespace Render
diff --git a/src/render/backend/renderview.cpp b/src/render/backend/renderview.cpp
index 7800a8184..f3ded5bd3 100644
--- a/src/render/backend/renderview.cpp
+++ b/src/render/backend/renderview.cpp
@@ -56,6 +56,7 @@
 #include <Qt3DRenderer/private/renderlogging_p.h>
 #include <Qt3DRenderer/private/renderpassfilternode_p.h>
 #include <Qt3DRenderer/private/renderrenderpass_p.h>
+#include <Qt3DRenderer/private/rendergeometryrenderer_p.h>
 #include <Qt3DRenderer/private/renderstate_p.h>
 #include <Qt3DRenderer/private/techniquefilternode_p.h>
 #include <Qt3DRenderer/private/viewportnode_p.h>
@@ -370,11 +371,12 @@ void RenderView::buildRenderCommands(RenderEntity *node)
 {
     // Build renderCommand for current node
     if (isEntityInLayers(node, m_data->m_layers)) {
-        RenderMesh *mesh = Q_NULLPTR;
-        if (node->componentHandle<RenderMesh, 16>() != HMesh()
-                && (mesh = node->renderComponent<RenderMesh>()) != Q_NULLPTR
-                && mesh->isEnabled()) {
-            if (!mesh->meshDataHandle().isNull()) {
+        RenderGeometryRenderer *geometryRenderer = Q_NULLPTR;
+        if (node->componentHandle<RenderGeometryRenderer, 16>() != HGeometryRenderer()
+                && (geometryRenderer = node->renderComponent<RenderGeometryRenderer>()) != Q_NULLPTR) {
+
+            // There is a geometry renderer
+            if (geometryRenderer != Q_NULLPTR && !geometryRenderer->geometryId().isNull()) {
                 // TO DO: Perform culling here
                 // As shaders may be deforming, transforming the mesh
                 // We might want to make that optional or dependent on an explicit bounding box item
@@ -426,7 +428,9 @@ void RenderView::buildRenderCommands(RenderEntity *node)
 
                     RenderCommand *command = m_allocator->allocate<RenderCommand>();
                     command->m_depth = m_data->m_eyePos.distanceToPoint(node->worldBoundingVolume()->center());
-                    command->m_meshData = mesh->meshDataHandle();
+
+                    command->m_geometry = m_renderer->geometryManager()->lookupHandle(geometryRenderer->geometryId());
+                    command->m_geometryRenderer = node->componentHandle<RenderGeometryRenderer, 16>();
                     command->m_instancesCount = 0;
                     command->m_stateSet = Q_NULLPTR;
                     command->m_changeCost = 0;