Convert containers to use std::vector

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

7 files changed, 72 insertions, 73 deletions

diff --git a/src/plugins/geometryloaders/default/basegeometryloader.cpp b/src/plugins/geometryloaders/default/basegeometryloader.cpp
index fe8c2d56c..852f7dc25 100644
--- a/src/plugins/geometryloaders/default/basegeometryloader.cpp
+++ b/src/plugins/geometryloaders/default/basegeometryloader.cpp
@@ -72,10 +72,10 @@ bool BaseGeometryLoader::load(QIODevice *ioDev, const QString &subMesh)
     if (!doLoad(ioDev, subMesh))
         return false;
 
-    if (m_normals.isEmpty())
+    if (m_normals.empty())
         generateAveragedNormals(m_points, m_normals, m_indices);
 
-    if (m_generateTangents && !m_texCoords.isEmpty())
+    if (m_generateTangents && !m_texCoords.empty())
         generateTangents(m_points, m_normals, m_indices, m_texCoords, m_tangents);
 
     if (m_centerMesh)
@@ -93,14 +93,14 @@ bool BaseGeometryLoader::load(QIODevice *ioDev, const QString &subMesh)
     return true;
 }
 
-void BaseGeometryLoader::generateAveragedNormals(const QList<QVector3D> &points,
-                                                 QList<QVector3D> &normals,
-                                                 const QList<unsigned int> &faces) const
+void BaseGeometryLoader::generateAveragedNormals(const std::vector<QVector3D> &points,
+                                                 std::vector<QVector3D> &normals,
+                                                 const std::vector<unsigned int> &faces) const
 {
-    for (int i = 0; i < points.size(); ++i)
-        normals.append(QVector3D());
+    for (size_t i = 0; i < points.size(); ++i)
+        normals.push_back(QVector3D());
 
-    for (int i = 0; i < faces.size(); i += 3) {
+    for (size_t i = 0; i < faces.size(); i += 3) {
         const QVector3D &p1 = points[ faces[i]   ];
         const QVector3D &p2 = points[ faces[i+1] ];
         const QVector3D &p3 = points[ faces[i+2] ];
@@ -114,22 +114,22 @@ void BaseGeometryLoader::generateAveragedNormals(const QList<QVector3D> &points,
         normals[ faces[i+2] ] += n;
     }
 
-    for (int i = 0; i < normals.size(); ++i)
+    for (size_t i = 0; i < normals.size(); ++i)
         normals[i].normalize();
 }
 
 void BaseGeometryLoader::generateGeometry()
 {
     QByteArray bufferBytes;
-    const int count = m_points.size();
+    const size_t count = m_points.size();
     const quint32 elementSize = 3 + (hasTextureCoordinates() ? 2 : 0)
-            + (hasNormals() ? 3 : 0)
-            + (hasTangents() ? 4 : 0);
+        + (hasNormals() ? 3 : 0)
+        + (hasTangents() ? 4 : 0);
     const quint32 stride = elementSize * sizeof(float);
     bufferBytes.resize(stride * count);
     float *fptr = reinterpret_cast<float*>(bufferBytes.data());
 
-    for (int index = 0; index < count; ++index) {
+    for (size_t index = 0; index < count; ++index) {
         *fptr++ = m_points.at(index).x();
         *fptr++ = m_points.at(index).y();
         *fptr++ = m_points.at(index).z();
@@ -206,22 +206,22 @@ void BaseGeometryLoader::generateGeometry()
     m_geometry->addAttribute(indexAttribute);
 }
 
-void BaseGeometryLoader::generateTangents(const QList<QVector3D> &points,
-                                          const QList<QVector3D> &normals,
-                                          const QList<unsigned  int> &faces,
-                                          const QList<QVector2D> &texCoords,
-                                          QList<QVector4D> &tangents) const
+void BaseGeometryLoader::generateTangents(const std::vector<QVector3D> &points,
+                                          const std::vector<QVector3D> &normals,
+                                          const std::vector<unsigned int> &faces,
+                                          const std::vector<QVector2D> &texCoords,
+                                          std::vector<QVector4D> &tangents) const
 {
     tangents.clear();
-    QList<QVector3D> tan1Accum;
-    QList<QVector3D> tan2Accum;
+    std::vector<QVector3D> tan1Accum;
+    std::vector<QVector3D> tan2Accum;
 
     tan1Accum.resize(points.size());
     tan2Accum.resize(points.size());
     tangents.resize(points.size());
 
     // Compute the tangent vector
-    for (int i = 0; i < faces.size(); i += 3) {
+    for (size_t i = 0; i < faces.size(); i += 3) {
         const QVector3D &p1 = points[ faces[i] ];
         const QVector3D &p2 = points[ faces[i+1] ];
         const QVector3D &p3 = points[ faces[i+2] ];
@@ -249,7 +249,7 @@ void BaseGeometryLoader::generateTangents(const QList<QVector3D> &points,
         tan2Accum[ faces[i+2] ] += tan2;
     }
 
-    for (int i = 0; i < points.size(); ++i) {
+    for (size_t i = 0; i < points.size(); ++i) {
         const QVector3D &n = normals[i];
         const QVector3D &t1 = tan1Accum[i];
         const QVector3D &t2 = tan2Accum[i];
@@ -262,16 +262,16 @@ void BaseGeometryLoader::generateTangents(const QList<QVector3D> &points,
     }
 }
 
-void BaseGeometryLoader::center(QList<QVector3D> &points)
+void BaseGeometryLoader::center(std::vector<QVector3D> &points)
 {
-    if (points.isEmpty())
+    if (points.empty())
         return;
 
     const QAxisAlignedBoundingBox bb(points);
     const QVector3D center = bb.center();
 
     // Translate center of the AABB to the origin
-    for (int i = 0; i < points.size(); ++i) {
+    for (size_t i = 0; i < points.size(); ++i) {
         QVector3D &point = points[i];
         point = point - center;
     }
diff --git a/src/plugins/geometryloaders/default/basegeometryloader_p.h b/src/plugins/geometryloaders/default/basegeometryloader_p.h
index 9c40e38bf..d86cd6f97 100644
--- a/src/plugins/geometryloaders/default/basegeometryloader_p.h
+++ b/src/plugins/geometryloaders/default/basegeometryloader_p.h
@@ -52,7 +52,6 @@
 //
 
 #include <QtCore/QObject>
-#include <QtCore/QList>
 
 #include <QtGui/QVector2D>
 #include <QtGui/QVector3D>
@@ -60,6 +59,8 @@
 
 #include <Qt3DRender/private/qgeometryloaderinterface_p.h>
 
+#include <vector>
+
 #include <private/qlocale_tools_p.h>
 
 QT_BEGIN_NAMESPACE
@@ -88,15 +89,15 @@ public:
     void setMeshCenteringEnabled(bool b) { m_centerMesh = b; }
     bool isMeshCenteringEnabled() const { return m_centerMesh; }
 
-    bool hasNormals() const { return !m_normals.isEmpty(); }
-    bool hasTextureCoordinates() const { return !m_texCoords.isEmpty(); }
-    bool hasTangents() const { return !m_tangents.isEmpty(); }
+    bool hasNormals() const { return !m_normals.empty(); }
+    bool hasTextureCoordinates() const { return !m_texCoords.empty(); }
+    bool hasTangents() const { return !m_tangents.empty(); }
 
-    QList<QVector3D> vertices() const { return m_points; }
-    QList<QVector3D> normals() const { return m_normals; }
-    QList<QVector2D> textureCoordinates() const { return m_texCoords; }
-    QList<QVector4D> tangents() const { return m_tangents; }
-    QList<unsigned int> indices() const { return m_indices; }
+    const std::vector<QVector3D> &vertices() const { return m_points; }
+    const std::vector<QVector3D> &normals() const { return m_normals; }
+    const std::vector<QVector2D> &textureCoordinates() const { return m_texCoords; }
+    const std::vector<QVector4D> &tangents() const { return m_tangents; }
+    const std::vector<unsigned int> &indices() const { return m_indices; }
 
     Qt3DCore::QGeometry *geometry() const override;
 
@@ -105,26 +106,26 @@ public:
 protected:
     virtual bool doLoad(QIODevice *ioDev, const QString &subMesh = QString()) = 0;
 
-    void generateAveragedNormals(const QList<QVector3D>& points,
-                                 QList<QVector3D>& normals,
-                                 const QList<unsigned int>& faces) const;
+    void generateAveragedNormals(const std::vector<QVector3D>& points,
+                                 std::vector<QVector3D>& normals,
+                                 const std::vector<unsigned int>& faces) const;
     void generateGeometry();
-    void generateTangents(const QList<QVector3D>& points,
-                          const QList<QVector3D>& normals,
-                          const QList<unsigned int>& faces,
-                          const QList<QVector2D>& texCoords,
-                          QList<QVector4D>& tangents) const;
-    void center(QList<QVector3D>& points);
+    void generateTangents(const std::vector<QVector3D>& points,
+                          const std::vector<QVector3D>& normals,
+                          const std::vector<unsigned int>& faces,
+                          const std::vector<QVector2D>& texCoords,
+                          std::vector<QVector4D>& tangents) const;
+    void center(std::vector<QVector3D>& points);
 
     bool m_loadTextureCoords;
     bool m_generateTangents;
     bool m_centerMesh;
 
-    QList<QVector3D> m_points;
-    QList<QVector3D> m_normals;
-    QList<QVector2D> m_texCoords;
-    QList<QVector4D> m_tangents;
-    QList<unsigned int> m_indices;
+    std::vector<QVector3D> m_points;
+    std::vector<QVector3D> m_normals;
+    std::vector<QVector2D> m_texCoords;
+    std::vector<QVector4D> m_tangents;
+    std::vector<unsigned int> m_indices;
 
     Qt3DCore::QGeometry *m_geometry;
 };
diff --git a/src/plugins/geometryloaders/default/objgeometryloader.cpp b/src/plugins/geometryloaders/default/objgeometryloader.cpp
index 2bc35f06a..14a2b588e 100644
--- a/src/plugins/geometryloaders/default/objgeometryloader.cpp
+++ b/src/plugins/geometryloaders/default/objgeometryloader.cpp
@@ -240,7 +240,7 @@ bool ObjGeometryLoader::doLoad(QIODevice *ioDev, const QString &subMesh)
     m_indices.reserve(indexCount);
     for (const FaceIndices &faceIndices : qAsConst(faceIndexVector)) {
         const unsigned int i = faceIndexMap.value(faceIndices);
-        m_indices.append(i);
+        m_indices.push_back(i);
     }
 
     return true;
diff --git a/src/plugins/geometryloaders/default/plygeometryloader.cpp b/src/plugins/geometryloaders/default/plygeometryloader.cpp
index 95ad183fd..949adeaee 100644
--- a/src/plugins/geometryloaders/default/plygeometryloader.cpp
+++ b/src/plugins/geometryloaders/default/plygeometryloader.cpp
@@ -406,21 +406,21 @@ bool PlyGeometryLoader::parseMesh(QIODevice *ioDev)
             }
 
             if (element.type == ElementVertex) {
-                m_points.append(point);
+                m_points.push_back(point);
 
                 if (m_hasNormals)
-                    m_normals.append(normal);
+                    m_normals.push_back(normal);
 
                 if (m_hasTexCoords)
-                    m_texCoords.append(texCoord);
+                    m_texCoords.push_back(texCoord);
             } else if (element.type == ElementFace) {
                 if (faceIndices.size() >= 3) {
                     // decompose face into triangle fan
 
                     for (int j = 1; j < faceIndices.size() - 1; ++j) {
-                        m_indices.append(faceIndices[0]);
-                        m_indices.append(faceIndices[j]);
-                        m_indices.append(faceIndices[j + 1]);
+                        m_indices.push_back(faceIndices[0]);
+                        m_indices.push_back(faceIndices[j]);
+                        m_indices.push_back(faceIndices[j + 1]);
                     }
                 }
             }
diff --git a/src/plugins/geometryloaders/default/stlgeometryloader.cpp b/src/plugins/geometryloaders/default/stlgeometryloader.cpp
index 0f973a7e3..a8083eb32 100644
--- a/src/plugins/geometryloaders/default/stlgeometryloader.cpp
+++ b/src/plugins/geometryloaders/default/stlgeometryloader.cpp
@@ -89,8 +89,8 @@ bool StlGeometryLoader::loadAscii(QIODevice *ioDev)
                 const float x = tokens.floatAt(1);
                 const float y = tokens.floatAt(2);
                 const float z = tokens.floatAt(3);
-                m_points.append(QVector3D(x, y, z));
-                m_indices.append(m_indices.size());
+                m_points.push_back(QVector3D(x, y, z));
+                m_indices.push_back(m_indices.size());
             }
         }
     }
@@ -127,9 +127,8 @@ bool StlGeometryLoader::loadBinary(QIODevice *ioDev)
         for (int j = 0; j < 3; ++j) {
             QVector3D point;
             stream >> point;
-            m_points.append(point);
-
-            m_indices.append((i * 3) + j);
+            m_points.push_back(point);
+            m_indices.push_back((i * 3) + j);
         }
 
         quint16 attributeCount;
diff --git a/src/render/io/qaxisalignedboundingbox.cpp b/src/render/io/qaxisalignedboundingbox.cpp
index 1d4ca8b63..0dff15674 100644
--- a/src/render/io/qaxisalignedboundingbox.cpp
+++ b/src/render/io/qaxisalignedboundingbox.cpp
@@ -46,9 +46,9 @@ QT_BEGIN_NAMESPACE
 
 namespace Qt3DRender {
 
-void QAxisAlignedBoundingBox::update(const QList<QVector3D> &points)
+void QAxisAlignedBoundingBox::update(const std::vector<QVector3D> &points)
 {
-    if (points.isEmpty()) {
+    if (points.empty()) {
         m_center = QVector3D();
         m_radii = QVector3D();
         return;
@@ -57,8 +57,7 @@ void QAxisAlignedBoundingBox::update(const QList<QVector3D> &points)
     QVector3D minPoint = points.at( 0 );
     QVector3D maxPoint = points.at( 0 );
 
-    for (int i = 1; i < points.size(); ++i)
-    {
+    for (size_t i = 1; i < points.size(); ++i) {
         const QVector3D &point = points.at(i);
         if (point.x() > maxPoint.x())
             maxPoint.setX(point.x());
diff --git a/src/render/io/qaxisalignedboundingbox_p.h b/src/render/io/qaxisalignedboundingbox_p.h
index 6ed3d9fd4..7b01243cd 100644
--- a/src/render/io/qaxisalignedboundingbox_p.h
+++ b/src/render/io/qaxisalignedboundingbox_p.h
@@ -51,7 +51,7 @@
 // We mean it.
 //
 
-#include <QList>
+#include <vector>
 #include <QMatrix4x4>
 #include <QVector3D>
 
@@ -67,13 +67,13 @@ class QAxisAlignedBoundingBox
 {
 public:
     inline QAxisAlignedBoundingBox()
-        : m_center(),
-          m_radii()
+        : m_center()
+        , m_radii()
     {}
 
-    inline explicit QAxisAlignedBoundingBox(const QList<QVector3D> &points)
-        : m_center(),
-          m_radii()
+    inline explicit QAxisAlignedBoundingBox(const std::vector<QVector3D> &points)
+        : m_center()
+        , m_radii()
     {
         update(points);
     }
@@ -86,7 +86,7 @@ public:
 
     bool isNull() const { return m_center.isNull() && m_radii.isNull(); }
 
-    void Q_3DRENDERSHARED_PRIVATE_EXPORT update(const QList<QVector3D> &points);
+    void Q_3DRENDERSHARED_PRIVATE_EXPORT update(const std::vector<QVector3D> &points);
 
     inline QVector3D center() const { return m_center; }
     inline QVector3D radii() const { return m_radii; }
@@ -115,12 +115,12 @@ public:
 
     inline void expandToContain(const QVector3D &pt)
     {
-        update(QList<QVector3D> { pt });
+        update(std::vector<QVector3D> { pt });
     }
 
     inline void expandToContain(const QAxisAlignedBoundingBox &other)
     {
-        update(QList<QVector3D> { other.minPoint(), other.maxPoint() });
+        update(std::vector<QVector3D> { other.minPoint(), other.maxPoint() });
     }
 
     inline QAxisAlignedBoundingBox transformBy(const QMatrix4x4 &mat) const