QGeometryRenderer: add index buffer byte-offset property

Add property to QGeometryRender to set a byte-offset into the index
buffer. The property will only be valid when the geometry has an index
buffer attribute.

Task-number: QTBUG-60027
Change-Id: I87409b89766e622fd9a4ab8233f0bc0578f15852
Reviewed-by: Paul Lemire <paul.lemire@kdab.com>

8 files changed, 81 insertions, 1 deletions

diff --git a/src/render/backend/renderer.cpp b/src/render/backend/renderer.cpp
index ca970aebb..3bfaa72c4 100644
--- a/src/render/backend/renderer.cpp
+++ b/src/render/backend/renderer.cpp
@@ -883,7 +883,7 @@ void Renderer::prepareCommandsSubmission(const QVector<RenderView *> &renderView
                     // Update the draw command with all the information required for the drawing
                     if (command->m_drawIndexed) {
                         command->m_indexAttributeDataType = GraphicsContext::glDataTypeFromAttributeDataType(indexAttribute->vertexBaseType());
-                        command->m_indexAttributeByteOffset = indexAttribute->byteOffset();
+                        command->m_indexAttributeByteOffset = indexAttribute->byteOffset() + rGeometryRenderer->indexBufferByteOffset();
                     }
 
                     // Note: we only care about the primitiveCount when using direct draw calls
diff --git a/src/render/geometry/geometryrenderer.cpp b/src/render/geometry/geometryrenderer.cpp
index d69cbcbd9..978ee6252 100644
--- a/src/render/geometry/geometryrenderer.cpp
+++ b/src/render/geometry/geometryrenderer.cpp
@@ -64,6 +64,7 @@ GeometryRenderer::GeometryRenderer()
     , m_indexOffset(0)
     , m_firstInstance(0)
     , m_firstVertex(0)
+    , m_indexBufferByteOffset(0)
     , m_restartIndexValue(-1)
     , m_verticesPerPatch(0)
     , m_primitiveRestartEnabled(false)
@@ -85,6 +86,7 @@ void GeometryRenderer::cleanup()
     m_indexOffset = 0;
     m_firstInstance = 0;
     m_firstVertex = 0;
+    m_indexBufferByteOffset = 0;
     m_restartIndexValue = -1;
     m_verticesPerPatch = 0;
     m_primitiveRestartEnabled = false;
@@ -111,6 +113,7 @@ void GeometryRenderer::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBase
     m_indexOffset = data.indexOffset;
     m_firstInstance = data.firstInstance;
     m_firstVertex = data.firstVertex;
+    m_indexBufferByteOffset = data.indexBufferByteOffset;
     m_restartIndexValue = data.restartIndexValue;
     m_verticesPerPatch = data.verticesPerPatch;
     m_primitiveRestartEnabled = data.primitiveRestart;
@@ -146,6 +149,9 @@ void GeometryRenderer::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
         } else if (propertyName == QByteArrayLiteral("firstVertex")) {
             m_firstVertex = propertyChange->value().value<int>();
             m_dirty = true;
+        } else if (propertyName == QByteArrayLiteral("indexBufferByteOffset")) {
+            m_indexBufferByteOffset = propertyChange->value().value<int>();
+            m_dirty = true;
         } else if (propertyName == QByteArrayLiteral("restartIndexValue")) {
             m_restartIndexValue = propertyChange->value().value<int>();
             m_dirty = true;
diff --git a/src/render/geometry/geometryrenderer_p.h b/src/render/geometry/geometryrenderer_p.h
index 24edf6152..5a7358f00 100644
--- a/src/render/geometry/geometryrenderer_p.h
+++ b/src/render/geometry/geometryrenderer_p.h
@@ -83,6 +83,7 @@ public:
     inline int indexOffset() const { return m_indexOffset; }
     inline int firstInstance() const { return m_firstInstance; }
     inline int firstVertex() const { return m_firstVertex; }
+    inline int indexBufferByteOffset() const { return m_indexBufferByteOffset; }
     inline int restartIndexValue() const { return m_restartIndexValue; }
     inline int verticesPerPatch() const { return m_verticesPerPatch; }
     inline bool primitiveRestartEnabled() const { return m_primitiveRestartEnabled; }
@@ -105,6 +106,7 @@ private:
     int m_indexOffset;
     int m_firstInstance;
     int m_firstVertex;
+    int m_indexBufferByteOffset;
     int m_restartIndexValue;
     int m_verticesPerPatch;
     bool m_primitiveRestartEnabled;
diff --git a/src/render/geometry/qgeometryrenderer.cpp b/src/render/geometry/qgeometryrenderer.cpp
index 443b7cbac..666c72d83 100644
--- a/src/render/geometry/qgeometryrenderer.cpp
+++ b/src/render/geometry/qgeometryrenderer.cpp
@@ -58,6 +58,7 @@ QGeometryRendererPrivate::QGeometryRendererPrivate()
     , m_indexOffset(0)
     , m_firstInstance(0)
     , m_firstVertex(0)
+    , m_indexBufferByteOffset(0)
     , m_restartIndexValue(-1)
     , m_verticesPerPatch(0)
     , m_primitiveRestart(false)
@@ -145,6 +146,12 @@ QGeometryRendererPrivate::~QGeometryRendererPrivate()
  */
 
 /*!
+    \qmlproperty int GeometryRenderer::indexBufferByteOffset
+
+    Holds the byte offset into the index buffer.
+ */
+
+/*!
     \qmlproperty int GeometryRenderer::restartIndex
 
     Holds the restart index.
@@ -269,6 +276,17 @@ int QGeometryRenderer::firstVertex() const
 }
 
 /*!
+    \property QGeometryRenderer::indexBufferByteOffset
+
+    Holds the byte offset into the index buffer.
+ */
+int QGeometryRenderer::indexBufferByteOffset() const
+{
+    Q_D(const QGeometryRenderer);
+    return d->m_indexBufferByteOffset;
+}
+
+/*!
     \property QGeometryRenderer::restartIndexValue
 
     Holds the restart index.
@@ -382,6 +400,16 @@ void QGeometryRenderer::setFirstVertex(int firstVertex)
     emit firstVertexChanged(firstVertex);
 }
 
+void QGeometryRenderer::setIndexBufferByteOffset(int offset)
+{
+    Q_D(QGeometryRenderer);
+    if (d->m_indexBufferByteOffset == offset)
+        return;
+
+    d->m_indexBufferByteOffset = offset;
+    emit indexBufferByteOffsetChanged(offset);
+}
+
 void QGeometryRenderer::setRestartIndexValue(int index)
 {
     Q_D(QGeometryRenderer);
@@ -482,6 +510,7 @@ Qt3DCore::QNodeCreatedChangeBasePtr QGeometryRenderer::createNodeCreationChange(
     data.indexOffset = d->m_indexOffset;
     data.firstInstance = d->m_firstInstance;
     data.firstVertex = d->m_firstVertex;
+    data.indexBufferByteOffset = d->m_indexBufferByteOffset;
     data.restartIndexValue = d->m_restartIndexValue;
     data.verticesPerPatch = d->m_verticesPerPatch;
     data.primitiveRestart = d->m_primitiveRestart;
diff --git a/src/render/geometry/qgeometryrenderer.h b/src/render/geometry/qgeometryrenderer.h
index 28d580990..704e2f89f 100644
--- a/src/render/geometry/qgeometryrenderer.h
+++ b/src/render/geometry/qgeometryrenderer.h
@@ -61,6 +61,7 @@ class QT3DRENDERSHARED_EXPORT QGeometryRenderer : public Qt3DCore::QComponent
     Q_PROPERTY(int indexOffset READ indexOffset WRITE setIndexOffset NOTIFY indexOffsetChanged)
     Q_PROPERTY(int firstInstance READ firstInstance WRITE setFirstInstance NOTIFY firstInstanceChanged)
     Q_PROPERTY(int firstVertex READ firstVertex WRITE setFirstVertex NOTIFY firstVertexChanged)
+    Q_PROPERTY(int indexBufferByteOffset READ indexBufferByteOffset WRITE setIndexBufferByteOffset NOTIFY indexBufferByteOffsetChanged)
     Q_PROPERTY(int restartIndexValue READ restartIndexValue WRITE setRestartIndexValue NOTIFY restartIndexValueChanged)
     Q_PROPERTY(int verticesPerPatch READ verticesPerPatch WRITE setVerticesPerPatch NOTIFY verticesPerPatchChanged)
     Q_PROPERTY(bool primitiveRestartEnabled READ primitiveRestartEnabled WRITE setPrimitiveRestartEnabled NOTIFY primitiveRestartEnabledChanged)
@@ -95,6 +96,7 @@ public:
     int indexOffset() const;
     int firstInstance() const;
     int firstVertex() const;
+    int indexBufferByteOffset() const;
     int restartIndexValue() const;
     int verticesPerPatch() const;
     bool primitiveRestartEnabled() const;
@@ -110,6 +112,7 @@ public Q_SLOTS:
     void setIndexOffset(int indexOffset);
     void setFirstInstance(int firstInstance);
     void setFirstVertex(int firstVertex);
+    void setIndexBufferByteOffset(int offset);
     void setRestartIndexValue(int index);
     void setVerticesPerPatch(int verticesPerPatch);
     void setPrimitiveRestartEnabled(bool enabled);
@@ -122,6 +125,7 @@ Q_SIGNALS:
     void indexOffsetChanged(int indexOffset);
     void firstInstanceChanged(int firstInstance);
     void firstVertexChanged(int firstVertex);
+    void indexBufferByteOffsetChanged(int offset);
     void restartIndexValueChanged(int restartIndexValue);
     void verticesPerPatchChanged(int verticesPerPatch);
     void primitiveRestartEnabledChanged(bool primitiveRestartEnabled);
diff --git a/src/render/geometry/qgeometryrenderer_p.h b/src/render/geometry/qgeometryrenderer_p.h
index 324dc9609..8096b4a6b 100644
--- a/src/render/geometry/qgeometryrenderer_p.h
+++ b/src/render/geometry/qgeometryrenderer_p.h
@@ -75,6 +75,7 @@ public:
     int m_indexOffset;
     int m_firstInstance;
     int m_firstVertex;
+    int m_indexBufferByteOffset;
     int m_restartIndexValue;
     int m_verticesPerPatch;
     bool m_primitiveRestart;
@@ -90,6 +91,7 @@ struct QGeometryRendererData
     int indexOffset;
     int firstInstance;
     int firstVertex;
+    int indexBufferByteOffset;
     int restartIndexValue;
     int verticesPerPatch;
     bool primitiveRestart;
diff --git a/tests/auto/render/geometryrenderer/tst_geometryrenderer.cpp b/tests/auto/render/geometryrenderer/tst_geometryrenderer.cpp
index da1d98c44..9b3907360 100644
--- a/tests/auto/render/geometryrenderer/tst_geometryrenderer.cpp
+++ b/tests/auto/render/geometryrenderer/tst_geometryrenderer.cpp
@@ -90,6 +90,7 @@ private Q_SLOTS:
         geometryRenderer.setVertexCount(1609);
         geometryRenderer.setIndexOffset(750);
         geometryRenderer.setFirstInstance(883);
+        geometryRenderer.setIndexBufferByteOffset(96);
         geometryRenderer.setRestartIndexValue(65536);
         geometryRenderer.setPrimitiveRestartEnabled(true);
         geometryRenderer.setPrimitiveType(Qt3DRender::QGeometryRenderer::Patches);
@@ -108,6 +109,7 @@ private Q_SLOTS:
         QCOMPARE(renderGeometryRenderer.vertexCount(), geometryRenderer.vertexCount());
         QCOMPARE(renderGeometryRenderer.indexOffset(), geometryRenderer.indexOffset());
         QCOMPARE(renderGeometryRenderer.firstInstance(), geometryRenderer.firstInstance());
+        QCOMPARE(renderGeometryRenderer.indexBufferByteOffset(), geometryRenderer.indexBufferByteOffset());
         QCOMPARE(renderGeometryRenderer.restartIndexValue(), geometryRenderer.restartIndexValue());
         QCOMPARE(renderGeometryRenderer.primitiveRestartEnabled(), geometryRenderer.primitiveRestartEnabled());
         QCOMPARE(renderGeometryRenderer.primitiveType(), geometryRenderer.primitiveType());
@@ -131,6 +133,7 @@ private Q_SLOTS:
         QCOMPARE(renderGeometryRenderer.vertexCount(), 0);
         QCOMPARE(renderGeometryRenderer.indexOffset(), 0);
         QCOMPARE(renderGeometryRenderer.firstInstance(), 0);
+        QCOMPARE(renderGeometryRenderer.indexBufferByteOffset(), 0);
         QCOMPARE(renderGeometryRenderer.restartIndexValue(), -1);
         QCOMPARE(renderGeometryRenderer.primitiveRestartEnabled(), false);
         QCOMPARE(renderGeometryRenderer.primitiveType(), Qt3DRender::QGeometryRenderer::Triangles);
@@ -147,6 +150,7 @@ private Q_SLOTS:
         geometryRenderer.setVertexCount(350);
         geometryRenderer.setIndexOffset(427);
         geometryRenderer.setFirstInstance(383);
+        geometryRenderer.setIndexBufferByteOffset(96);
         geometryRenderer.setRestartIndexValue(555);
         geometryRenderer.setPrimitiveRestartEnabled(true);
         geometryRenderer.setPrimitiveType(Qt3DRender::QGeometryRenderer::Patches);
@@ -166,6 +170,7 @@ private Q_SLOTS:
         QCOMPARE(renderGeometryRenderer.vertexCount(), 0);
         QCOMPARE(renderGeometryRenderer.indexOffset(), 0);
         QCOMPARE(renderGeometryRenderer.firstInstance(), 0);
+        QCOMPARE(renderGeometryRenderer.indexBufferByteOffset(), 0);
         QCOMPARE(renderGeometryRenderer.restartIndexValue(), -1);
         QCOMPARE(renderGeometryRenderer.primitiveRestartEnabled(), false);
         QCOMPARE(renderGeometryRenderer.primitiveType(), Qt3DRender::QGeometryRenderer::Triangles);
@@ -247,6 +252,22 @@ private Q_SLOTS:
 
         // WHEN
         updateChange.reset(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId()));
+        updateChange->setPropertyName("indexBufferByteOffset");
+        updateChange->setValue(96);
+        renderGeometryRenderer.sceneChangeEvent(updateChange);
+
+        // THEN
+        QCOMPARE(renderGeometryRenderer.indexBufferByteOffset(), 96);
+        QVERIFY(renderGeometryRenderer.isDirty());
+
+        QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::GeometryDirty);
+        renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
+
+        renderGeometryRenderer.unsetDirty();
+        QVERIFY(!renderGeometryRenderer.isDirty());
+
+        // WHEN
+        updateChange.reset(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId()));
         updateChange->setPropertyName("restartIndexValue");
         updateChange->setValue(46);
         renderGeometryRenderer.sceneChangeEvent(updateChange);
diff --git a/tests/auto/render/qgeometryrenderer/tst_qgeometryrenderer.cpp b/tests/auto/render/qgeometryrenderer/tst_qgeometryrenderer.cpp
index 94f720097..edd767ad9 100644
--- a/tests/auto/render/qgeometryrenderer/tst_qgeometryrenderer.cpp
+++ b/tests/auto/render/qgeometryrenderer/tst_qgeometryrenderer.cpp
@@ -88,6 +88,7 @@ private Q_SLOTS:
         geometry1->setInstanceCount(1);
         geometry1->setIndexOffset(0);
         geometry1->setFirstInstance(55);
+        geometry1->setIndexBufferByteOffset(48);
         geometry1->setRestartIndexValue(-1);
         geometry1->setPrimitiveRestartEnabled(false);
         geometry1->setPrimitiveType(Qt3DRender::QGeometryRenderer::Triangles);
@@ -101,6 +102,7 @@ private Q_SLOTS:
         geometry2->setInstanceCount(200);
         geometry2->setIndexOffset(58);
         geometry2->setFirstInstance(10);
+        geometry2->setIndexBufferByteOffset(96);
         geometry2->setRestartIndexValue(65535);
         geometry2->setVertexCount(2056);
         geometry2->setPrimitiveRestartEnabled(true);
@@ -134,6 +136,7 @@ private Q_SLOTS:
         QCOMPARE(cloneData.vertexCount, geometryRenderer->vertexCount());
         QCOMPARE(cloneData.indexOffset, geometryRenderer->indexOffset());
         QCOMPARE(cloneData.firstInstance, geometryRenderer->firstInstance());
+        QCOMPARE(cloneData.indexBufferByteOffset, geometryRenderer->indexBufferByteOffset());
         QCOMPARE(cloneData.restartIndexValue, geometryRenderer->restartIndexValue());
         QCOMPARE(cloneData.primitiveRestart, geometryRenderer->primitiveRestartEnabled());
         QCOMPARE(cloneData.primitiveType, geometryRenderer->primitiveType());
@@ -207,6 +210,19 @@ private Q_SLOTS:
         arbiter.events.clear();
 
         // WHEN
+        geometryRenderer->setIndexBufferByteOffset(91);
+        QCoreApplication::processEvents();
+
+        // THEN
+        QCOMPARE(arbiter.events.size(), 1);
+        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
+        QCOMPARE(change->propertyName(), "indexBufferByteOffset");
+        QCOMPARE(change->value().value<int>(), 91);
+        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+
+        arbiter.events.clear();
+
+        // WHEN
         geometryRenderer->setRestartIndexValue(65535);
         QCoreApplication::processEvents();