Performance boost by storing data in GL buffers directly

ChangeLog.md

@@ -6,6 +6,8 @@
     * Fixed bug in WindowSDL where resizing only worked after calling it two times.
     * Fixed bug in Console that caused its window to get bigger after each launch.
     * Added ShaderBuffer class.
+    * Level geometry now stored in GL buffers at level load.
+        * Greatly improved level load times, more FPS.
 
     [ 20141231 ]
     * No longer using Exceptions.

include/Camera.h

@@ -51,7 +51,6 @@ class Camera {
     static void calculateFrustumPlanes();
 
     static glm::vec3 pos;
-    static glm::vec3 drawPos;
     static glm::quat quaternion;
     static glm::vec3 posSpeed;
     static glm::vec2 rotSpeed;

include/Mesh.h

@@ -8,12 +8,13 @@
 #ifndef _MESH_H_
 #define _MESH_H_
 
-#include <map>
 #include <vector>
 #include <glm/mat4x4.hpp>
 #include <glm/vec2.hpp>
 #include <glm/vec3.hpp>
 
+#include "system/Shader.h"
+
 struct IndexedRectangle {
     unsigned int v1, v2, v3, v4; // Vertex list indices
     unsigned int texture; // Index into object-texture list
@@ -46,53 +47,17 @@ class Mesh {
     void display(glm::mat4 MVP);
 
   private:
-    std::vector<unsigned short> indices;
-    std::vector<glm::vec3> vertices;
-    std::vector<glm::vec2> uvs;
-    std::vector<unsigned int> textures;
-
-    std::vector<unsigned short> indicesColor;
-    std::vector<glm::vec3> verticesColor;
-    std::vector<glm::vec3> colors;
-};
-
-// --------------------------------------
-
-struct PackedVertex {
-    glm::vec3 pos;
-    glm::vec2 uv;
-    unsigned int tex;
+    std::vector<unsigned short> indicesBuff;
+    std::vector<glm::vec3> verticesBuff;
+    std::vector<unsigned int> texturesBuff;
 
-    PackedVertex(glm::vec3 p, glm::vec2 u, unsigned int t) : pos(p), uv(u), tex(t) { }
+    std::vector<unsigned short> indicesColorBuff;
+    std::vector<glm::vec3> verticesColorBuff;
+    std::vector<glm::vec3> colorsBuff;
 
-    bool operator<(const PackedVertex& v) const {
-        return memcmp(this, &v, sizeof(PackedVertex)) > 0;
-    }
+    ShaderBuffer indices, vertices, uvs;
+    ShaderBuffer indicesColor, verticesColor, colors;
 };
 
-struct PackedColoredVertex {
-    glm::vec3 pos;
-    glm::vec3 col;
-
-    PackedColoredVertex(glm::vec3 p, glm::vec3 c) : pos(p), col(c) { }
-
-    bool operator<(const PackedColoredVertex& v) const {
-        return memcmp(this, &v, sizeof(PackedColoredVertex)) > 0;
-    }
-};
-
-template <typename T>
-bool findSimilarVertex(T& v,
-                       std::map<T, unsigned short> m,
-                       unsigned short& s) {
-    auto it = m.find(v);
-    if (it == m.end())
-        return false;
-    else {
-        s = it->second;
-        return true;
-    }
-}
-
 #endif
 

include/RoomMesh.h

@@ -14,6 +14,7 @@
 #include <glm/vec3.hpp>
 
 #include "Mesh.h"
+#include "system/Shader.h"
 
 struct RoomVertexTR2 {
     int x, y, z; // Vertex coordinates, relative to x/zOffset
@@ -36,10 +37,10 @@ class RoomMesh {
     void display(glm::mat4 MVP);
 
   private:
-    std::vector<unsigned short> indices;
-    std::vector<glm::vec3> vertices;
-    std::vector<glm::vec2> uvs;
-    std::vector<unsigned int> textures;
+    std::vector<unsigned short> indicesBuff;
+    std::vector<glm::vec3> verticesBuff;
+    std::vector<unsigned int> texturesBuff;
+    ShaderBuffer indices, vertices, uvs;
 };
 
 #endif

include/TextureManager.h

@@ -59,6 +59,7 @@ class TextureManager {
         SYSTEM
     };
 
+    TextureManager() : nextFreeTextureUnit(0) { }
     ~TextureManager();
 
     int initialize();
@@ -69,12 +70,12 @@ class TextureManager {
     int numTextures(TextureStorage s = TextureStorage::GAME);
 
     /*!
-     * \brief Binds the texture for use in GL
-     * \param n valid texture index
-     * \param s Which TextureStorage should be accessed
-     * \param unit Which GL texture unit should be used
+     * \brief Bind texture to next free texture unit.
+     * \param n ID of texture to bind
+     * \param s Place where texture is stored
+     * \returns ID of GL texture unit to which this texture is bound.
      */
-    void bindTextureId(unsigned int n, TextureStorage s = TextureStorage::GAME, unsigned int unit = 0);
+    int bindTexture(unsigned int n, TextureStorage s);
 
     /*!
      * \brief Loads Buffer as texture
@@ -107,6 +108,9 @@ class TextureManager {
 
   private:
     std::vector<unsigned int>& getIds(TextureStorage s);
+    std::vector<int>& getUnits(TextureStorage s);
+
+    void bindTextureId(unsigned int n, TextureStorage s, unsigned int unit);
     int loadPCX(std::string filename, TextureStorage s, int slot);
 
     std::vector<unsigned int> mTextureIdsGame;
@@ -114,6 +118,10 @@ class TextureManager {
 
     std::vector<TextureTile*> tiles;
     std::vector<std::vector<int>> animations;
+
+    std::vector<int> gameUnits;
+    std::vector<int> systemUnits;
+    unsigned int nextFreeTextureUnit;
 };
 
 TextureManager& getTextureManager();

include/system/FontSDL.h

@@ -33,6 +33,8 @@ class FontSDL {
     static bool mFontInit;
     static TTF_Font* mFont;
     static unsigned int mFontTexture;
+    static ShaderBuffer vertexBuffer;
+    static ShaderBuffer uvBuffer;
 };
 
 #endif

include/system/FontTRLE.h

@@ -11,6 +11,8 @@
 #include <vector>
 #include <glm/vec2.hpp>
 
+#include "system/Shader.h"
+
 /*!
  * \brief Tomb Raider Level Editor Font loader
  */
@@ -42,6 +44,9 @@ class FontTRLE {
     // 106 entries: (x, y, w, h, offset)
     static int offsets[106][5];
     static int defaultOffsets[106][5];
+
+    static ShaderBuffer vertexBuffer;
+    static ShaderBuffer uvBuffer;
 };
 
 #endif

include/system/Shader.h

@@ -17,7 +17,7 @@
 
 class ShaderBuffer {
   public:
-    ShaderBuffer();
+    ShaderBuffer() : created(false), buffer(0), boundSize(0) { }
     ~ShaderBuffer();
 
     void bufferData(int elem, int size, void* data);
@@ -30,8 +30,12 @@ class ShaderBuffer {
     void bindBuffer(int location, int size);
     void unbind(int location);
 
+    int getSize() { return boundSize; }
+
   private:
+    bool created;
     unsigned int buffer;
+    int boundSize;
 };
 
 class Shader {
@@ -45,41 +49,31 @@ class Shader {
     int addUniform(const char* name);
     unsigned int getUniform(int n);
 
-    void addBuffer(int n = 1);
-    unsigned int getBuffer(int n);
-
-    template<typename T>
-    void bufferData(int buff, std::vector<T> v)
-        { bufferData(buff, v.size(), sizeof(T), &v[0]); }
-    void bufferData(int buff, int elem, int size, void* d);
-
     void loadUniform(int uni, glm::vec2 vec);
     void loadUniform(int uni, glm::vec4 vec);
     void loadUniform(int uni, glm::mat4 mat);
-    void loadUniform(int uni, int texture, TextureManager::TextureStorage store, int slot = 0);
-
-    void bindBuffer(int buff);
-    void bindBuffer(int buff, int location, int size);
-
-    void disableAttribs();
+    void loadUniform(int uni, int texture, TextureManager::TextureStorage store);
 
     static int initialize();
     static void shutdown();
 
-    static void drawGL(std::vector<glm::vec2>& vertices, std::vector<glm::vec2>& uvs,
-                       glm::vec4 color, unsigned int texture);
+    static void drawGL(ShaderBuffer& vertices, ShaderBuffer& uvs, glm::vec4 color, unsigned int texture,
+                       TextureManager::TextureStorage store = TextureManager::TextureStorage::SYSTEM);
 
-    static void drawGL(std::vector<glm::vec3>& vertices, std::vector<glm::vec2>& uvs,
-                       std::vector<unsigned short>& indices, glm::mat4 MVP, unsigned int texture);
+    static void drawGL(ShaderBuffer& vertices, ShaderBuffer& uvs, unsigned int texture, glm::mat4 MVP,
+                       TextureManager::TextureStorage store = TextureManager::TextureStorage::GAME);
+    static void drawGL(ShaderBuffer& vertices, ShaderBuffer& uvs, ShaderBuffer& indices,
+                       unsigned int texture, glm::mat4 MVP,
+                       TextureManager::TextureStorage store = TextureManager::TextureStorage::GAME);
 
-    static void drawGL(std::vector<glm::vec3>& vertices, std::vector<glm::vec3>& colors,
-                       std::vector<unsigned short>& indices, glm::mat4 MVP, int mode = GL_TRIANGLES);
+    static void drawGL(ShaderBuffer& vertices, ShaderBuffer& colors, glm::mat4 MVP,
+                       unsigned int mode = GL_TRIANGLES);
+    static void drawGL(ShaderBuffer& vertices, ShaderBuffer& colors, ShaderBuffer& indices,
+                       glm::mat4 MVP, unsigned int mode = GL_TRIANGLES);
 
   private:
     int programID;
     std::vector<unsigned int> uniforms;
-    std::vector<unsigned int> buffers;
-    std::vector<bool> attribs;
 
     static Shader textShader;
     static const char* textShaderVertex;

src/Camera.cpp

@@ -43,7 +43,6 @@ const static glm::vec3 upUnit(0.0f, 1.0f, 0.0f);
 const static glm::vec3 dirUnit(0.0f, 0.0f, -1.0f);
 
 glm::vec3 Camera::pos(0.0f, 0.0f, 0.0f);
-glm::vec3 Camera::drawPos(0.0f, 0.0f, 0.0f);
 glm::quat Camera::quaternion(glm::vec3(0.0f, 0.0f, 0.0f));
 glm::vec3 Camera::posSpeed(0.0f, 0.0f, 0.0f);
 glm::vec2 Camera::rotSpeed(0.0f, 0.0f);
@@ -56,7 +55,6 @@ bool Camera::dirty = true;
 
 void Camera::reset() {
     pos = glm::vec3(0.0f, 0.0f, 0.0f);
-    drawPos = glm::vec3(0.0f, 0.0f, 0.0f);
     quaternion = glm::quat(glm::vec3(0.0f, 0.0f, 0.0f));
     posSpeed = glm::vec3(0.0f, 0.0f, 0.0f);
     rotSpeed = glm::vec2(0.0f, 0.0f);
@@ -233,6 +231,12 @@ static glm::vec3 frustumColors[6] = {
 };
 static glm::vec3 frustumVertices[8];
 
+static ShaderBuffer vertexBuffer;
+static ShaderBuffer colorBuffer;
+static ShaderBuffer indexBuffer;
+static ShaderBuffer vertexPointBuffer;
+static ShaderBuffer colorPointBuffer;
+
 void Camera::calculateFrustumPlanes() {
     glm::mat4 combo = projection * view;
 
@@ -260,30 +264,7 @@ void Camera::calculateFrustumPlanes() {
     planes[NEAR].set(frustumVertices[NTL], frustumVertices[NTR], frustumVertices[NBR]);
     planes[FAR].set(frustumVertices[FTR], frustumVertices[FTL], frustumVertices[FBL]);
 
-    drawPos = getPosition();
-}
-
-bool Camera::boxInFrustum(BoundingBox b) {
-    for (int i = 0; i < 6; i++) {
-        int out = 0, in = 0;
-        for (int c = 0; (c < 8) && ((in == 0) || (out == 0)); c++) {
-            if (planes[i].distance(b.getCorner(c)) < 0)
-                out++;
-            else
-                in++;
-        }
-
-        if (in == 0)
-            return false;
-    }
-
-    return true;
-}
-
-void Camera::displayFrustum(glm::mat4 MVP) {
     std::vector<glm::vec3> verts;
-    std::vector<glm::vec3> cols;
-    std::vector<unsigned short> inds;
 
     // Near
     verts.push_back(frustumVertices[NTL]);
@@ -321,29 +302,60 @@ void Camera::displayFrustum(glm::mat4 MVP) {
     verts.push_back(frustumVertices[FTR]);
     verts.push_back(frustumVertices[FBR]);
 
-    for (int i = 0; i < 6; i++) {
-        cols.push_back(frustumColors[i]);
-        cols.push_back(frustumColors[i]);
-        cols.push_back(frustumColors[i]);
-        cols.push_back(frustumColors[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);
-    }
-
-    Shader::drawGL(verts, cols, inds, MVP);
+    vertexBuffer.bufferData(verts);
 
     verts.clear();
-    cols.clear();
-    inds.clear();
+    std::vector<glm::vec3> cols;
 
-    verts.push_back(drawPos);
+    verts.push_back(getPosition());
     cols.push_back(glm::vec3(1.0f, 1.0f, 1.0f));
-    inds.push_back(0);
-    Shader::drawGL(verts, cols, inds, MVP, GL_POINTS);
+
+    vertexPointBuffer.bufferData(verts);
+    colorPointBuffer.bufferData(cols);
+
+    if (colorBuffer.getSize() == 0) {
+        cols.clear();
+        for (int i = 0; i < 6; i++) {
+            for (int j = 0; j < 4; j++) {
+                cols.push_back(frustumColors[i]);
+            }
+        }
+        colorBuffer.bufferData(cols);
+    }
+
+    if (indexBuffer.getSize() == 0) {
+        std::vector<unsigned short> inds;
+        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.bufferData(inds);
+    }
+}
+
+bool Camera::boxInFrustum(BoundingBox b) {
+    for (int i = 0; i < 6; i++) {
+        int out = 0, in = 0;
+        for (int c = 0; (c < 8) && ((in == 0) || (out == 0)); c++) {
+            if (planes[i].distance(b.getCorner(c)) < 0)
+                out++;
+            else
+                in++;
+        }
+
+        if (in == 0)
+            return false;
+    }
+
+    return true;
+}
+
+void Camera::displayFrustum(glm::mat4 MVP) {
+    Shader::drawGL(vertexBuffer, colorBuffer, indexBuffer, MVP);
+    Shader::drawGL(vertexPointBuffer, colorPointBuffer, MVP, GL_POINTS);
 }
 

src/Mesh.cpp

@@ -16,132 +16,132 @@ Mesh::Mesh(const std::vector<glm::vec3>& vert,
            const std::vector<IndexedColoredRectangle>& coloredRect,
            const std::vector<IndexedColoredRectangle>& coloredTri) {
     for (auto& t : rect) {
-        indices.push_back(0);
-        vertices.push_back(glm::vec3(vert.at(t.v1).x, vert.at(t.v1).y, vert.at(t.v1).z));
-        vertices.push_back(glm::vec3(vert.at(t.v2).x, vert.at(t.v2).y, vert.at(t.v2).z));
-        vertices.push_back(glm::vec3(vert.at(t.v3).x, vert.at(t.v3).y, vert.at(t.v3).z));
-        vertices.push_back(glm::vec3(vert.at(t.v4).x, vert.at(t.v4).y, vert.at(t.v4).z));
-        textures.push_back(t.texture);
+        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));
+        texturesBuff.push_back(t.texture);
     }
 
     for (auto& t : tri) {
-        indices.push_back(1);
-        vertices.push_back(glm::vec3(vert.at(t.v1).x, vert.at(t.v1).y, vert.at(t.v1).z));
-        vertices.push_back(glm::vec3(vert.at(t.v2).x, vert.at(t.v2).y, vert.at(t.v2).z));
-        vertices.push_back(glm::vec3(vert.at(t.v3).x, vert.at(t.v3).y, vert.at(t.v3).z));
-        textures.push_back(t.texture);
+        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));
+        texturesBuff.push_back(t.texture);
     }
 
     for (auto& t : coloredRect) {
-        indicesColor.push_back(0);
-        verticesColor.push_back(glm::vec3(vert.at(t.v1).x, vert.at(t.v1).y, vert.at(t.v1).z));
-        verticesColor.push_back(glm::vec3(vert.at(t.v2).x, vert.at(t.v2).y, vert.at(t.v2).z));
-        verticesColor.push_back(glm::vec3(vert.at(t.v3).x, vert.at(t.v3).y, vert.at(t.v3).z));
-        verticesColor.push_back(glm::vec3(vert.at(t.v4).x, vert.at(t.v4).y, vert.at(t.v4).z));
-        colors.push_back(glm::vec3(t.r, t.g, t.b));
+        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(glm::vec3(t.r, t.g, t.b));
     }
 
     for (auto& t : coloredTri) {
-        indicesColor.push_back(1);
-        verticesColor.push_back(glm::vec3(vert.at(t.v1).x, vert.at(t.v1).y, vert.at(t.v1).z));
-        verticesColor.push_back(glm::vec3(vert.at(t.v2).x, vert.at(t.v2).y, vert.at(t.v2).z));
-        verticesColor.push_back(glm::vec3(vert.at(t.v3).x, vert.at(t.v3).y, vert.at(t.v3).z));
-        colors.push_back(glm::vec3(t.r, t.g, t.b));
+        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(glm::vec3(t.r, t.g, t.b));
     }
 }
 
 void Mesh::prepare() {
     std::vector<unsigned short> ind;
     std::vector<glm::vec3> vert;
+    std::vector<glm::vec2> uvBuff;
     std::vector<unsigned int> tex;
-    std::map<PackedVertex, unsigned short> vertexMap;
+
     int vertIndex = 0;
-    for (int i = 0; i < indices.size(); i++) {
-        unsigned int texture = getTextureManager().getTile(textures.at(i)).getTexture();
-        for (int v = 0; v < ((indices.at(i) == 0) ? 4 : 3); v++) {
-            glm::vec2 uv = getTextureManager().getTile(textures.at(i)).getUV(v);
-            PackedVertex p(vertices.at(vertIndex + v), uv, texture);
-            unsigned short s;
-            if (findSimilarVertex(p, vertexMap, s)) {
-                ind.push_back(s); // Vertex already cached
-            } else {
-                vertexMap[p] = vert.size();
-                ind.push_back(vert.size());
-                vert.push_back(p.pos);
-                uvs.push_back(p.uv);
-                tex.push_back(p.tex);
-            }
+    for (int i = 0; i < indicesBuff.size(); i++) {
+        unsigned int texture = getTextureManager().getTile(texturesBuff.at(i)).getTexture();
+        for (int v = 0; v < ((indicesBuff.at(i) == 0) ? 4 : 3); v++) {
+            ind.push_back(vert.size());
+            vert.push_back(verticesBuff.at(vertIndex + v));
+            uvBuff.push_back(getTextureManager().getTile(texturesBuff.at(i)).getUV(v));
+            tex.push_back(texture);
         }
 
-        if (indices.at(i) == 0) {
+        if (indicesBuff.at(i) == 0) {
             ind.push_back(ind.at(ind.size() - 2));
             ind.push_back(ind.at(ind.size() - 5));
         }
 
-        vertIndex += (indices.at(i) == 0) ? 4 : 3;
+        vertIndex += (indicesBuff.at(i) == 0) ? 4 : 3;
     }
+
     assert((ind.size() % 3) == 0);
     assert(vert.size() == tex.size());
-    assert(vert.size() == uvs.size());
-    indices = std::move(ind);
-    vertices = std::move(vert);
-    textures = std::move(tex);
-
-    std::vector<unsigned short> indC;
-    std::vector<glm::vec3> vertC;
-    std::vector<glm::vec3> col;
-    std::map<PackedColoredVertex, unsigned short> vertexMapC;
+    assert(vert.size() == uvBuff.size());
+
+    indicesBuff = std::move(ind);
+    vertices.bufferData(vert);
+    uvs.bufferData(uvBuff);
+    texturesBuff = std::move(tex);
+
+    std::vector<unsigned short> indCol;
+    std::vector<glm::vec3> vertCol;
+    std::vector<glm::vec3> cols;
+
     vertIndex = 0;
-    for (int i = 0; i < indicesColor.size(); i++) {
-        for (int v = 0; v < ((indicesColor.at(i) == 0) ? 4 : 3); v++) {
-            PackedColoredVertex p(verticesColor.at(vertIndex + v), colors.at(i));
-            unsigned short s;
-            if (findSimilarVertex(p, vertexMapC, s)) {
-                indC.push_back(s); // Vertex already cached
-            } else {
-                vertexMapC[p] = vertC.size();
-                indC.push_back(vertC.size());
-                vertC.push_back(p.pos);
-                col.push_back(p.col);
-            }
+    for (int i = 0; i < indicesColorBuff.size(); i++) {
+        for (int v = 0; v < ((indicesColorBuff.at(i) == 0) ? 4 : 3); v++) {
+            indCol.push_back(vertCol.size());
+            vertCol.push_back(verticesColorBuff.at(vertIndex + v));
+            cols.push_back(colorsBuff.at(i));
         }
 
-        if (indicesColor.at(i) == 0) {
-            indC.push_back(indC.at(indC.size() - 2));
-            indC.push_back(indC.at(indC.size() - 5));
+        if (indicesColorBuff.at(i) == 0) {
+            indCol.push_back(indCol.at(indCol.size() - 2));
+            indCol.push_back(indCol.at(indCol.size() - 5));
         }
 
-        vertIndex += (indicesColor.at(i) == 0) ? 4 : 3;
+        vertIndex += (indicesColorBuff.at(i) == 0) ? 4 : 3;
     }
-    assert((indC.size() % 3) == 0);
-    assert(vertC.size() == col.size());
-    indicesColor = std::move(indC);
-    verticesColor = std::move(vertC);
-    colors = std::move(col);
+
+    assert((indCol.size() % 3) == 0);
+    assert(vertCol.size() == cols.size());
+
+    indicesColor.bufferData(indCol);
+    verticesColor.bufferData(vertCol);
+    colors.bufferData(cols);
+
+    verticesBuff.clear();
+    indicesColorBuff.clear();
+    verticesColorBuff.clear();
+    colorsBuff.clear();
 }
 
 void Mesh::display(glm::mat4 MVP) {
-    if (indices.size() > 0) {
+    if (indicesBuff.size() > 0) {
         unsigned int indexStart = 0;
         unsigned int indexPos = 1;
-        unsigned int texture = textures.at(indices.at(0));
+        unsigned int texture = texturesBuff.at(indicesBuff.at(0));
 
-        while ((indexStart != indexPos) && (indexPos < indices.size())) {
-            while ((indexPos < indices.size()) && (textures.at(indices.at(indexPos)) == texture))
+        while ((indexStart != indexPos) && (indexPos < indicesBuff.size())) {
+            while ((indexPos < indicesBuff.size())
+                    && (texturesBuff.at(indicesBuff.at(indexPos)) == texture)) {
                 indexPos++;
+            }
 
-            std::vector<unsigned short> ind(indices.begin() + indexStart, indices.begin() + indexPos);
-            Shader::drawGL(vertices, uvs, ind, MVP, texture);
+            std::vector<unsigned short> ind(indicesBuff.begin() + indexStart,
+                                            indicesBuff.begin() + indexPos);
+            indices.bufferData(ind);
+            Shader::drawGL(vertices, uvs, indices, texture, MVP);
 
-            if (indexPos < indices.size()) {
+            if (indexPos < indicesBuff.size()) {
                 indexStart = indexPos;
                 indexPos += 1;
-                texture = textures.at(indices.at(indexStart));
+                texture = texturesBuff.at(indicesBuff.at(indexStart));
             }
         }
     }
 
-    if (indicesColor.size() > 0)
+    if (indicesColor.getSize() > 0)
         Shader::drawGL(verticesColor, colors, indicesColor, MVP);
 }
 

src/Render.cpp

@@ -185,10 +185,11 @@ void Render::drawTexture(float x, float y, float w, float h, glm::vec4 color,
     uvs.push_back(glm::vec2(1.0f, 1.0f));
     uvs.push_back(glm::vec2(0.0f, 0.0f));
 
-    //! \fixme This drawGL only uses SYSTEM textures!
-    assert(s == TextureManager::TextureStorage::SYSTEM);
+    static ShaderBuffer vert, uv;
+    vert.bufferData(vertices);
+    uv.bufferData(uvs);
 
-    Shader::drawGL(vertices, uvs, color, texture);
+    Shader::drawGL(vert, uv, color, texture, s);
 }
 
 static const int modeStringCount = 4;

src/RoomData.cpp

@@ -40,7 +40,11 @@ void BoundingBox::display(glm::mat4 VP, glm::vec3 colorLine, glm::vec3 colorDot)
     inds.push_back(5);
     inds.push_back(2);
 
-    Shader::drawGL(verts, cols, inds, VP, GL_LINE_STRIP);
+    static ShaderBuffer vert, col, ind;
+    vert.bufferData(verts);
+    col.bufferData(cols);
+    ind.bufferData(inds);
+    Shader::drawGL(vert, col, ind, VP, GL_LINE_STRIP);
 
     cols.clear();
     inds.clear();
@@ -50,7 +54,11 @@ void BoundingBox::display(glm::mat4 VP, glm::vec3 colorLine, glm::vec3 colorDot)
         inds.push_back(i);
     }
 
-    Shader::drawGL(verts, cols, inds, VP, GL_POINTS);
+    static ShaderBuffer vert2, col2, ind2;
+    vert2.bufferData(verts);
+    col2.bufferData(cols);
+    ind2.bufferData(inds);
+    Shader::drawGL(vert2, col2, ind2, VP, GL_POINTS);
 }
 
 // ----------------------------------------------------------------------------

src/RoomMesh.cpp

@@ -6,89 +6,85 @@
  */
 
 #include "global.h"
-#include "Mesh.h"
 #include "TextureManager.h"
-#include "system/Shader.h"
 #include "RoomMesh.h"
 
 RoomMesh::RoomMesh(const std::vector<RoomVertexTR2>& vert,
                    const std::vector<IndexedRectangle>& rect,
                    const std::vector<IndexedRectangle>& tri) {
     for (auto& t : rect) {
-        indices.push_back(0);
-        vertices.push_back(glm::vec3(vert.at(t.v1).x, vert.at(t.v1).y, vert.at(t.v1).z));
-        vertices.push_back(glm::vec3(vert.at(t.v2).x, vert.at(t.v2).y, vert.at(t.v2).z));
-        vertices.push_back(glm::vec3(vert.at(t.v3).x, vert.at(t.v3).y, vert.at(t.v3).z));
-        vertices.push_back(glm::vec3(vert.at(t.v4).x, vert.at(t.v4).y, vert.at(t.v4).z));
-        textures.push_back(t.texture);
+        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));
+        texturesBuff.push_back(t.texture);
     }
 
     for (auto& t : tri) {
-        indices.push_back(1);
-        vertices.push_back(glm::vec3(vert.at(t.v1).x, vert.at(t.v1).y, vert.at(t.v1).z));
-        vertices.push_back(glm::vec3(vert.at(t.v2).x, vert.at(t.v2).y, vert.at(t.v2).z));
-        vertices.push_back(glm::vec3(vert.at(t.v3).x, vert.at(t.v3).y, vert.at(t.v3).z));
-        textures.push_back(t.texture);
+        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));
+        texturesBuff.push_back(t.texture);
     }
 }
 
 void RoomMesh::prepare() {
     std::vector<unsigned short> ind;
     std::vector<glm::vec3> vert;
+    std::vector<glm::vec2> uvBuff;
     std::vector<unsigned int> tex;
 
-    std::map<PackedVertex, unsigned short> vertexMap;
-
     int vertIndex = 0;
-    for (int i = 0; i < indices.size(); i++) {
-        unsigned int texture = getTextureManager().getTile(textures.at(i)).getTexture();
-        for (int v = 0; v < ((indices.at(i) == 0) ? 4 : 3); v++) {
-            glm::vec2 uv = getTextureManager().getTile(textures.at(i)).getUV(v);
-            PackedVertex p(vertices.at(vertIndex + v), uv, texture);
-            unsigned short s;
-            if (findSimilarVertex(p, vertexMap, s)) {
-                ind.push_back(s); // Vertex already cached
-            } else {
-                vertexMap[p] = vert.size();
-                ind.push_back(vert.size());
-                vert.push_back(p.pos);
-                uvs.push_back(p.uv);
-                tex.push_back(p.tex);
-            }
+    for (int i = 0; i < indicesBuff.size(); i++) {
+        unsigned int texture = getTextureManager().getTile(texturesBuff.at(i)).getTexture();
+        for (int v = 0; v < ((indicesBuff.at(i) == 0) ? 4 : 3); v++) {
+            ind.push_back(vert.size());
+            vert.push_back(verticesBuff.at(vertIndex + v));
+            uvBuff.push_back(getTextureManager().getTile(texturesBuff.at(i)).getUV(v));
+            tex.push_back(texture);
         }
 
-        if (indices.at(i) == 0) {
+        if (indicesBuff.at(i) == 0) {
             ind.push_back(ind.at(ind.size() - 2));
             ind.push_back(ind.at(ind.size() - 5));
         }
 
-        vertIndex += (indices.at(i) == 0) ? 4 : 3;
+        vertIndex += (indicesBuff.at(i) == 0) ? 4 : 3;
     }
 
     assert((ind.size() % 3) == 0);
+    assert(vert.size() == tex.size());
+    assert(vert.size() == uvBuff.size());
 
-    indices = std::move(ind);
-    vertices = std::move(vert);
-    textures = std::move(tex);
+    indicesBuff = std::move(ind);
+    vertices.bufferData(vert);
+    uvs.bufferData(uvBuff);
+    texturesBuff = std::move(tex);
 }
 
 void RoomMesh::display(glm::mat4 MVP) {
-    if (indices.size() > 0) {
+    if (indicesBuff.size() > 0) {
         unsigned int indexStart = 0;
         unsigned int indexPos = 1;
-        unsigned int texture = textures.at(indices.at(0));
+        unsigned int texture = texturesBuff.at(indicesBuff.at(0));
 
-        while ((indexStart != indexPos) && (indexPos < indices.size())) {
-            while ((indexPos < indices.size()) && (textures.at(indices.at(indexPos)) == texture))
+        while ((indexStart != indexPos) && (indexPos < indicesBuff.size())) {
+            while ((indexPos < indicesBuff.size())
+                    && (texturesBuff.at(indicesBuff.at(indexPos)) == texture)) {
                 indexPos++;
+            }
 
-            std::vector<unsigned short> ind(indices.begin() + indexStart, indices.begin() + indexPos);
-            Shader::drawGL(vertices, uvs, ind, MVP, texture);
+            std::vector<unsigned short> ind(indicesBuff.begin() + indexStart,
+                                            indicesBuff.begin() + indexPos);
+            indices.bufferData(ind);
+            Shader::drawGL(vertices, uvs, indices, texture, MVP);
 
-            if (indexPos < indices.size()) {
+            if (indexPos < indicesBuff.size()) {
                 indexStart = indexPos;
                 indexPos += 1;
-                texture = textures.at(indices.at(indexStart));
+                texture = texturesBuff.at(indicesBuff.at(indexStart));
             }
         }
     }

src/TextureManager.cpp

@@ -69,8 +69,11 @@ void TextureManager::clear() {
         tiles.pop_back();
     }
 
-    while (!animations.empty())
-        animations.pop_back();
+    animations.clear();
+
+    gameUnits.clear();
+    systemUnits.clear();
+    nextFreeTextureUnit = 0;
 }
 
 void TextureManager::addTile(TextureTile* t) {
@@ -125,6 +128,13 @@ std::vector<unsigned int>& TextureManager::getIds(TextureStorage s) {
         return mTextureIdsSystem;
 }
 
+std::vector<int>& TextureManager::getUnits(TextureStorage s) {
+    if (s == TextureStorage::GAME)
+        return gameUnits;
+    else
+        return systemUnits;
+}
+
 int TextureManager::initialize() {
     assert(mTextureIdsGame.size() == 0);
     assert(mTextureIdsSystem.size() == 0);
@@ -216,7 +226,7 @@ int TextureManager::loadBufferSlot(unsigned char* image,
     }
 
     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
-    glBindTexture(GL_TEXTURE_2D, getIds(s).at(slot));
+    bindTexture(slot, s);
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, glcMode, GL_UNSIGNED_BYTE, image);
 
     if (filter) {
@@ -246,9 +256,23 @@ void TextureManager::bindTextureId(unsigned int n, TextureStorage s, unsigned in
     glBindTexture(GL_TEXTURE_2D, getIds(s).at(n));
 }
 
-int TextureManager::loadImage(std::string filename, TextureStorage s, int slot) {
-    //! \todo case insensitive compare
+int TextureManager::bindTexture(unsigned int n, TextureStorage s) {
+    assert(n < getIds(s).size());
+
+    if ((n < getUnits(s).size()) && (getUnits(s).at(n) >= 0)) {
+        bindTextureId(n, s, getUnits(s).at(n));
+        return getUnits(s).at(n);
+    } else {
+        while (getUnits(s).size() <= n)
+            getUnits(s).push_back(-1);
+        getUnits(s).at(n) = nextFreeTextureUnit;
+        bindTextureId(n, s, nextFreeTextureUnit);
+        nextFreeTextureUnit++;
+        return nextFreeTextureUnit - 1;
+    }
+}
 
+int TextureManager::loadImage(std::string filename, TextureStorage s, int slot) {
     if (stringEndsWith(filename, ".pcx")) {
         return loadPCX(filename, s, slot);
     } else {

src/UI.cpp

@@ -52,7 +52,6 @@ int UI::initialize() {
         return -2;
     if (imguiShader.addUniform("textureSampler") < 0)
         return -3;
-    imguiShader.addBuffer(3);
 
     iniFilename = RunTime::getBaseDir() + "/imgui.ini";
     logFilename = RunTime::getBaseDir() + "/imgui_log.txt";
@@ -531,19 +530,17 @@ void UI::renderImGui(ImDrawList** const cmd_lists, int cmd_lists_count) {
     if (cmd_lists_count == 0)
         return;
 
+    static ShaderBuffer vert, uv, col;
+
     glEnable(GL_SCISSOR_TEST);
     glDisable(GL_DEPTH_TEST);
 
     imguiShader.use();
     imguiShader.loadUniform(0, Window::getSize());
     imguiShader.loadUniform(1, fontTex, TextureManager::TextureStorage::SYSTEM);
-    imguiShader.bindBuffer(0, 0, 2);
-    imguiShader.bindBuffer(1, 1, 2);
-    imguiShader.bindBuffer(2, 2, 4);
-
-    std::vector<glm::vec2> vertices;
-    std::vector<glm::vec2> uvs;
-    std::vector<glm::vec4> colors;
+    vert.bindBuffer(0, 2);
+    uv.bindBuffer(1, 2);
+    col.bindBuffer(2, 4);
 
     /*! \fixme Don't copy data
      * The GL calls and the shaders can probably be slightly altered
@@ -556,6 +553,10 @@ void UI::renderImGui(ImDrawList** const cmd_lists, int cmd_lists_count) {
 
         int offset = 0;
         for (int n = 0; n < commands.size(); n++) {
+            std::vector<glm::vec2> vertices;
+            std::vector<glm::vec2> uvs;
+            std::vector<glm::vec4> colors;
+
             for (int v = 0; v < commands[n].vtx_count; v++) {
                 vertices.push_back(glm::vec2(buffer[offset + v].pos.x, buffer[offset + v].pos.y));
                 uvs.push_back(glm::vec2(buffer[offset + v].uv.x, buffer[offset + v].uv.y));
@@ -570,9 +571,9 @@ void UI::renderImGui(ImDrawList** const cmd_lists, int cmd_lists_count) {
 
             offset += commands[n].vtx_count;
 
-            imguiShader.bufferData(0, vertices);
-            imguiShader.bufferData(1, uvs);
-            imguiShader.bufferData(2, colors);
+            vert.bufferData(vertices);
+            uv.bufferData(uvs);
+            col.bufferData(colors);
 
             glScissor(commands[n].clip_rect.x,
                       Window::getSize().y - commands[n].clip_rect.w,
@@ -580,14 +581,12 @@ void UI::renderImGui(ImDrawList** const cmd_lists, int cmd_lists_count) {
                       commands[n].clip_rect.w - commands[n].clip_rect.y);
 
             glDrawArrays(GL_TRIANGLES, 0, vertices.size());
-
-            vertices.clear();
-            uvs.clear();
-            colors.clear();
         }
     }
 
-    imguiShader.disableAttribs();
+    vert.unbind(0);
+    uv.unbind(1);
+    col.unbind(2);
 
     glEnable(GL_DEPTH_TEST);
     glDisable(GL_SCISSOR_TEST);

src/system/FontSDL.cpp

@@ -15,6 +15,8 @@
 bool FontSDL::mFontInit = false;
 TTF_Font* FontSDL::mFont = nullptr;
 unsigned int FontSDL::mFontTexture = -1;
+ShaderBuffer FontSDL::vertexBuffer;
+ShaderBuffer FontSDL::uvBuffer;
 
 void FontSDL::shutdown() {
     if (mFont != nullptr)
@@ -126,7 +128,10 @@ void FontSDL::drawText(unsigned int x, unsigned int y, float scale,
     uvs.push_back(glm::vec2(1.0f, 1.0f));
     uvs.push_back(glm::vec2(0.0f, 0.0f));
 
-    Shader::drawGL(vertices, uvs, glm::vec4(1.0f, 1.0f, 1.0f, 1.0f), mFontTexture);
+    vertexBuffer.bufferData(vertices);
+    uvBuffer.bufferData(uvs);
+    Shader::drawGL(vertexBuffer, uvBuffer, glm::vec4(1.0f, 1.0f, 1.0f, 1.0f),
+                   mFontTexture, TextureManager::TextureStorage::SYSTEM);
 }
 
 unsigned int FontSDL::heightText(float scale, unsigned int maxWidth, std::string s) {
@@ -208,6 +213,9 @@ void FontSDL::drawTextWrapped(unsigned int x, unsigned int y, float scale,
     uvs.push_back(glm::vec2(1.0f, 1.0f));
     uvs.push_back(glm::vec2(0.0f, 0.0f));
 
-    Shader::drawGL(vertices, uvs, glm::vec4(1.0f, 1.0f, 1.0f, 1.0f), mFontTexture);
+    vertexBuffer.bufferData(vertices);
+    uvBuffer.bufferData(uvs);
+    Shader::drawGL(vertexBuffer, uvBuffer, glm::vec4(1.0f, 1.0f, 1.0f, 1.0f),
+                   mFontTexture, TextureManager::TextureStorage::SYSTEM);
 }
 

src/system/FontTRLE.cpp

@@ -21,6 +21,8 @@
 bool FontTRLE::mFontInit = false;
 unsigned int FontTRLE::mFontTexture = 0;
 int FontTRLE::offsets[106][5];
+ShaderBuffer FontTRLE::vertexBuffer;
+ShaderBuffer FontTRLE::uvBuffer;
 
 void FontTRLE::shutdown() {
 }
@@ -166,8 +168,10 @@ void FontTRLE::drawText(unsigned int x, unsigned int y, float scale,
         x += (int)((float)(offsets[index][2] + 1) * scale * SCALING); // width
     }
 
+    vertexBuffer.bufferData(vertices);
+    uvBuffer.bufferData(uvs);
     glm::vec4 col(color[0] / 256.0f, color[1] / 256.0f, color[2] / 256.0f, color[3] / 256.0f);
-    Shader::drawGL(vertices, uvs, col, mFontTexture);
+    Shader::drawGL(vertexBuffer, uvBuffer, col, mFontTexture);
 }
 
 unsigned int FontTRLE::heightText(float scale, unsigned int maxWidth, std::string s) {
@@ -240,8 +244,10 @@ void FontTRLE::drawTextWrapped(unsigned int x, unsigned int y, float scale,
         x += (int)((float)(offsets[index][2] + 1) * scale * SCALING); // width
     }
 
+    vertexBuffer.bufferData(vertices);
+    uvBuffer.bufferData(uvs);
     glm::vec4 col(color[0] / 256.0f, color[1] / 256.0f, color[2] / 256.0f, color[3] / 256.0f);
-    Shader::drawGL(vertices, uvs, col, mFontTexture);
+    Shader::drawGL(vertexBuffer, uvBuffer, col, mFontTexture);
 }
 
 int FontTRLE::defaultOffsets[106][5] = {

src/system/Shader.cpp

@@ -11,30 +11,44 @@
 #include "system/Window.h"
 #include "system/Shader.h"
 
-ShaderBuffer::ShaderBuffer() : buffer(0) {
-    glGenBuffers(1, &buffer);
-}
-
 ShaderBuffer::~ShaderBuffer() {
-    glDeleteBuffers(1, &buffer);
+    if (created)
+        glDeleteBuffers(1, &buffer);
 }
 
 void ShaderBuffer::bufferData(int elem, int size, void* data) {
+    if (!created) {
+        glGenBuffers(1, &buffer);
+        created = true;
+    }
+
+    boundSize = elem;
     glBindBuffer(GL_ARRAY_BUFFER, buffer);
     glBufferData(GL_ARRAY_BUFFER, elem * size, data, GL_STATIC_DRAW);
 }
 
 void ShaderBuffer::bindBuffer() {
+    if (!created) {
+        glGenBuffers(1, &buffer);
+        created = true;
+    }
+
     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer);
 }
 
 void ShaderBuffer::bindBuffer(int location, int size) {
+    if (!created) {
+        glGenBuffers(1, &buffer);
+        created = true;
+    }
+
     glEnableVertexAttribArray(location);
     glBindBuffer(GL_ARRAY_BUFFER, buffer);
     glVertexAttribPointer(location, size, GL_FLOAT, GL_FALSE, 0, nullptr);
 }
 
 void ShaderBuffer::unbind(int location) {
+    assert(created == true);
     glDisableVertexAttribArray(location);
 }
 
@@ -43,9 +57,6 @@ void ShaderBuffer::unbind(int location) {
 Shader::~Shader() {
     if (programID >= 0)
         glDeleteProgram(programID);
-
-    if (!buffers.empty())
-        glDeleteBuffers(buffers.size(), &buffers[0]);
 }
 
 int Shader::addUniform(const char* name) {
@@ -65,24 +76,6 @@ unsigned int Shader::getUniform(int n) {
     return uniforms.at(n);
 }
 
-void Shader::addBuffer(int n) {
-    int s = buffers.size();
-    for (int i = 0; i < n; i++)
-        buffers.push_back(0);
-    glGenBuffers(n, &buffers[s]);
-}
-
-unsigned int Shader::getBuffer(int n) {
-    assert(n >= 0);
-    assert(n < buffers.size());
-    return buffers.at(n);
-}
-
-void Shader::bufferData(int buff, int elem, int size, void* d) {
-    glBindBuffer(GL_ARRAY_BUFFER, getBuffer(buff));
-    glBufferData(GL_ARRAY_BUFFER, elem * size, d, GL_STREAM_DRAW);
-}
-
 void Shader::loadUniform(int uni, glm::vec2 vec) {
     glUniform2f(getUniform(uni), vec.x, vec.y);
 }
@@ -95,32 +88,8 @@ void Shader::loadUniform(int uni, glm::mat4 mat) {
     glUniformMatrix4fv(getUniform(uni), 1, GL_FALSE, &mat[0][0]);
 }
 
-void Shader::loadUniform(int uni, int texture, TextureManager::TextureStorage store, int slot) {
-    getTextureManager().bindTextureId(texture, store, slot);
-    glUniform1i(getUniform(uni), slot);
-}
-
-void Shader::bindBuffer(int buff) {
-    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, getBuffer(buff));
-}
-
-void Shader::bindBuffer(int buff, int location, int size) {
-    glEnableVertexAttribArray(location);
-    glBindBuffer(GL_ARRAY_BUFFER, getBuffer(buff));
-    glVertexAttribPointer(location, size, GL_FLOAT, GL_FALSE, 0, nullptr);
-
-    while (attribs.size() <= location)
-        attribs.push_back(false);
-    attribs.at(location) = true;
-}
-
-void Shader::disableAttribs() {
-    for (int i = 0; i < attribs.size(); i++) {
-        if (attribs.at(i)) {
-            glDisableVertexAttribArray(i);
-            attribs.at(i) = false;
-        }
-    }
+void Shader::loadUniform(int uni, int texture, TextureManager::TextureStorage store) {
+    glUniform1i(getUniform(uni), getTextureManager().bindTexture(texture, store));
 }
 
 void Shader::use() {
@@ -225,6 +194,9 @@ int Shader::initialize() {
     // Accept fragment if closer to camera
     glDepthFunc(GL_LESS);
 
+    glEnable(GL_BLEND);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
     // Set up culling
     //glEnable(GL_CULL_FACE); //! \todo Transparency?
 
@@ -238,7 +210,6 @@ int Shader::initialize() {
         return -3;
     if (textShader.addUniform("colorVar") < 0)
         return -4;
-    textShader.addBuffer(2);
 
     if (textureShader.compile(textureShaderVertex, textureShaderFragment) < 0)
         return -5;
@@ -246,16 +217,11 @@ int Shader::initialize() {
         return -6;
     if (textureShader.addUniform("textureSampler") < 0)
         return -7;
-    textureShader.addBuffer(3);
 
     if (colorShader.compile(colorShaderVertex, colorShaderFragment) < 0)
         return -8;
     if (colorShader.addUniform("MVP") < 0)
         return -9;
-    colorShader.addBuffer(3);
-
-    glEnable(GL_BLEND);
-    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
     return 0;
 }
@@ -264,59 +230,81 @@ void Shader::shutdown() {
     glDeleteVertexArrays(1, &vertexArrayID);
 }
 
-void Shader::drawGL(std::vector<glm::vec2>& vertices, std::vector<glm::vec2>& uvs,
-                    glm::vec4 color, unsigned int texture) {
-    assert(vertices.size() == uvs.size());
-    assert((vertices.size() % 3) == 0);
+void Shader::drawGL(ShaderBuffer& vertices, ShaderBuffer& uvs, glm::vec4 color,
+                    unsigned int texture, TextureManager::TextureStorage store) {
+    assert(vertices.getSize() == uvs.getSize());
+    assert((vertices.getSize() % 3) == 0);
 
-    textShader.bufferData(0, vertices);
-    textShader.bufferData(1, uvs);
     textShader.use();
     textShader.loadUniform(0, Window::getSize());
-    textShader.loadUniform(1, texture, TextureManager::TextureStorage::SYSTEM);
+    textShader.loadUniform(1, texture, store);
     textShader.loadUniform(2, color);
-    textShader.bindBuffer(0, 0, 2);
-    textShader.bindBuffer(1, 1, 2);
+    vertices.bindBuffer(0, 2);
+    uvs.bindBuffer(1, 2);
 
     glDisable(GL_DEPTH_TEST);
-    glDrawArrays(GL_TRIANGLES, 0, vertices.size());
+    glDrawArrays(GL_TRIANGLES, 0, vertices.getSize());
     glEnable(GL_DEPTH_TEST);
 
-    textShader.disableAttribs();
+    vertices.unbind(0);
+    uvs.unbind(1);
 }
 
-void Shader::drawGL(std::vector<glm::vec3>& vertices, std::vector<glm::vec2>& uvs,
-                    std::vector<unsigned short>& indices, glm::mat4 MVP, unsigned int texture) {
-    assert(vertices.size() == uvs.size());
-    assert((indices.size() % 3) == 0);
+void Shader::drawGL(ShaderBuffer& vertices, ShaderBuffer& uvs, unsigned int texture,
+                    glm::mat4 MVP, TextureManager::TextureStorage store) {
+    assert(vertices.getSize() == uvs.getSize());
+    assert((vertices.getSize() % 3) == 0);
 
-    textureShader.bufferData(0, vertices);
-    textureShader.bufferData(1, uvs);
-    textureShader.bufferData(2, indices);
     textureShader.use();
     textureShader.loadUniform(0, MVP);
-    textureShader.loadUniform(1, texture, TextureManager::TextureStorage::GAME);
-    textureShader.bindBuffer(0, 0, 3);
-    textureShader.bindBuffer(1, 1, 2);
-    textureShader.bindBuffer(2);
-    glDrawElements(GL_TRIANGLES, indices.size(), GL_UNSIGNED_SHORT, nullptr);
-    textureShader.disableAttribs();
+    textureShader.loadUniform(1, texture, store);
+    vertices.bindBuffer(0, 3);
+    uvs.bindBuffer(1, 2);
+    glDrawArrays(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, TextureManager::TextureStorage store) {
+    assert(vertices.getSize() == uvs.getSize());
+    assert((indices.getSize() % 3) == 0);
+
+    textureShader.use();
+    textureShader.loadUniform(0, MVP);
+    textureShader.loadUniform(1, texture, store);
+    vertices.bindBuffer(0, 3);
+    uvs.bindBuffer(1, 2);
+    indices.bindBuffer();
+    glDrawElements(GL_TRIANGLES, indices.getSize(), GL_UNSIGNED_SHORT, nullptr);
+    vertices.unbind(0);
+    uvs.unbind(1);
+}
+
+void Shader::drawGL(ShaderBuffer& vertices, ShaderBuffer& colors, glm::mat4 MVP, unsigned int mode) {
+    assert(vertices.getSize() == colors.getSize());
+
+    colorShader.use();
+    colorShader.loadUniform(0, MVP);
+    vertices.bindBuffer(0, 3);
+    colors.bindBuffer(1, 3);
+    glDrawArrays(mode, 0, vertices.getSize());
+    vertices.unbind(0);
+    colors.unbind(1);
 }
 
-void Shader::drawGL(std::vector<glm::vec3>& vertices, std::vector<glm::vec3>& colors,
-                    std::vector<unsigned short>& indices, glm::mat4 MVP, int mode) {
-    assert(vertices.size() == colors.size());
+void Shader::drawGL(ShaderBuffer& vertices, ShaderBuffer& colors, ShaderBuffer& indices,
+                    glm::mat4 MVP, unsigned int mode) {
+    assert(vertices.getSize() == colors.getSize());
 
-    colorShader.bufferData(0, vertices);
-    colorShader.bufferData(1, colors);
-    colorShader.bufferData(2, indices);
     colorShader.use();
     colorShader.loadUniform(0, MVP);
-    colorShader.bindBuffer(0, 0, 3);
-    colorShader.bindBuffer(1, 1, 3);
-    colorShader.bindBuffer(2);
-    glDrawElements(mode, indices.size(), GL_UNSIGNED_SHORT, nullptr);
-    colorShader.disableAttribs();
+    vertices.bindBuffer(0, 3);
+    colors.bindBuffer(1, 3);
+    indices.bindBuffer();
+    glDrawElements(mode, indices.getSize(), GL_UNSIGNED_SHORT, nullptr);
+    vertices.unbind(0);
+    colors.unbind(1);
 }
 
 // --------------------------------------