Now always copying GL data

include/Mesh.h

   private:
     std::vector<unsigned short> indicesBuff;
     std::vector<glm::vec3> verticesBuff;
+    std::vector<glm::vec2> uvsBuff;
     std::vector<unsigned int> texturesBuff;
 
     std::vector<unsigned short> indicesColorBuff;
     std::vector<glm::vec3> verticesColorBuff;
-    std::vector<unsigned int> colorsBuff;
-
-    ShaderBuffer indices, vertices, uvs;
-    ShaderBuffer indicesColor, verticesColor, colors;
+    std::vector<glm::vec3> colorsBuff;
+    std::vector<unsigned int> colorsIndexBuff;
 };
 
 #endif

include/Render.h

 
     static void screenShot(const char* filenameBase);
 
-    static void drawTexture(float x, float y, float w, float h, glm::vec4 color,
-                            unsigned int texture, TextureStorage s);
-
     static RenderMode getMode() { return mode; }
     static void setMode(RenderMode m) { mode = m; }
 

include/RoomMesh.h

 #include <vector>
 
 #include "Mesh.h"
-#include "system/Shader.h"
 
 struct RoomVertexTR2 {
     int x, y, z; // Vertex coordinates, relative to x/zOffset
   private:
     std::vector<unsigned short> indicesBuff;
     std::vector<glm::vec3> verticesBuff;
+    std::vector<glm::vec2> uvsBuff;
     std::vector<unsigned int> texturesBuff;
-    ShaderBuffer indices, vertices, uvs;
 };
 
 #endif

include/Sprite.h

 #ifndef _SPRITE_H_
 #define _SPRITE_H_
 
-#include "system/Shader.h"
+#include <vector>
 
 class Sprite {
   public:
 
   private:
     int texture;
-    ShaderBuffer vertices, uvs;
+    std::vector<glm::vec3> vertexBuff;
+    std::vector<glm::vec2> uvBuff;
     glm::vec4 uv2D;
 };
 

include/system/Shader.h

 
     static void set2DState(bool on, bool depth = true);
 
