Update buffer visitor

Optimize iteration in non-primitive-restart case; remove code
duplication.

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

2 files changed, 46 insertions, 174 deletions

diff --git a/src/core/geometry/buffervisitor_p.h b/src/core/geometry/buffervisitor_p.h
index b1166555b..d6e730626 100644
--- a/src/core/geometry/buffervisitor_p.h
+++ b/src/core/geometry/buffervisitor_p.h
@@ -178,8 +178,15 @@ protected:
                                      int primitiveRestartIndex)
     {
         const uint stride = byteStride / sizeof(Coordinate);
-        for (uint i = 0; i < count; ++i) {
-            if (!primitiveRestartEnabled || static_cast<int>(indices[i]) != primitiveRestartIndex) {
+        if (primitiveRestartEnabled) {
+            for (uint i = 0; i < count; ++i) {
+                if (static_cast<int>(indices[i]) != primitiveRestartIndex) {
+                    const uint n = stride * indices[i];
+                    visit(i, coordinates[n]);
+                }
+            }
+        } else {
+            for (uint i = 0; i < count; ++i) {
                 const uint n = stride * indices[i];
                 visit(i, coordinates[n]);
             }
@@ -198,7 +205,6 @@ protected:
         }
     }
 
-
     template <typename Coordinate, typename IndexElem>
     void traverseCoordinates2Indexed(Coordinate *coordinates,
                                      const uint byteStride,
@@ -208,8 +214,15 @@ protected:
                                      int primitiveRestartIndex)
     {
         const uint stride = byteStride ? byteStride / sizeof(Coordinate) : 2;
-        for (uint i = 0; i < count; ++i) {
-            if (!primitiveRestartEnabled || static_cast<int>(indices[i]) != primitiveRestartIndex) {
+        if (primitiveRestartEnabled) {
+            for (uint i = 0; i < count; ++i) {
+                if (static_cast<int>(indices[i]) != primitiveRestartIndex) {
+                    const uint n = stride * indices[i];
+                    visit(i, coordinates[n], coordinates[n + 1]);
+                }
+            }
+        } else {
+            for (uint i = 0; i < count; ++i) {
                 const uint n = stride * indices[i];
                 visit(i, coordinates[n], coordinates[n + 1]);
             }
@@ -237,8 +250,15 @@ protected:
                                      int primitiveRestartIndex)
     {
         const uint stride = byteStride ? byteStride / sizeof(Coordinate) : 3;
-        for (uint i = 0; i < count; ++i) {
-            if (!primitiveRestartEnabled || static_cast<int>(indices[i]) != primitiveRestartIndex) {
+        if (primitiveRestartEnabled) {
+            for (uint i = 0; i < count; ++i) {
+                if (static_cast<int>(indices[i]) != primitiveRestartIndex) {
+                    const uint n = stride * indices[i];
+                    visit(i, coordinates[n], coordinates[n + 1], coordinates[n + 2]);
+                }
+            }
+        } else {
+            for (uint i = 0; i < count; ++i) {
                 const uint n = stride * indices[i];
                 visit(i, coordinates[n], coordinates[n + 1], coordinates[n + 2]);
             }
@@ -266,8 +286,15 @@ protected:
                                      int primitiveRestartIndex)
     {
         const uint stride = byteStride ? byteStride / sizeof(Coordinate) : 4;
-        for (uint i = 0; i < count; ++i) {
-            if (!primitiveRestartEnabled || static_cast<int>(indices[i]) != primitiveRestartIndex) {
+        if (primitiveRestartEnabled) {
+            for (uint i = 0; i < count; ++i) {
+                if (static_cast<int>(indices[i]) != primitiveRestartIndex) {
+                    const uint n = stride * indices[i];
+                    visit(i, coordinates[n], coordinates[n + 1], coordinates[n + 2], coordinates[n + 3]);
+                }
+            }
+        } else {
+            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]);
             }
diff --git a/src/render/backend/buffervisitor_p.h b/src/render/backend/buffervisitor_p.h
index 6d916208b..ab5a62c14 100644
--- a/src/render/backend/buffervisitor_p.h
+++ b/src/render/backend/buffervisitor_p.h
@@ -53,6 +53,7 @@
 
 #include <Qt3DCore/qnodeid.h>
 #include <Qt3DCore/qattribute.h>
+#include <Qt3DCore/private/buffervisitor_p.h>
 #include <Qt3DRender/private/trianglesvisitor_p.h>
 #include <Qt3DRender/private/attribute_p.h>
 #include <Qt3DRender/private/buffer_p.h>
@@ -73,52 +74,14 @@ namespace Render {
 
 
 template <typename ValueType, Qt3DCore::QAttribute::VertexBaseType VertexBaseType, uint dataSize>
-class Q_AUTOTEST_EXPORT BufferVisitor
+class Q_AUTOTEST_EXPORT BufferVisitor : public Qt3DCore::BufferVisitor<ValueType, VertexBaseType, dataSize>
 {
 public:
     explicit BufferVisitor(NodeManagers *manager)
         : m_manager(manager)
     {
     }
-    virtual ~BufferVisitor() { }
-
-    virtual void visit(uint ndx, ValueType x) {
-        Q_UNUSED(ndx); Q_UNUSED(x);
-    }
-    virtual void visit(uint ndx, ValueType x, ValueType y) {
-        Q_UNUSED(ndx); Q_UNUSED(x); Q_UNUSED(y);
-    }
-    virtual void visit(uint ndx, ValueType x, ValueType y, ValueType z) {
-        Q_UNUSED(ndx); Q_UNUSED(x); Q_UNUSED(y); Q_UNUSED(z);
-    }
-    virtual void visit(uint ndx, ValueType x, ValueType y, ValueType z, ValueType w) {
-        Q_UNUSED(ndx); Q_UNUSED(x); Q_UNUSED(y); Q_UNUSED(z); Q_UNUSED(w);
-    }
-
-    template<typename VertexBufferType, typename IndexBufferType>
-    void traverseCoordinateIndexed(VertexBufferType *vertexBuffer,
-                                   IndexBufferType *indexBuffer,
-                                   int vertexByteStride,
-                                   int drawVertexCount,
-                                   bool primitiveRestartEnabled,
-                                   int primitiveRestartIndex)
-    {
-        switch (dataSize) {
-        case 1: traverseCoordinates1Indexed(vertexBuffer, vertexByteStride, indexBuffer, drawVertexCount,
-                                            primitiveRestartEnabled, primitiveRestartIndex);
-            break;
-        case 2: traverseCoordinates2Indexed(vertexBuffer, vertexByteStride, indexBuffer, drawVertexCount,
-                                            primitiveRestartEnabled, primitiveRestartIndex);
-            break;
-        case 3: traverseCoordinates3Indexed(vertexBuffer, vertexByteStride, indexBuffer, drawVertexCount,
-                                            primitiveRestartEnabled, primitiveRestartIndex);
-            break;
-        case 4: traverseCoordinates4Indexed(vertexBuffer, vertexByteStride, indexBuffer, drawVertexCount,
-                                            primitiveRestartEnabled, primitiveRestartIndex);
-            break;
-        default: Q_UNREACHABLE();
-        }
-    }
+    virtual ~BufferVisitor() = default;
 
     bool apply(Qt3DRender::Render::Attribute *attribute,
                Qt3DRender::Render::Attribute *indexAttribute,
@@ -139,19 +102,19 @@ public:
             switch (indexAttribute->vertexBaseType()) {
             case Qt3DCore::QAttribute::UnsignedShort: {
                 auto indexBuffer = BufferTypeInfo::castToType<Qt3DCore::QAttribute::UnsignedShort>(indexData, indexAttribute->byteOffset());
-                traverseCoordinateIndexed(vertexBuffer, indexBuffer, attribute->byteStride(), drawVertexCount,
+                this->traverseCoordinateIndexed(vertexBuffer, indexBuffer, attribute->byteStride(), drawVertexCount,
                                           primitiveRestartEnabled, primitiveRestartIndex);
                 break;
             }
             case Qt3DCore::QAttribute::UnsignedInt: {
                 auto indexBuffer = BufferTypeInfo::castToType<Qt3DCore::QAttribute::UnsignedInt>(indexData, indexAttribute->byteOffset());
-                traverseCoordinateIndexed(vertexBuffer, indexBuffer, attribute->byteStride(), drawVertexCount,
+                this->traverseCoordinateIndexed(vertexBuffer, indexBuffer, attribute->byteStride(), drawVertexCount,
                                           primitiveRestartEnabled, primitiveRestartIndex);
                 break;
             }
             case Qt3DCore::QAttribute::UnsignedByte: {
                 auto indexBuffer = BufferTypeInfo::castToType<Qt3DCore::QAttribute::UnsignedByte>(indexData, indexAttribute->byteOffset());
-                traverseCoordinateIndexed(vertexBuffer, indexBuffer, attribute->byteStride(), drawVertexCount,
+                this->traverseCoordinateIndexed(vertexBuffer, indexBuffer, attribute->byteStride(), drawVertexCount,
                                           primitiveRestartEnabled, primitiveRestartIndex);
                 break;
             }
@@ -159,10 +122,10 @@ public:
             }
         } else {
             switch (dataSize) {
-            case 1: traverseCoordinates1(vertexBuffer, attribute->byteStride(), drawVertexCount); break;
-            case 2: traverseCoordinates2(vertexBuffer, attribute->byteStride(), drawVertexCount); break;
-            case 3: traverseCoordinates3(vertexBuffer, attribute->byteStride(), drawVertexCount); break;
-            case 4: traverseCoordinates4(vertexBuffer, attribute->byteStride(), drawVertexCount); break;
+            case 1: this->traverseCoordinates1(vertexBuffer, attribute->byteStride(), drawVertexCount); break;
+            case 2: this->traverseCoordinates2(vertexBuffer, attribute->byteStride(), drawVertexCount); break;
+            case 3: this->traverseCoordinates3(vertexBuffer, attribute->byteStride(), drawVertexCount); break;
+            case 4: this->traverseCoordinates4(vertexBuffer, attribute->byteStride(), drawVertexCount); break;
             default: Q_UNREACHABLE();
             }
         }
@@ -171,124 +134,6 @@ public:
     }
 
 protected:
-
-    template <typename Coordinate>
-    void traverseCoordinates1(Coordinate *coordinates,
-                              const uint byteStride,
-                              const uint count)
-    {
-        const uint stride = byteStride / sizeof(Coordinate);
-        for (uint ndx = 0; ndx < count; ++ndx) {
-            visit(ndx, coordinates[0]);
-            coordinates += stride;
-        }
-    }
-
-    template <typename Coordinate, typename IndexElem>
-    void traverseCoordinates1Indexed(Coordinate *coordinates,
-                                     const uint byteStride,
-                                     IndexElem *indices,
-                                     const uint count,
-                                     bool primitiveRestartEnabled,
-                                     int primitiveRestartIndex)
-    {
-        const uint stride = byteStride / sizeof(Coordinate);
-        for (uint i = 0; i < count; ++i) {
-            if (!primitiveRestartEnabled || (int) indices[i] != primitiveRestartIndex) {
-                const uint n = stride * indices[i];
-                visit(i, coordinates[n]);
-            }
-        }
-    }
-
-    template <typename Coordinate>
-    void traverseCoordinates2(Coordinate *coordinates,
-                              const uint byteStride,
-                              const uint count)
-    {
-        const uint stride = byteStride ? byteStride / sizeof(Coordinate) : 2;
-        for (uint ndx = 0; ndx < count; ++ndx) {
-            visit(ndx, coordinates[0], coordinates[1]);
-            coordinates += stride;
-        }
-    }
-
-
-    template <typename Coordinate, typename IndexElem>
-    void traverseCoordinates2Indexed(Coordinate *coordinates,
-                                     const uint byteStride,
-                                     IndexElem *indices,
-                                     const uint count,
-                                     bool primitiveRestartEnabled,
-                                     int primitiveRestartIndex)
-    {
-        const uint stride = byteStride ? byteStride / sizeof(Coordinate) : 2;
-        for (uint i = 0; i < count; ++i) {
-            if (!primitiveRestartEnabled || (int) indices[i] != primitiveRestartIndex) {
-                const uint n = stride * indices[i];
-                visit(i, coordinates[n], coordinates[n + 1]);
-            }
-        }
-    }
-
-    template <typename Coordinate>
-    void traverseCoordinates3(Coordinate *coordinates,
-                              const uint byteStride,
-                              const uint count)
-    {
-        const uint stride = byteStride ? byteStride / sizeof(Coordinate) : 3;
-        for (uint ndx = 0; ndx < count; ++ndx) {
-            visit(ndx, coordinates[0], coordinates[1], coordinates[2]);
-            coordinates += stride;
-        }
-    }
-
-    template <typename Coordinate, typename IndexElem>
-    void traverseCoordinates3Indexed(Coordinate *coordinates,
-                                     const uint byteStride,
-                                     IndexElem *indices,
-                                     const uint count,
-                                     bool primitiveRestartEnabled,
-                                     int primitiveRestartIndex)
-    {
-        const uint stride = byteStride ? byteStride / sizeof(Coordinate) : 3;
-        for (uint i = 0; i < count; ++i) {
-            if (!primitiveRestartEnabled || (int) indices[i] != primitiveRestartIndex) {
-                const uint n = stride * indices[i];
-                visit(i, coordinates[n], coordinates[n + 1], coordinates[n + 2]);
-            }
-        }
-    }
-
-    template <typename Coordinate>
-    void traverseCoordinates4(Coordinate *coordinates,
-                              const uint byteStride,
-                              const uint count)
-    {
-        const uint stride = byteStride ? byteStride / sizeof(Coordinate) : 4;
-        for (uint ndx = 0; ndx < count; ++ndx) {
-            visit(ndx, coordinates[0], coordinates[1], coordinates[2], coordinates[3]);
-            coordinates += stride;
-        }
-    }
-
-    template <typename Coordinate, typename IndexElem>
-    void traverseCoordinates4Indexed(Coordinate *coordinates,
-                                     const uint byteStride,
-                                     IndexElem *indices,
-                                     const uint count,
-                                     bool primitiveRestartEnabled,
-                                     int primitiveRestartIndex)
-    {
-        const uint stride = byteStride ? byteStride / sizeof(Coordinate) : 4;
-        for (uint i = 0; i < count; ++i) {
-            if (!primitiveRestartEnabled || (int) indices[i] != primitiveRestartIndex) {
-                const uint n = stride * indices[i];
-                visit(i, coordinates[n], coordinates[n + 1], coordinates[n + 2], coordinates[n + 3]);
-            }
-        }
-    }
-
     NodeManagers *m_manager;
 };