ShaderParameterPack: use std::vector

Leads to a massive gain on bigscene-cpp (increase of 10 fps,
frame preparation time reduced by 2ms)

Change-Id: Ie2d1f0816fef8c28f316bb9cc8c7daf417c7f8fd
Reviewed-by: Mike Krus <mike.krus@kdab.com>
(cherry picked from commit 735fe47dab436727dc5ab6d66ba7feb7a868f4c3)

5 files changed, 59 insertions, 46 deletions

diff --git a/src/plugins/renderers/opengl/graphicshelpers/submissioncontext.cpp b/src/plugins/renderers/opengl/graphicshelpers/submissioncontext.cpp
index 86f0af505..abfb7922a 100644
--- a/src/plugins/renderers/opengl/graphicshelpers/submissioncontext.cpp
+++ b/src/plugins/renderers/opengl/graphicshelpers/submissioncontext.cpp
@@ -1238,7 +1238,7 @@ bool SubmissionContext::setParameters(ShaderParameterPack &parameterPack, GLShad
     // for SSBO and UBO
 
     // Bind Shader Storage block to SSBO and update SSBO
-    const QVector<BlockToSSBO> blockToSSBOs = parameterPack.shaderStorageBuffers();
+    const std::vector<BlockToSSBO> &blockToSSBOs = parameterPack.shaderStorageBuffers();
     for (const BlockToSSBO b : blockToSSBOs) {
         Buffer *cpuBuffer = m_renderer->nodeManagers()->bufferManager()->lookupResource(b.m_bufferID);
         GLBuffer *ssbo = glBufferForRenderBuffer(cpuBuffer);
@@ -1256,7 +1256,7 @@ bool SubmissionContext::setParameters(ShaderParameterPack &parameterPack, GLShad
 
     // Bind UniformBlocks to UBO and update UBO from Buffer
     // TO DO: Convert ShaderData to Buffer so that we can use that generic process
-    const QVector<BlockToUBO> blockToUBOs = parameterPack.uniformBuffers();
+    const std::vector<BlockToUBO> &blockToUBOs = parameterPack.uniformBuffers();
     int uboIndex = 0;
     for (const BlockToUBO &b : blockToUBOs) {
         Buffer *cpuBuffer = m_renderer->nodeManagers()->bufferManager()->lookupResource(b.m_bufferID);
diff --git a/src/plugins/renderers/opengl/renderer/commandexecuter.cpp b/src/plugins/renderers/opengl/renderer/commandexecuter.cpp
index 70fdbb943..cb21aeab8 100644
--- a/src/plugins/renderers/opengl/renderer/commandexecuter.cpp
+++ b/src/plugins/renderers/opengl/renderer/commandexecuter.cpp
@@ -261,7 +261,7 @@ QJsonObject parameterPackToJson(const Render::OpenGL::ShaderParameterPack &pack)
     obj.insert(QLatin1String("uniforms"), uniformsArray);
 
     QJsonArray texturesArray;
-    const QVector<Render::OpenGL::ShaderParameterPack::NamedResource> &textures = pack.textures();
+    const std::vector<Render::OpenGL::ShaderParameterPack::NamedResource> &textures = pack.textures();
     for (const auto & texture : textures) {
         QJsonObject textureObj;
         textureObj.insert(QLatin1String("name"), Render::StringToInt::lookupString(texture.glslNameId));
@@ -270,7 +270,7 @@ QJsonObject parameterPackToJson(const Render::OpenGL::ShaderParameterPack &pack)
     }
     obj.insert(QLatin1String("textures"), texturesArray);
 
-    const QVector<Render::OpenGL::BlockToUBO> &ubos = pack.uniformBuffers();
+    const std::vector<Render::OpenGL::BlockToUBO> &ubos = pack.uniformBuffers();
     QJsonArray ubosArray;
     for (const auto &ubo : ubos) {
         QJsonObject uboObj;
@@ -281,7 +281,7 @@ QJsonObject parameterPackToJson(const Render::OpenGL::ShaderParameterPack &pack)
     }
     obj.insert(QLatin1String("ubos"), ubosArray);
 
-    const QVector<Render::OpenGL::BlockToSSBO> &ssbos = pack.shaderStorageBuffers();
+    const std::vector<Render::OpenGL::BlockToSSBO> &ssbos = pack.shaderStorageBuffers();
     QJsonArray ssbosArray;
     for (const auto &ssbo : ssbos) {
         QJsonObject ssboObj;
diff --git a/src/plugins/renderers/opengl/renderer/renderview.cpp b/src/plugins/renderers/opengl/renderer/renderview.cpp
index 9e4bd9f46..429984ef5 100644
--- a/src/plugins/renderers/opengl/renderer/renderview.cpp
+++ b/src/plugins/renderers/opengl/renderer/renderview.cpp
@@ -288,17 +288,19 @@ struct AdjacentSubRangeFinder<QSortPolicy::Texture>
     static bool adjacentSubRange(const RenderCommand &a, const RenderCommand &b)
     {
         // Two renderCommands are adjacent if one contains all the other command's textures
-        QVector<ShaderParameterPack::NamedResource> texturesA = a.m_parameterPack.textures();
-        QVector<ShaderParameterPack::NamedResource> texturesB = b.m_parameterPack.textures();
+        const std::vector<ShaderParameterPack::NamedResource> &texturesA = a.m_parameterPack.textures();
+        const std::vector<ShaderParameterPack::NamedResource> &texturesB = b.m_parameterPack.textures();
 
-        if (texturesB.size() > texturesA.size())
-            qSwap(texturesA, texturesB);
+        const bool bBigger = texturesB.size() > texturesA.size();
+        const std::vector<ShaderParameterPack::NamedResource> &smallestVector = bBigger ? texturesA : texturesB;
+        const std::vector<ShaderParameterPack::NamedResource> &biggestVector = bBigger ? texturesB : texturesA;
 
-        // textureB.size() is always <= textureA.size()
-        for (const ShaderParameterPack::NamedResource &texB : qAsConst(texturesB)) {
-            if (!texturesA.contains(texB))
+        const auto e = biggestVector.cend();
+        for (const ShaderParameterPack::NamedResource &tex : smallestVector) {
+            if (std::find(biggestVector.begin(), e, tex) == e)
                 return false;
         }
+
         return true;
     }
 };
@@ -411,22 +413,21 @@ struct SubRangeSorter<QSortPolicy::Texture>
                          [&commands] (const int &iA, const int &iB) {
             const RenderCommand &a = commands[iA];
             const RenderCommand &b = commands[iB];
-            QVector<ShaderParameterPack::NamedResource> texturesA = a.m_parameterPack.textures();
-            QVector<ShaderParameterPack::NamedResource> texturesB = b.m_parameterPack.textures();
-
-            const int originalTextureASize = texturesA.size();
+            const std::vector<ShaderParameterPack::NamedResource> &texturesA = a.m_parameterPack.textures();
+            const std::vector<ShaderParameterPack::NamedResource> &texturesB = b.m_parameterPack.textures();
 
-            if (texturesB.size() > texturesA.size())
-                qSwap(texturesA, texturesB);
+            const bool bBigger = texturesB.size() > texturesA.size();
+            const std::vector<ShaderParameterPack::NamedResource> &smallestVector = bBigger ? texturesA : texturesB;
+            const std::vector<ShaderParameterPack::NamedResource> &biggestVector = bBigger ? texturesB : texturesA;
 
             int identicalTextureCount = 0;
-
-            for (const ShaderParameterPack::NamedResource &texB : qAsConst(texturesB)) {
-                if (texturesA.contains(texB))
+            const auto e = biggestVector.cend();
+            for (const ShaderParameterPack::NamedResource &tex : smallestVector) {
+                if (std::find(biggestVector.begin(), e, tex) != e)
                     ++identicalTextureCount;
             }
 
-            return identicalTextureCount < originalTextureASize;
+            return identicalTextureCount < smallestVector.size();
         });
 #endif
     }
diff --git a/src/plugins/renderers/opengl/renderer/shaderparameterpack.cpp b/src/plugins/renderers/opengl/renderer/shaderparameterpack.cpp
index 467ac34c5..43b0b90c1 100644
--- a/src/plugins/renderers/opengl/renderer/shaderparameterpack.cpp
+++ b/src/plugins/renderers/opengl/renderer/shaderparameterpack.cpp
@@ -81,7 +81,7 @@ void ShaderParameterPack::setTexture(const int glslNameId, int uniformArrayIndex
         return;
     }
 
-    m_textures.append(NamedResource(glslNameId, texId, uniformArrayIndex, NamedResource::Texture));
+    m_textures.push_back(NamedResource(glslNameId, texId, uniformArrayIndex, NamedResource::Texture));
 }
 
 void ShaderParameterPack::setImage(const int glslNameId, int uniformArrayIndex, Qt3DCore::QNodeId id)
@@ -94,13 +94,13 @@ void ShaderParameterPack::setImage(const int glslNameId, int uniformArrayIndex,
         return;
     }
 
-    m_images.append(NamedResource(glslNameId, id, uniformArrayIndex, NamedResource::Image));
+    m_images.push_back(NamedResource(glslNameId, id, uniformArrayIndex, NamedResource::Image));
 }
 
 // Contains Uniform Block Index and QNodeId of the ShaderData (UBO)
 void ShaderParameterPack::setUniformBuffer(BlockToUBO blockToUBO)
 {
-    m_uniformBuffers.append(std::move(blockToUBO));
+    m_uniformBuffers.push_back(std::move(blockToUBO));
 }
 
 void ShaderParameterPack::setShaderStorageBuffer(BlockToSSBO blockToSSBO)
diff --git a/src/plugins/renderers/opengl/renderer/shaderparameterpack_p.h b/src/plugins/renderers/opengl/renderer/shaderparameterpack_p.h
index 78cb8515f..5596c2937 100644
--- a/src/plugins/renderers/opengl/renderer/shaderparameterpack_p.h
+++ b/src/plugins/renderers/opengl/renderer/shaderparameterpack_p.h
@@ -92,8 +92,8 @@ QT3D_DECLARE_TYPEINFO_3(Qt3DRender, Render, OpenGL, BlockToSSBO, Q_PRIMITIVE_TYP
 
 struct PackUniformHash
 {
-    QVector<int> keys;
-    QVector<UniformValue> values;
+    std::vector<int> keys;
+    std::vector<UniformValue> values;
 
     PackUniformHash()
     {
@@ -105,9 +105,19 @@ struct PackUniformHash
         values.reserve(count);
     }
 
+    inline int indexForKey(int key) const
+    {
+        const auto b = keys.cbegin();
+        const auto e = keys.cend();
+        const auto it = std::find(b, e, key);
+        if (it == e)
+            return -1;
+        return std::distance(b, it);
+    }
+
     void insert(int key, const UniformValue &value)
     {
-        const int idx = keys.indexOf(key);
+        const int idx = indexForKey(key);
         if (idx != -1) {
             values[idx] = value;
         } else {
@@ -118,7 +128,7 @@ struct PackUniformHash
 
     void insert(int key, UniformValue &&value)
     {
-        const int idx = keys.indexOf(key);
+        const int idx = indexForKey(key);
         if (idx != -1) {
             values[idx] = std::move(value);
         } else {
@@ -127,9 +137,9 @@ struct PackUniformHash
         }
     }
 
-    UniformValue value(int key) const
+    UniformValue value(int key) const noexcept
     {
-        const int idx = keys.indexOf(key);
+        const int idx = indexForKey(key);
         if (idx != -1)
             return values.at(idx);
         return UniformValue();
@@ -137,7 +147,7 @@ struct PackUniformHash
 
     UniformValue& value(int key)
     {
-        const int idx = keys.indexOf(key);
+        const int idx = indexForKey(key);
         if (idx != -1)
             return values[idx];
         insert(key, UniformValue());
@@ -147,20 +157,22 @@ struct PackUniformHash
     template<typename F>
     void apply(int key, F func) const noexcept
     {
-        const int idx = keys.indexOf(key);
+        const int idx = indexForKey(key);
         if (idx != -1)
             func(values[idx]);
     }
 
     void erase(int idx)
     {
-        keys.removeAt(idx);
-        values.removeAt(idx);
+        keys.erase(keys.begin() + idx);
+        values.erase(values.begin() + idx);
     }
 
     bool contains(int key) const noexcept
     {
-        return keys.contains(key);
+        const auto b = keys.cbegin();
+        const auto e = keys.cend();
+        return std::find(b, e, key) != e;
     }
 };
 
@@ -218,19 +230,19 @@ public:
         }
     };
 
-    inline QVector<NamedResource> textures() const { return m_textures; }
-    inline QVector<NamedResource> images() const { return m_images; }
-    inline QVector<BlockToUBO> uniformBuffers() const { return m_uniformBuffers; }
-    inline QVector<BlockToSSBO> shaderStorageBuffers() const { return m_shaderStorageBuffers; }
-    inline QVector<int> submissionUniformIndices() const { return m_submissionUniformIndices; }
+    inline const std::vector<NamedResource> &textures() const { return m_textures; }
+    inline const std::vector<NamedResource> &images() const { return m_images; }
+    inline const std::vector<BlockToUBO> &uniformBuffers() const { return m_uniformBuffers; }
+    inline const std::vector<BlockToSSBO> &shaderStorageBuffers() const { return m_shaderStorageBuffers; }
+    inline const std::vector<int> &submissionUniformIndices() const { return m_submissionUniformIndices; }
 private:
     PackUniformHash m_uniforms;
 
-    QVector<NamedResource> m_textures;
-    QVector<NamedResource> m_images;
-    QVector<BlockToUBO> m_uniformBuffers;
-    QVector<BlockToSSBO> m_shaderStorageBuffers;
-    QVector<int> m_submissionUniformIndices;
+    std::vector<NamedResource> m_textures;
+    std::vector<NamedResource> m_images;
+    std::vector<BlockToUBO> m_uniformBuffers;
+    std::vector<BlockToSSBO> m_shaderStorageBuffers;
+    std::vector<int> m_submissionUniformIndices;
 
     friend class RenderView;
 };