-    static void drawGL(ShaderBuffer& vertices, ShaderBuffer& uvs, glm::vec4 color, unsigned int texture,
-                       TextureStorage store = TextureStorage::SYSTEM, gl::GLenum mode = gl::GL_TRIANGLES,
-                       ShaderTexture* target = nullptr, Shader& shader = textShader);
-
-    static void drawGL(ShaderBuffer& vertices, ShaderBuffer& uvs, unsigned int texture, glm::mat4 MVP,
-                       TextureStorage store = TextureStorage::GAME, ShaderTexture* target = nullptr,
+    static void drawGL(std::vector<glm::vec3>& vertices, std::vector<glm::vec2>& uvs,
+                       glm::mat4 MVP, unsigned int texture, TextureStorage store,
+                       gl::GLenum mode = gl::GL_TRIANGLES, ShaderTexture* target = nullptr,
                        Shader& shader = textureShader);
-    static void drawGL(ShaderBuffer& vertices, ShaderBuffer& uvs, ShaderBuffer& indices,
-                       unsigned int texture, glm::mat4 MVP,
-                       TextureStorage store = TextureStorage::GAME, ShaderTexture* target = nullptr,
+    static void drawGL(std::vector<glm::vec3>& vertices, std::vector<glm::vec2>& uvs,
+                       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(ShaderBuffer& vertices, ShaderBuffer& colors, glm::mat4 MVP,
+    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);
+    static void drawGL(std::vector<glm::vec3>& vertices, std::vector<glm::vec3>& colors,
+                       std::vector<unsigned short>& indices, glm::mat4 MVP,
                        gl::GLenum mode = gl::GL_TRIANGLES, ShaderTexture* target = nullptr,
                        Shader& shader = colorShader);
-    static void drawGL(ShaderBuffer& vertices, ShaderBuffer& colors, ShaderBuffer& indices,
-                       glm::mat4 MVP, gl::GLenum mode = gl::GL_TRIANGLES, ShaderTexture* target = nullptr,
-                       Shader& shader = colorShader);
 
     static std::string getVersion(bool linked);
 
   private:
     int programID;
     std::vector<unsigned int> uniforms;
+    ShaderBuffer vertexBuffer, otherBuffer, indexBuffer;
 
-    static Shader textShader;
-    static const char* textShaderVertex;
-    static const char* textShaderFragment;
+    static void bindProperBuffer(ShaderTexture* target);
 
     static Shader textureShader;
     static const char* textureShaderVertex;
     static const char* colorShaderFragment;
 
     static unsigned int vertexArrayID;
+    static bool lastBufferWasNotFramebuffer;
 };
 
 #endif

src/Camera.cpp

 };
 static glm::vec3 frustumVertices[8];
 
-static ShaderBuffer vertexBuffer;
-static ShaderBuffer colorBuffer;
-static ShaderBuffer indexBuffer;
-static ShaderBuffer vertexPointBuffer;
-static ShaderBuffer colorPointBuffer;
+static std::vector<glm::vec3> vertexBuffer;
+static std::vector<glm::vec3> colorBuffer;
+static std::vector<unsigned short> indexBuffer;
+static std::vector<glm::vec3> vertexPointBuffer;
+static std::vector<glm::vec3> colorPointBuffer;
 
 void Camera::calculateFrustumPlanes() {
     glm::mat4 combo = projection * view;
     planes[NEAR].set(frustumVertices[NTL], frustumVertices[NTR], frustumVertices[NBR]);
     planes[FAR].set(frustumVertices[FTR], frustumVertices[FTL], frustumVertices[FBL]);
 
-    std::vector<glm::vec3> verts;
-
     // Near
-    verts.push_back(frustumVertices[NTL]);
-    verts.push_back(frustumVertices[NTR]);
-    verts.push_back(frustumVertices[NBR]);
-    verts.push_back(frustumVertices[NBL]);
+    vertexBuffer.push_back(frustumVertices[NTL]);
+    vertexBuffer.push_back(frustumVertices[NTR]);
+    vertexBuffer.push_back(frustumVertices[NBR]);
+    vertexBuffer.push_back(frustumVertices[NBL]);
 
     // Far
-    verts.push_back(frustumVertices[FTR]);
-    verts.push_back(frustumVertices[FTL]);
-    verts.push_back(frustumVertices[FBL]);
-    verts.push_back(frustumVertices[FBR]);
+    vertexBuffer.push_back(frustumVertices[FTR]);
+    vertexBuffer.push_back(frustumVertices[FTL]);
+    vertexBuffer.push_back(frustumVertices[FBL]);
+    vertexBuffer.push_back(frustumVertices[FBR]);
 
     // Top
-    verts.push_back(frustumVertices[NTR]);
-    verts.push_back(frustumVertices[NTL]);
-    verts.push_back(frustumVertices[FTL]);
-    verts.push_back(frustumVertices[FTR]);
+    vertexBuffer.push_back(frustumVertices[NTR]);
+    vertexBuffer.push_back(frustumVertices[NTL]);
+    vertexBuffer.push_back(frustumVertices[FTL]);
+    vertexBuffer.push_back(frustumVertices[FTR]);
 
     // Bottom
-    verts.push_back(frustumVertices[NBL]);
-    verts.push_back(frustumVertices[NBR]);
-    verts.push_back(frustumVertices[FBR]);
-    verts.push_back(frustumVertices[FBL]);
+    vertexBuffer.push_back(frustumVertices[NBL]);
+    vertexBuffer.push_back(frustumVertices[NBR]);
+    vertexBuffer.push_back(frustumVertices[FBR]);
+    vertexBuffer.push_back(frustumVertices[FBL]);
 
     // Left
-    verts.push_back(frustumVertices[NTL]);
-    verts.push_back(frustumVertices[NBL]);
-    verts.push_back(frustumVertices[FBL]);
-    verts.push_back(frustumVertices[FTL]);
+    vertexBuffer.push_back(frustumVertices[NTL]);
+    vertexBuffer.push_back(frustumVertices[NBL]);
+    vertexBuffer.push_back(frustumVertices[FBL]);
+    vertexBuffer.push_back(frustumVertices[FTL]);
 
     // Right
-    verts.push_back(frustumVertices[NBR]);
-    verts.push_back(frustumVertices[NTR]);
-    verts.push_back(frustumVertices[FTR]);
-    verts.push_back(frustumVertices[FBR]);
-
-    vertexBuffer.bufferData(verts);
-
-    verts.clear();
-    std::vector<glm::vec3> cols;
-
-    verts.push_back(getPosition());
-    cols.push_back(glm::vec3(1.0f, 1.0f, 1.0f));
+    vertexBuffer.push_back(frustumVertices[NBR]);
+    vertexBuffer.push_back(frustumVertices[NTR]);
+    vertexBuffer.push_back(frustumVertices[FTR]);
+    vertexBuffer.push_back(frustumVertices[FBR]);
 
-    vertexPointBuffer.bufferData(verts);
-    colorPointBuffer.bufferData(cols);
+    // Position indicator
+    vertexPointBuffer.push_back(getPosition());
+    colorPointBuffer.push_back(glm::vec3(1.0f, 1.0f, 1.0f));
 
-    if (colorBuffer.getSize() == 0) {
-        cols.clear();
+    // Lazy initialization of frustum plane color buffer
+    if (colorBuffer.size() == 0) {
         for (int i = 0; i < 6; i++) {
             for (int j = 0; j < 4; j++) {
-                cols.push_back(frustumColors[i]);
+                colorBuffer.push_back(frustumColors[i]);
             }
         }
-        colorBuffer.bufferData(cols);
     }
 
-    if (indexBuffer.getSize() == 0) {
-        std::vector<unsigned short> inds;
+    if (indexBuffer.size() == 0) {
         for (int i = 0; i < 6; i++) {
-            inds.push_back(4 * i);
-            inds.push_back((4 * i) + 1);
-            inds.push_back((4 * i) + 2);
-            inds.push_back((4 * i) + 3);
-            inds.push_back((4 * i) + 2);
-            inds.push_back(4 * i);
+            indexBuffer.push_back(4 * i);
+            indexBuffer.push_back((4 * i) + 1);
+            indexBuffer.push_back((4 * i) + 2);
+            indexBuffer.push_back((4 * i) + 3);
+            indexBuffer.push_back((4 * i) + 2);
+            indexBuffer.push_back(4 * i);
         }
-        indexBuffer.bufferData(inds);
     }
 }
 

src/Mesh.cpp

            const std::vector<IndexedColoredRectangle>& coloredTri) {
     for (auto& t : rect) {
         indicesBuff.push_back(0);
-        verticesBuff.push_back(glm::vec3(vert.at(t.v1).x, vert.at(t.v1).y, vert.at(t.v1).z));
-        verticesBuff.push_back(glm::vec3(vert.at(t.v2).x, vert.at(t.v2).y, vert.at(t.v2).z));
-        verticesBuff.push_back(glm::vec3(vert.at(t.v3).x, vert.at(t.v3).y, vert.at(t.v3).z));
-        verticesBuff.push_back(glm::vec3(vert.at(t.v4).x, vert.at(t.v4).y, vert.at(t.v4).z));
+        verticesBuff.emplace_back(vert.at(t.v1).x, vert.at(t.v1).y, vert.at(t.v1).z);
+        verticesBuff.emplace_back(vert.at(t.v2).x, vert.at(t.v2).y, vert.at(t.v2).z);
+        verticesBuff.emplace_back(vert.at(t.v3).x, vert.at(t.v3).y, vert.at(t.v3).z);
+        verticesBuff.emplace_back(vert.at(t.v4).x, vert.at(t.v4).y, vert.at(t.v4).z);
         texturesBuff.push_back(t.texture);
     }
 
     for (auto& t : tri) {
         indicesBuff.push_back(1);
-        verticesBuff.push_back(glm::vec3(vert.at(t.v1).x, vert.at(t.v1).y, vert.at(t.v1).z));
-        verticesBuff.push_back(glm::vec3(vert.at(t.v2).x, vert.at(t.v2).y, vert.at(t.v2).z));
-        verticesBuff.push_back(glm::vec3(vert.at(t.v3).x, vert.at(t.v3).y, vert.at(t.v3).z));
+        verticesBuff.emplace_back(vert.at(t.v1).x, vert.at(t.v1).y, vert.at(t.v1).z);
+        verticesBuff.emplace_back(vert.at(t.v2).x, vert.at(t.v2).y, vert.at(t.v2).z);
+        verticesBuff.emplace_back(vert.at(t.v3).x, vert.at(t.v3).y, vert.at(t.v3).z);
         texturesBuff.push_back(t.texture);
     }
 
     for (auto& t : coloredRect) {
         indicesColorBuff.push_back(0);
-        verticesColorBuff.push_back(glm::vec3(vert.at(t.v1).x, vert.at(t.v1).y, vert.at(t.v1).z));
-        verticesColorBuff.push_back(glm::vec3(vert.at(t.v2).x, vert.at(t.v2).y, vert.at(t.v2).z));
-        verticesColorBuff.push_back(glm::vec3(vert.at(t.v3).x, vert.at(t.v3).y, vert.at(t.v3).z));
-        verticesColorBuff.push_back(glm::vec3(vert.at(t.v4).x, vert.at(t.v4).y, vert.at(t.v4).z));
-        colorsBuff.push_back(t.index);
+        verticesColorBuff.emplace_back(vert.at(t.v1).x, vert.at(t.v1).y, vert.at(t.v1).z);
+        verticesColorBuff.emplace_back(vert.at(t.v2).x, vert.at(t.v2).y, vert.at(t.v2).z);
+        verticesColorBuff.emplace_back(vert.at(t.v3).x, vert.at(t.v3).y, vert.at(t.v3).z);
+        verticesColorBuff.emplace_back(vert.at(t.v4).x, vert.at(t.v4).y, vert.at(t.v4).z);
+        colorsIndexBuff.push_back(t.index);
     }
 
     for (auto& t : coloredTri) {
         indicesColorBuff.push_back(1);
-        verticesColorBuff.push_back(glm::vec3(vert.at(t.v1).x, vert.at(t.v1).y, vert.at(t.v1).z));
-        verticesColorBuff.push_back(glm::vec3(vert.at(t.v2).x, vert.at(t.v2).y, vert.at(t.v2).z));
-        verticesColorBuff.push_back(glm::vec3(vert.at(t.v3).x, vert.at(t.v3).y, vert.at(t.v3).z));
-        colorsBuff.push_back(t.index);
+        verticesColorBuff.emplace_back(vert.at(t.v1).x, vert.at(t.v1).y, vert.at(t.v1).z);
+        verticesColorBuff.emplace_back(vert.at(t.v2).x, vert.at(t.v2).y, vert.at(t.v2).z);
+        verticesColorBuff.emplace_back(vert.at(t.v3).x, vert.at(t.v3).y, vert.at(t.v3).z);
+        colorsIndexBuff.push_back(t.index);
     }
 }
 
     orAssertEqual(vert.size(), uvBuff.size());
 
     indicesBuff = std::move(ind);
-    vertices.bufferData(vert);
-    uvs.bufferData(uvBuff);
+    verticesBuff = std::move(vert);
+    uvsBuff = std::move(uvBuff);
     texturesBuff = std::move(tex);
 
     std::vector<unsigned short> indCol;
                 v = 0;
             indCol.push_back(vertCol.size());
             vertCol.push_back(verticesColorBuff.at(vertIndex + v));
-            glm::vec4 c = TextureManager::getPalette(colorsBuff.at(i));
+            glm::vec4 c = TextureManager::getPalette(colorsIndexBuff.at(i));
             cols.push_back(glm::vec3(c.x, c.y, c.z));
         }
 
     orAssertEqual(indCol.size() % 3, 0);
     orAssertEqual(vertCol.size(), cols.size());
 
-    indicesColor.bufferData(indCol);
-    verticesColor.bufferData(vertCol);
-    colors.bufferData(cols);
-
-    verticesBuff.clear();
-    indicesColorBuff.clear();
-    verticesColorBuff.clear();
-    colorsBuff.clear();
+    indicesColorBuff = std::move(indCol);
+    verticesColorBuff = std::move(vertCol);
+    colorsBuff = std::move(cols);
 }
 
 void Mesh::display(glm::mat4 MVP, ShaderTexture* shaderTexture) {
                 indexPos++;
             }
 
