Handle primitive restart in buffer visitor

Task-number: QTBUG-66407
Change-Id: Ic79851e94fcadee8f707cb2682938692db094aa7
Reviewed-by: Mike Krus <mike.krus@kdab.com>
Reviewed-by: Sean Harmer <sean.harmer@kdab.com>

2 files changed, 69 insertions, 25 deletions

diff --git a/src/render/backend/buffervisitor_p.h b/src/render/backend/buffervisitor_p.h
index 97851dab0..4870171b1 100644
--- a/src/render/backend/buffervisitor_p.h
+++ b/src/render/backend/buffervisitor_p.h
@@ -95,7 +95,11 @@ public:
         Q_UNUSED(ndx); Q_UNUSED(x); Q_UNUSED(y); Q_UNUSED(z); Q_UNUSED(w);
     }
 
-    bool apply(Qt3DRender::Render::Attribute *attribute, Qt3DRender::Render::Attribute *indexAttribute, int drawVertexCount)
+    bool apply(Qt3DRender::Render::Attribute *attribute,
+               Qt3DRender::Render::Attribute *indexAttribute,
+               int drawVertexCount,
+               bool primitiveRestartEnabled,
+               int primitiveRestartIndex)
     {
         if (attribute->vertexBaseType() != VertexBaseType)
             return false;
@@ -110,19 +114,35 @@ public:
             if (indexAttribute->vertexBaseType() == QAttribute::UnsignedShort) {
                 auto indexBuffer = BufferTypeInfo::castToType<QAttribute::UnsignedShort>(indexData, indexAttribute->byteOffset());
                 switch (dataSize) {
-                case 1: traverseCoordinates1Indexed(buffer, attribute->byteStride(), indexBuffer, drawVertexCount); break;
-                case 2: traverseCoordinates2Indexed(buffer, attribute->byteStride(), indexBuffer, drawVertexCount); break;
-                case 3: traverseCoordinates3Indexed(buffer, attribute->byteStride(), indexBuffer, drawVertexCount); break;
-                case 4: traverseCoordinates4Indexed(buffer, attribute->byteStride(), indexBuffer, drawVertexCount); break;
+                case 1: traverseCoordinates1Indexed(buffer, attribute->byteStride(), indexBuffer, drawVertexCount,
+                                                    primitiveRestartEnabled, primitiveRestartIndex);
+                    break;
+                case 2: traverseCoordinates2Indexed(buffer, attribute->byteStride(), indexBuffer, drawVertexCount,
+                                                    primitiveRestartEnabled, primitiveRestartIndex);
+                    break;
+                case 3: traverseCoordinates3Indexed(buffer, attribute->byteStride(), indexBuffer, drawVertexCount,
+                                                    primitiveRestartEnabled, primitiveRestartIndex);
+                    break;
+                case 4: traverseCoordinates4Indexed(buffer, attribute->byteStride(), indexBuffer, drawVertexCount,
+                                                    primitiveRestartEnabled, primitiveRestartIndex);
+                    break;
                 default: Q_UNREACHABLE();
                 }
             } else {
                 auto indexBuffer = BufferTypeInfo::castToType<QAttribute::UnsignedInt>(indexData, indexAttribute->byteOffset());
                 switch (dataSize) {
-                case 1: traverseCoordinates1Indexed(buffer, attribute->byteStride(), indexBuffer, drawVertexCount); break;
-                case 2: traverseCoordinates2Indexed(buffer, attribute->byteStride(), indexBuffer, drawVertexCount); break;
-                case 3: traverseCoordinates3Indexed(buffer, attribute->byteStride(), indexBuffer, drawVertexCount); break;
-                case 4: traverseCoordinates4Indexed(buffer, attribute->byteStride(), indexBuffer, drawVertexCount); break;
+                case 1: traverseCoordinates1Indexed(buffer, attribute->byteStride(), indexBuffer, drawVertexCount,
+                                                    primitiveRestartEnabled, primitiveRestartIndex);
+                    break;
+                case 2: traverseCoordinates2Indexed(buffer, attribute->byteStride(), indexBuffer, drawVertexCount,
+                                                    primitiveRestartEnabled, primitiveRestartIndex);
+                    break;
+                case 3: traverseCoordinates3Indexed(buffer, attribute->byteStride(), indexBuffer, drawVertexCount,
+                                                    primitiveRestartEnabled, primitiveRestartIndex);
+                    break;
+                case 4: traverseCoordinates4Indexed(buffer, attribute->byteStride(), indexBuffer, drawVertexCount,
+                                                    primitiveRestartEnabled, primitiveRestartIndex);
+                    break;
                 default: Q_UNREACHABLE();
                 }
             }
@@ -157,12 +177,16 @@ protected:
     void traverseCoordinates1Indexed(Coordinate *coordinates,
                                      const uint byteStride,
                                      IndexElem *indices,
-                                     const uint count)
+                                     const uint count,
+                                     bool primitiveRestartEnabled,
+                                     int primitiveRestartIndex)
     {
         const uint stride = byteStride / sizeof(Coordinate);
         for (uint i = 0; i < count; ++i) {
-            const uint n = stride * indices[i];
-            visit(i, coordinates[n]);
+            if (!primitiveRestartEnabled || indices[i] != primitiveRestartIndex) {
+                const uint n = stride * indices[i];
+                visit(i, coordinates[n]);
+            }
         }
     }
 
