Optimized Mesh rendering

include/system/Shader.h

                        gl::GLenum mode = gl::GL_TRIANGLES, ShaderTexture* target = nullptr,
                        Shader& shader = textureShader);
 
+    static void drawGLBuffer(std::vector<glm::vec3>& vertices, std::vector<glm::vec2>& uvs,
+                             Shader& shader = textureShader);
+    static void drawGLOnly(std::vector<unsigned short>& indices, glm::mat4 MVP,
+                           unsigned int texture, TextureStorage store,
+                           gl::GLenum mode = gl::GL_TRIANGLES, ShaderTexture* target = nullptr,
+                           Shader& shader = textureShader);
+
     static void drawGL(std::vector<glm::vec3>& vertices, std::vector<glm::vec3>& colors,
                        glm::mat4 MVP, gl::GLenum mode = gl::GL_TRIANGLES,
                        ShaderTexture* target = nullptr, Shader& shader = colorShader);

src/Mesh.cpp

 
 void Mesh::display(glm::mat4 MVP, ShaderTexture* shaderTexture) {
     if (indicesBuff.size() > 0) {
-        unsigned int indexStart = 0;
-        unsigned int indexPos = 1;
-        unsigned int texture = texturesBuff.at(indicesBuff.at(0));
-
-        while ((indexStart != indexPos) && (indexPos < indicesBuff.size())) {
-            while ((indexPos < indicesBuff.size())
-                   && (texturesBuff.at(indicesBuff.at(indexPos)) == texture)) {
-                indexPos++;
+        Shader::drawGLBuffer(verticesBuff, uvsBuff);
+
+        for (int i = 0; i < TextureManager::numTextures(TextureStorage::GAME); i++) {
+            std::vector<unsigned short> indices;
+            for (int n = 0; n < indicesBuff.size(); n++) {
+                if (texturesBuff.at(indicesBuff.at(n)) == i) {
+                    indices.push_back(indicesBuff.at(n));
+                }
             }
 
-            std::vector<unsigned short> indices(indicesBuff.begin() + indexStart,
-                                            indicesBuff.begin() + indexPos);
-            Shader::drawGL(verticesBuff, uvsBuff, indices, MVP, texture,
-                           TextureStorage::GAME, gl::GL_TRIANGLES, shaderTexture);
-
-            if (indexPos < indicesBuff.size()) {
-                indexStart = indexPos;
-                indexPos += 1;
-                texture = texturesBuff.at(indicesBuff.at(indexStart));
-            }
+            Shader::drawGLOnly(indices, MVP, i, TextureStorage::GAME,
+                               gl::GL_TRIANGLES, shaderTexture);
         }
     }
 

src/RoomMesh.cpp

 
 void RoomMesh::display(glm::mat4 MVP) {
     if (indicesBuff.size() > 0) {
-        unsigned int indexStart = 0;
-        unsigned int indexPos = 1;
-        unsigned int texture = texturesBuff.at(indicesBuff.at(0));
+        Shader::drawGLBuffer(verticesBuff, uvsBuff);
 
-        while ((indexStart != indexPos) && (indexPos < indicesBuff.size())) {
-            while ((indexPos < indicesBuff.size())
-                   && (texturesBuff.at(indicesBuff.at(indexPos)) == texture)) {
-                indexPos++;
+        for (int i = 0; i < TextureManager::numTextures(TextureStorage::GAME); i++) {
+            std::vector<unsigned short> indices;
+            for (int n = 0; n < indicesBuff.size(); n++) {
+                if (texturesBuff.at(indicesBuff.at(n)) == i) {
+                    indices.push_back(indicesBuff.at(n));
+                }
             }
 
-            std::vector<unsigned short> indices(indicesBuff.begin() + indexStart,
-                                            indicesBuff.begin() + indexPos);
-            Shader::drawGL(verticesBuff, uvsBuff, indices, MVP, texture, TextureStorage::GAME);
-
-            if (indexPos < indicesBuff.size()) {
-                indexStart = indexPos;
-                indexPos += 1;
-                texture = texturesBuff.at(indicesBuff.at(indexStart));
-            }
+            Shader::drawGLOnly(indices, MVP, i, TextureStorage::GAME);
         }
     }
 }

src/system/Shader.cpp

                     std::vector<unsigned short>& indices, glm::mat4 MVP,
                     unsigned int texture, TextureStorage store,
                     gl::GLenum mode, ShaderTexture* target, Shader& shader) {
+    drawGLBuffer(vertices, uvs);
+    drawGLOnly(indices, MVP, texture, store, mode, target, shader);
+}
+
+void Shader::drawGLBuffer(std::vector<glm::vec3>& vertices, std::vector<glm::vec2>& uvs, Shader& shader) {
     orAssert(vertices.size() == uvs.size());
+
+    shader.vertexBuffer.bufferData(vertices);
+    shader.otherBuffer.bufferData(uvs);
+}
+
+void Shader::drawGLOnly(std::vector<unsigned short>& indices, glm::mat4 MVP,
+                        unsigned int texture, TextureStorage store,
+                        gl::GLenum mode, ShaderTexture* target, Shader& shader) {
     if (mode == gl::GL_TRIANGLES)
         orAssert((indices.size() % 3) == 0);
     bindProperBuffer(target);
     shader.loadUniform(0, MVP);
     shader.loadUniform(1, texture, store);
 
-    shader.vertexBuffer.bufferData(vertices);
-    shader.otherBuffer.bufferData(uvs);
     shader.indexBuffer.bufferData(indices);
 
     shader.vertexBuffer.bindBuffer(0, 3);