-            std::vector<unsigned short> ind(indicesBuff.begin() + indexStart,
+            std::vector<unsigned short> indices(indicesBuff.begin() + indexStart,
                                             indicesBuff.begin() + indexPos);
-            indices.bufferData(ind);
-            Shader::drawGL(vertices, uvs, indices, texture, MVP, TextureStorage::GAME, shaderTexture);
+            Shader::drawGL(verticesBuff, uvsBuff, indices, MVP, texture,
+                           TextureStorage::GAME, gl::GL_TRIANGLES, shaderTexture);
 
             if (indexPos < indicesBuff.size()) {
                 indexStart = indexPos;
         }
     }
 
-    if (indicesColor.getSize() > 0)
-        Shader::drawGL(verticesColor, colors, indicesColor, MVP, gl::GL_TRIANGLES, shaderTexture);
+    if (indicesColorBuff.size() > 0)
+        Shader::drawGL(verticesColorBuff, colorsBuff, indicesColorBuff, MVP, gl::GL_TRIANGLES, shaderTexture);
 }
 

src/Render.cpp

     gl::glClear(gl::GL_COLOR_BUFFER_BIT | gl::GL_DEPTH_BUFFER_BIT);
 
     if (mode == RenderMode::LoadScreen) {
-        glm::vec4 color(1.0f, 1.0f, 1.0f, 1.0f);
-        drawTexture(0.0f, 0.0f, Window::getSize().x, Window::getSize().y,
-                    color, TEXTURE_SPLASH, TextureStorage::SYSTEM);
+        ImGui::SetNextWindowPos(ImVec2(0.0f, 0.0f));
+        ImGui::SetNextWindowSize(ImVec2(Window::getSize().x, Window::getSize().y));
+        ImGui::Begin("SplashWindow", nullptr, ImGuiWindowFlags_NoTitleBar
+                     | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove
+                     | ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoScrollWithMouse
+                     | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoSavedSettings);
+        auto bm = TextureManager::getBufferManager(TEXTURE_SPLASH, TextureStorage::SYSTEM);
+        ImGui::Image(bm, ImVec2(Window::getSize().x, Window::getSize().y));
+        ImGui::End();
         return;
     }
 
     delete [] buffer;
 }
 