@@ -183,12 +207,16 @@ protected:
     void traverseCoordinates2Indexed(Coordinate *coordinates,
                                      const uint byteStride,
                                      IndexElem *indices,
-                                     const uint count)
+                                     const uint count,
+                                     bool primitiveRestartEnabled,
+                                     int primitiveRestartIndex)
     {
         const uint stride = byteStride / sizeof(Coordinate);
         for (uint i = 0; i < count; ++i) {
-            const uint n = stride * indices[i];
-            visit(i, coordinates[n], coordinates[n + 1]);
+            if (!primitiveRestartEnabled || indices[i] != primitiveRestartIndex) {
+                const uint n = stride * indices[i];
+                visit(i, coordinates[n], coordinates[n + 1]);
+            }
         }
     }
 
@@ -208,12 +236,16 @@ protected:
     void traverseCoordinates3Indexed(Coordinate *coordinates,
                                      const uint byteStride,
                                      IndexElem *indices,
-                                     const uint count)
+                                     const uint count,
+                                     bool primitiveRestartEnabled,
+                                     int primitiveRestartIndex)
     {
         const uint stride = byteStride / sizeof(Coordinate);
         for (uint i = 0; i < count; ++i) {
-            const uint n = stride * indices[i];
-            visit(i, coordinates[n], coordinates[n + 1], coordinates[n + 2]);
+            if (!primitiveRestartEnabled || indices[i] != primitiveRestartIndex) {
+                const uint n = stride * indices[i];
+                visit(i, coordinates[n], coordinates[n + 1], coordinates[n + 2]);
+            }
         }
     }
 
@@ -233,12 +265,16 @@ protected:
     void traverseCoordinates4Indexed(Coordinate *coordinates,
                                      const uint byteStride,
                                      IndexElem *indices,
-                                     const uint count)
+                                     const uint count,
+                                     bool primitiveRestartEnabled,
+                                     int primitiveRestartIndex)
     {
         const uint stride = byteStride / sizeof(Coordinate);
         for (uint i = 0; i < count; ++i) {
-            const uint n = stride * indices[i];
-            visit(i, coordinates[n], coordinates[n + 1], coordinates[n + 2], coordinates[n + 3]);
+            if (!primitiveRestartEnabled || indices[i] != primitiveRestartIndex) {
+                const uint n = stride * indices[i];
+                visit(i, coordinates[n], coordinates[n + 1], coordinates[n + 2], coordinates[n + 3]);
+            }
         }
     }
 
diff --git a/src/render/jobs/calcboundingvolumejob.cpp b/src/render/jobs/calcboundingvolumejob.cpp
index 0a6e5dfca..021478396 100644
--- a/src/render/jobs/calcboundingvolumejob.cpp
+++ b/src/render/jobs/calcboundingvolumejob.cpp
@@ -81,10 +81,15 @@ public:
 
     const Sphere& result() { return m_volume; }
 
-    bool apply(Qt3DRender::Render::Attribute *positionAttribute, Qt3DRender::Render::Attribute *indexAttribute, int drawVertexCount)
+    bool apply(Qt3DRender::Render::Attribute *positionAttribute,
+               Qt3DRender::Render::Attribute *indexAttribute,
+               int drawVertexCount,
+               bool primitiveRestartEnabled,
+               int primitiveRestartIndex)
     {
         FindExtremePoints findExtremePoints(m_manager);
-        if (!findExtremePoints.apply(positionAttribute, indexAttribute, drawVertexCount))
+        if (!findExtremePoints.apply(positionAttribute, indexAttribute,
+                                     drawVertexCount, primitiveRestartEnabled, primitiveRestartIndex))
             return false;
 
         // Calculate squared distance for the pairs of points
@@ -109,7 +114,8 @@ public:
         m_volume.setRadius((q - c).length());
 
         ExpandSphere expandSphere(m_manager, m_volume);
-        if (!expandSphere.apply(positionAttribute, indexAttribute, drawVertexCount))
+        if (!expandSphere.apply(positionAttribute, indexAttribute,
+                                drawVertexCount, primitiveRestartEnabled, primitiveRestartIndex))
             return false;
 
         return true;
@@ -268,7 +274,9 @@ void calculateLocalBoundingVolume(NodeManagers *manager, Entity *node)
                     (indexBuf && indexBuf->isDirty()))
             {
                 BoundingVolumeCalculator reader(manager);
-                if (reader.apply(positionAttribute, indexAttribute, drawVertexCount)) {
+                if (reader.apply(positionAttribute, indexAttribute,
+                                 drawVertexCount, gRenderer->primitiveRestartEnabled(), gRenderer->restartIndexValue()))
+                {
                     node->localBoundingVolume()->setCenter(reader.result().center());
                     node->localBoundingVolume()->setRadius(reader.result().radius());
                     node->unsetBoundingVolumeDirty();