-void Render::drawTexture(float x, float y, float w, float h, glm::vec4 color,
-                         unsigned int texture, TextureStorage s) {
-    std::vector<glm::vec2> vertices;
-    std::vector<glm::vec2> uvs;
-
-    vertices.push_back(glm::vec2(x, y + h));
-    vertices.push_back(glm::vec2(x + w, y + h));
-    vertices.push_back(glm::vec2(x, y));
-
-    vertices.push_back(glm::vec2(x + w, y));
-    vertices.push_back(glm::vec2(x, y));
-    vertices.push_back(glm::vec2(x + w, y + h));
-
-    uvs.push_back(glm::vec2(0.0f, 1.0f));
-    uvs.push_back(glm::vec2(1.0f, 1.0f));
-    uvs.push_back(glm::vec2(0.0f, 0.0f));
-
-    uvs.push_back(glm::vec2(1.0f, 0.0f));
-    uvs.push_back(glm::vec2(0.0f, 0.0f));
-    uvs.push_back(glm::vec2(1.0f, 1.0f));
-
-    static ShaderBuffer vert, uv;
-    vert.bufferData(vertices);
-    uv.bufferData(uvs);
-
-    Shader::drawGL(vert, uv, color, texture, s);
-}
-
 static const int modeStringCount = 4;
 static const char* modeStrings[modeStringCount] = {
     "Splash", "Texture", "Wireframe", "Solid"

src/RoomData.cpp

     inds.push_back(5);
     inds.push_back(2);
 
-    static ShaderBuffer vert, col, ind;
-    vert.bufferData(verts);
-    col.bufferData(cols);
-    ind.bufferData(inds);
-    Shader::drawGL(vert, col, ind, VP, gl::GL_LINE_STRIP);
+    Shader::drawGL(verts, cols, inds, VP, gl::GL_LINE_STRIP);
 
     cols.clear();
     inds.clear();
         inds.push_back(i);
     }
 
-    static ShaderBuffer vert2, col2, ind2;
-    vert2.bufferData(verts);
-    col2.bufferData(cols);
-    ind2.bufferData(inds);
-    Shader::drawGL(vert2, col2, ind2, VP, gl::GL_POINTS);
+    Shader::drawGL(verts, cols, inds, VP, gl::GL_POINTS);
 }
 
 // ----------------------------------------------------------------------------

src/RoomMesh.cpp

 
 #include "global.h"
 #include "TextureManager.h"
+#include "system/Shader.h"
 #include "RoomMesh.h"
 
 RoomMesh::RoomMesh(const std::vector<RoomVertexTR2>& vert,
 void RoomMesh::prepare() {
     std::vector<unsigned short> ind;
     std::vector<glm::vec3> vert;
-    std::vector<glm::vec2> uvBuff;
     std::vector<unsigned int> tex;
 
     int vertIndex = 0;
                 v = 0;
             ind.push_back(vert.size());
             vert.push_back(verticesBuff.at(vertIndex + v));
-            uvBuff.push_back(TextureManager::getTile(texturesBuff.at(i)).getUV(v));
+            uvsBuff.push_back(TextureManager::getTile(texturesBuff.at(i)).getUV(v));
             tex.push_back(texture);
         }
 
 
     orAssertEqual(ind.size() % 3, 0);
     orAssertEqual(vert.size(), tex.size());
-    orAssertEqual(vert.size(), uvBuff.size());
+    orAssertEqual(vert.size(), uvsBuff.size());
 
     indicesBuff = std::move(ind);
-    vertices.bufferData(vert);
-    uvs.bufferData(uvBuff);
+    verticesBuff = std::move(vert);
     texturesBuff = std::move(tex);
 }
 
                 indexPos++;
             }
 
-            std::vector<unsigned short> ind(indicesBuff.begin() + indexStart,
+            std::vector<unsigned short> indices(indicesBuff.begin() + indexStart,
                                             indicesBuff.begin() + indexPos);
-            indices.bufferData(ind);
-            Shader::drawGL(vertices, uvs, indices, texture, MVP);
+            Shader::drawGL(verticesBuff, uvsBuff, indices, MVP, texture, TextureStorage::GAME);
 
             if (indexPos < indicesBuff.size()) {
                 indexStart = indexPos;

src/Sprite.cpp

     int width2 = (int)(width * scale);
     int height2 = (int)(height * scale);
 
-    std::vector<glm::vec2> uv;
-    uv.emplace_back(float(x + texelOffset) / texelScale, float(y + height) / texelScale);
-    uv.emplace_back(float(x + texelOffset) / texelScale, float(y + texelOffset) / texelScale);
-    uv.emplace_back(float(x + width) / texelScale, float(y + texelOffset) / texelScale);
-    uv.emplace_back(float(x + width) / texelScale, float(y + height) / texelScale);
-    uv.emplace_back(uv.at(0));
-    uv.emplace_back(uv.at(2));
-
-    std::vector<glm::vec3> vert;
-    vert.emplace_back(float(-width2) / 2.0f, 0.0f, 0.0f);
-    vert.emplace_back(float(-width2) / 2.0f, float(-height2), 0.0f);
-    vert.emplace_back(float(width2) / 2.0f, float(-height2), 0.0f);
-    vert.emplace_back(float(width2) / 2.0f, 0.0f, 0.0f);
-    vert.emplace_back(vert.at(0));
-    vert.emplace_back(vert.at(2));
-
-    vertices.bufferData(vert);
-    uvs.bufferData(uv);
-
-    uv2D = glm::vec4(uv.at(0), uv.at(2));
+    uvBuff.emplace_back(float(x + texelOffset) / texelScale, float(y + height) / texelScale);
+    uvBuff.emplace_back(float(x + texelOffset) / texelScale, float(y + texelOffset) / texelScale);
+    uvBuff.emplace_back(float(x + width) / texelScale, float(y + texelOffset) / texelScale);
+    uvBuff.emplace_back(float(x + width) / texelScale, float(y + height) / texelScale);
+    uvBuff.emplace_back(uvBuff.at(0));
+    uvBuff.emplace_back(uvBuff.at(2));
+
+    vertexBuff.emplace_back(float(-width2) / 2.0f, 0.0f, 0.0f);
+    vertexBuff.emplace_back(float(-width2) / 2.0f, float(-height2), 0.0f);
+    vertexBuff.emplace_back(float(width2) / 2.0f, float(-height2), 0.0f);
+    vertexBuff.emplace_back(float(width2) / 2.0f, 0.0f, 0.0f);
+    vertexBuff.emplace_back(vertexBuff.at(0));
+    vertexBuff.emplace_back(vertexBuff.at(2));
+
+    uv2D = glm::vec4(uvBuff.at(0), uvBuff.at(2));
 }
 
 void Sprite::display(glm::mat4 MVP) {
-    Shader::drawGL(vertices, uvs, texture, MVP);
+    Shader::drawGL(vertexBuff, uvBuff, MVP, texture, TextureStorage::GAME);
 }
 
 // ----------------------------------------------------------------------------

src/system/Shader.cpp

 
     boundSize = elem;
     gl::glBindBuffer(gl::GL_ARRAY_BUFFER, buffer);
-    gl::glBufferData(gl::GL_ARRAY_BUFFER, elem * size, data, gl::GL_STATIC_DRAW);
+    gl::glBufferData(gl::GL_ARRAY_BUFFER, elem * size, data, gl::GL_DYNAMIC_DRAW);
 }
 
 void ShaderBuffer::bindBuffer() {
     }
 }
 
-Shader Shader::textShader;
 Shader Shader::textureShader;
 Shader Shader::colorShader;
 unsigned int Shader::vertexArrayID = 0;
+bool Shader::lastBufferWasNotFramebuffer = true;
 
 int Shader::initialize() {
     gl::glGenVertexArrays(1, &vertexArrayID);
 
     gl::glPointSize(5.0f);
 
-    if (textShader.compile(textShaderVertex, textShaderFragment) < 0)
-        return -1;
-    if (textShader.addUniform("screen") < 0)
-        return -2;
-    if (textShader.addUniform("textureSampler") < 0)
-        return -3;
-    if (textShader.addUniform("colorVar") < 0)
-        return -4;
-
     if (textureShader.compile(textureShaderVertex, textureShaderFragment) < 0)
-        return -5;
+        return -1;
     if (textureShader.addUniform("MVP") < 0)
-        return -6;
+        return -2;
     if (textureShader.addUniform("textureSampler") < 0)
-        return -7;
+        return -3;
 
     if (colorShader.compile(colorShaderVertex, colorShaderFragment) < 0)
-        return -8;
+        return -4;
     if (colorShader.addUniform("MVP") < 0)
-        return -9;
+        return -5;
 
     return 0;
 }
     }
 }
 
-void Shader::drawGL(ShaderBuffer& vertices, ShaderBuffer& uvs, glm::vec4 color,
-                    unsigned int texture, TextureStorage store, gl::GLenum mode,
-                    ShaderTexture* target, Shader& shader) {
-    orAssert(vertices.getSize() == uvs.getSize());
-    if (mode == gl::GL_TRIANGLES) {
-        orAssert((vertices.getSize() % 3) == 0);
-    }
-
-    if (target == nullptr) {
+void Shader::bindProperBuffer(ShaderTexture* target) {
+    if ((target == nullptr) && lastBufferWasNotFramebuffer) {
+        lastBufferWasNotFramebuffer = false;
         gl::glBindFramebuffer(gl::GL_FRAMEBUFFER, 0);
         gl::glViewport(0, 0, Window::getSize().x, Window::getSize().y);
-    } else {
+    } else if (target != nullptr) {
+        lastBufferWasNotFramebuffer = true;
         target->bind();
     }
-
-    shader.use();
-    shader.loadUniform(0, glm::vec2(Window::getSize()));
-    shader.loadUniform(1, texture, store);
-    shader.loadUniform(2, color);
-    vertices.bindBuffer(0, 2);
-    uvs.bindBuffer(1, 2);
-
-    set2DState(true);
-    gl::glDrawArrays(mode, 0, vertices.getSize());
-    set2DState(false);
-
-    vertices.unbind(0);
-    uvs.unbind(1);
 }
 
-void Shader::drawGL(ShaderBuffer& vertices, ShaderBuffer& uvs, unsigned int texture,
-                    glm::mat4 MVP, TextureStorage store, ShaderTexture* target,
-                    Shader& shader) {
-    orAssert(vertices.getSize() == uvs.getSize());
-    orAssert((vertices.getSize() % 3) == 0);
-
-    if (target == nullptr) {
-        gl::glBindFramebuffer(gl::GL_FRAMEBUFFER, 0);
-        gl::glViewport(0, 0, Window::getSize().x, Window::getSize().y);
-    } else {
-        target->bind();
-    }
+void Shader::drawGL(std::vector<glm::vec3>& vertices, std::vector<glm::vec2>& uvs,
+                    glm::mat4 MVP, unsigned int texture, TextureStorage store,
+                    gl::GLenum mode, ShaderTexture* target, Shader& shader) {
+    orAssert(vertices.size() == uvs.size());
+    if (mode == gl::GL_TRIANGLES)
+        orAssert((vertices.size() % 3) == 0);
+    bindProperBuffer(target);
 
     shader.use();
     shader.loadUniform(0, MVP);
     shader.loadUniform(1, texture, store);
-    vertices.bindBuffer(0, 3);
-    uvs.bindBuffer(1, 2);
-    gl::glDrawArrays(gl::GL_TRIANGLES, 0, vertices.getSize());
-    vertices.unbind(0);
-    uvs.unbind(1);
-}
 
-void Shader::drawGL(ShaderBuffer& vertices, ShaderBuffer& uvs, ShaderBuffer& indices,
-                    unsigned int texture, glm::mat4 MVP, TextureStorage store,
-                    ShaderTexture* target, Shader& shader) {
-    orAssert(vertices.getSize() == uvs.getSize());
-    orAssert((indices.getSize() % 3) == 0);
+    shader.vertexBuffer.bufferData(vertices);
+    shader.otherBuffer.bufferData(uvs);
 
-    if (target == nullptr) {
-        gl::glBindFramebuffer(gl::GL_FRAMEBUFFER, 0);
-        gl::glViewport(0, 0, Window::getSize().x, Window::getSize().y);
-    } else {
-        target->bind();
+    shader.vertexBuffer.bindBuffer(0, 3);
+    shader.otherBuffer.bindBuffer(1, 2);
 
-        unsigned int sz = vertices.getSize();
-        glm::vec3* buffer = new glm::vec3[sz];
-        gl::glBindBuffer(gl::GL_ARRAY_BUFFER, vertices.getBuffer());
-        gl::glGetBufferSubData(gl::GL_ARRAY_BUFFER, 0, sz * sizeof(glm::vec3), buffer);
+    gl::glDrawArrays(mode, 0, shader.vertexBuffer.getSize());
 
-        Log::get(LOG_DEBUG) << "drawGL Vertex dump:" << Log::endl;
-        for (unsigned int i = 0; i < sz; i++) {
-            glm::vec4 tmp(buffer[i], 1.0f);
-            tmp = MVP * tmp;
-            glm::vec3 res(tmp.x, tmp.y, tmp.z);
-            Log::get(LOG_DEBUG) << buffer[i] << " -> " << res << Log::endl;
-        }
+    shader.vertexBuffer.unbind(0);
+    shader.otherBuffer.unbind(1);
+}
 
-        delete [] buffer;
-    }
+void Shader::drawGL(std::vector<glm::vec3>& vertices, std::vector<glm::vec2>& uvs,
+                    std::vector<unsigned short>& indices, glm::mat4 MVP,
+                    unsigned int texture, TextureStorage store,
+                    gl::GLenum mode, ShaderTexture* target, Shader& shader) {
+    orAssert(vertices.size() == uvs.size());
+    if (mode == gl::GL_TRIANGLES)
+        orAssert((indices.size() % 3) == 0);
+    bindProperBuffer(target);
 
     shader.use();
     shader.loadUniform(0, MVP);
     shader.loadUniform(1, texture, store);
-    vertices.bindBuffer(0, 3);
-    uvs.bindBuffer(1, 2);
-    indices.bindBuffer();
-    gl::glDrawElements(gl::GL_TRIANGLES, indices.getSize(), gl::GL_UNSIGNED_SHORT, nullptr);
-    vertices.unbind(0);
-    uvs.unbind(1);
-}
 
-void Shader::drawGL(ShaderBuffer& vertices, ShaderBuffer& colors, glm::mat4 MVP,
-                    gl::GLenum mode, ShaderTexture* target, Shader& shader) {
-    orAssert(vertices.getSize() == colors.getSize());
-    if (mode == gl::GL_TRIANGLES) {
-        orAssert((vertices.getSize() % 3) == 0);
-    }
+    shader.vertexBuffer.bufferData(vertices);
+    shader.otherBuffer.bufferData(uvs);
+    shader.indexBuffer.bufferData(indices);
 
-    if (target == nullptr) {
-        gl::glBindFramebuffer(gl::GL_FRAMEBUFFER, 0);
-        gl::glViewport(0, 0, Window::getSize().x, Window::getSize().y);
-    } else {
-        target->bind();
-    }
+    shader.vertexBuffer.bindBuffer(0, 3);
+    shader.otherBuffer.bindBuffer(1, 2);
+    shader.indexBuffer.bindBuffer();
 
-    shader.use();
-    shader.loadUniform(0, MVP);
-    vertices.bindBuffer(0, 3);
-    colors.bindBuffer(1, 3);
-    gl::glDrawArrays(mode, 0, vertices.getSize());
-    vertices.unbind(0);
-    colors.unbind(1);
+    gl::glDrawElements(mode, shader.indexBuffer.getSize(), gl::GL_UNSIGNED_SHORT, nullptr);
+
+    shader.vertexBuffer.unbind(0);
+    shader.otherBuffer.unbind(1);
 }
 
-void Shader::drawGL(ShaderBuffer& vertices, ShaderBuffer& colors, ShaderBuffer& indices,
+void Shader::drawGL(std::vector<glm::vec3>& vertices, std::vector<glm::vec3>& colors,
                     glm::mat4 MVP, gl::GLenum mode, ShaderTexture* target, Shader& shader) {
-    orAssert(vertices.getSize() == colors.getSize());
-    if (mode == gl::GL_TRIANGLES) {
-        orAssert((indices.getSize() % 3) == 0);
-    }
-
-    if (target == nullptr) {
-        gl::glBindFramebuffer(gl::GL_FRAMEBUFFER, 0);
-        gl::glViewport(0, 0, Window::getSize().x, Window::getSize().y);
-    } else {
-        target->bind();
-    }
+    orAssert(vertices.size() == colors.size());
+    if (mode == gl::GL_TRIANGLES)
+        orAssert((vertices.size() % 3) == 0);
+    bindProperBuffer(target);
 
     shader.use();
     shader.loadUniform(0, MVP);
-    vertices.bindBuffer(0, 3);
-    colors.bindBuffer(1, 3);
-    indices.bindBuffer();
-    gl::glDrawElements(mode, indices.getSize(), gl::GL_UNSIGNED_SHORT, nullptr);
-    vertices.unbind(0);
-    colors.unbind(1);
-}
-
-// --------------------------------------
-// *INDENT-OFF*
 
-const char* Shader::textShaderVertex = R"!?!(
-#version 330 core
-
-layout(location = 0) in vec2 vertexPosition_screen;
-layout(location = 1) in vec2 vertexUV;
-
-out vec2 UV;
+    shader.vertexBuffer.bufferData(vertices);
+    shader.otherBuffer.bufferData(colors);
 
-uniform vec2 screen;
+    shader.vertexBuffer.bindBuffer(0, 3);
+    shader.otherBuffer.bindBuffer(1, 3);
 
-void main() {
-    vec2 halfScreen = screen / 2;
-    vec2 vertexPosition_homogenous = (vertexPosition_screen - halfScreen) / halfScreen;
+    gl::glDrawArrays(mode, 0, shader.vertexBuffer.getSize());
 
-    gl_Position = vec4(vertexPosition_homogenous.x, -vertexPosition_homogenous.y, 0, 1);
-    UV = vertexUV;
+    shader.vertexBuffer.unbind(0);
+    shader.otherBuffer.unbind(1);
 }
-)!?!";
 
-const char* Shader::textShaderFragment = R"!?!(
-#version 330 core
+void Shader::drawGL(std::vector<glm::vec3>& vertices, std::vector<glm::vec3>& colors,
+                    std::vector<unsigned short>& indices, glm::mat4 MVP,
+                    gl::GLenum mode, ShaderTexture* target, Shader& shader) {
+    orAssert(vertices.size() == colors.size());
+    if (mode == gl::GL_TRIANGLES)
+        orAssert((indices.size() % 3) == 0);
+    bindProperBuffer(target);
 
-in vec2 UV;
+    shader.use();
+    shader.loadUniform(0, MVP);
 
-layout(location = 0) out vec4 color;
+    shader.vertexBuffer.bufferData(vertices);
+    shader.otherBuffer.bufferData(colors);
+    shader.indexBuffer.bufferData(indices);
 
-uniform sampler2D textureSampler;
-uniform vec4 colorVar;
+    shader.vertexBuffer.bindBuffer(0, 3);
+    shader.otherBuffer.bindBuffer(1, 3);
+    shader.indexBuffer.bindBuffer();
 
-void main() {
-    color = texture(textureSampler, UV) * colorVar;
+    gl::glDrawElements(mode, shader.indexBuffer.getSize(), gl::GL_UNSIGNED_SHORT, nullptr);
+
+    shader.vertexBuffer.unbind(0);
+    shader.otherBuffer.unbind(1);
 }
-)!?!";
 
 // --------------------------------------
+// *INDENT-OFF*
 
 const char* Shader::textureShaderVertex = R"!?!(
 #version 330 core