TextureManager is now completely static.

ChangeLog.md

     * Added ShaderBuffer class.
     * Level geometry now stored in GL buffers at level load.
         * Greatly improved level load times, more FPS.
+    * TextureManager is now completely static.
 
     [ 20141231 ]
     * No longer using Exceptions.

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, TextureManager::TextureStorage s);
+                            unsigned int texture, TextureStorage s);
 
     static void setDisplayViewFrustum(bool d) { displayViewFrustum = d; }
     static bool getDisplayViewFrustum() { return displayViewFrustum; }

include/TextureManager.h

     std::vector<TextureTileVertex> vertices;
 };
 
+enum class ColorMode {
+    RGB,
+    RGBA,
+    ARGB,
+    BGR,
+    BGRA
+};
+
+enum class TextureStorage {
+    GAME,
+    SYSTEM
+};
+
 /*!
  * \brief Texture registry
  */
 class TextureManager {
   public:
+    static int initialize();
+    static int initializeSplash();
+    static void shutdown();
+    static void clear();
 
-    enum class ColorMode {
-        RGB,
-        RGBA,
-        ARGB,
-        BGR,
-        BGRA
-    };
-
-    enum class TextureStorage {
-        GAME,
-        SYSTEM
-    };
-
-    TextureManager() : nextFreeTextureUnit(0) { }
-    ~TextureManager();
-
-    int initialize();
-    int initializeSplash();
-
-    void clear();
-
-    int numTextures(TextureStorage s = TextureStorage::GAME);
+    static int numTextures(TextureStorage s = TextureStorage::GAME);
 
     /*!
      * \brief Bind texture to next free texture unit.
      * \param s Place where texture is stored
      * \returns ID of GL texture unit to which this texture is bound.
      */
-    int bindTexture(unsigned int n, TextureStorage s);
+    static int bindTexture(unsigned int n, TextureStorage s);
 
     /*!
      * \brief Loads Buffer as texture
      * \param filter if the texture should be mipmap filtered
      * \returns texture ID or < 0 on error
      */
-    int loadBufferSlot(unsigned char* image = nullptr,
-                       unsigned int width = 256, unsigned int height = 256,
-                       ColorMode mode = ColorMode::RGBA, unsigned int bpp = 32,
-                       TextureStorage s = TextureStorage::GAME,
-                       int slot = -1, bool filter = true);
+    static int loadBufferSlot(unsigned char* image = nullptr,
+                              unsigned int width = 256, unsigned int height = 256,
+                              ColorMode mode = ColorMode::RGBA, unsigned int bpp = 32,
+                              TextureStorage s = TextureStorage::GAME,
+                              int slot = -1, bool filter = true);
 
-    int loadImage(std::string filename, TextureStorage s = TextureStorage::GAME, int slot = -1);
+    static int loadImage(std::string filename, TextureStorage s = TextureStorage::GAME, int slot = -1);
 
-    void addTile(TextureTile* t);
-    int numTiles();
-    TextureTile& getTile(int index);
+    static void addTile(TextureTile* t);
+    static int numTiles();
+    static TextureTile& getTile(int index);
 
-    void addAnimatedTile(int index, int tile);
-    int numAnimatedTiles();
-    int getFirstTileAnimation(int index);
-    int getNextTileAnimation(int tile);
+    static void addAnimatedTile(int index, int tile);
+    static int numAnimatedTiles();
+    static int getFirstTileAnimation(int index);
+    static int getNextTileAnimation(int tile);
 
   private:
-    std::vector<unsigned int>& getIds(TextureStorage s);
-    std::vector<int>& getUnits(TextureStorage s);
+    static std::vector<unsigned int>& getIds(TextureStorage s);
+    static 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);
+    static void bindTextureId(unsigned int n, TextureStorage s, unsigned int unit);
+    static int loadPCX(std::string filename, TextureStorage s, int slot);
 
-    std::vector<unsigned int> mTextureIdsGame;
-    std::vector<unsigned int> mTextureIdsSystem;
+    static std::vector<unsigned int> mTextureIdsGame;
+    static std::vector<unsigned int> mTextureIdsSystem;
 
-    std::vector<TextureTile*> tiles;
-    std::vector<std::vector<int>> animations;
+    static std::vector<TextureTile*> tiles;
+    static std::vector<std::vector<int>> animations;
 
-    std::vector<int> gameUnits;
-    std::vector<int> systemUnits;
-    unsigned int nextFreeTextureUnit;
+    static std::vector<int> gameUnits;
+    static std::vector<int> systemUnits;
+    static unsigned int nextFreeTextureUnit;
 };
 
-TextureManager& getTextureManager();
-
 #endif
 

include/system/Shader.h

     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);
+    void loadUniform(int uni, int texture, TextureStorage store);
 
     static int initialize();
     static void shutdown();
 
     static void drawGL(ShaderBuffer& vertices, ShaderBuffer& uvs, glm::vec4 color, unsigned int texture,
-                       TextureManager::TextureStorage store = TextureManager::TextureStorage::SYSTEM);
+                       TextureStorage store = TextureStorage::SYSTEM);
 
     static void drawGL(ShaderBuffer& vertices, ShaderBuffer& uvs, unsigned int texture, glm::mat4 MVP,
-                       TextureManager::TextureStorage store = TextureManager::TextureStorage::GAME);
+                       TextureStorage store = TextureStorage::GAME);
     static void drawGL(ShaderBuffer& vertices, ShaderBuffer& uvs, ShaderBuffer& indices,
                        unsigned int texture, glm::mat4 MVP,
-                       TextureManager::TextureStorage store = TextureManager::TextureStorage::GAME);
+                       TextureStorage store = TextureStorage::GAME);
 
     static void drawGL(ShaderBuffer& vertices, ShaderBuffer& colors, glm::mat4 MVP,
                        unsigned int mode = GL_TRIANGLES);

include/utils/pcx.h

  */
 int pcxLoad(const char* filename, unsigned char** image,
             unsigned int* width, unsigned int* height,
-            TextureManager::ColorMode* mode, unsigned int* bpp);
+            ColorMode* mode, unsigned int* bpp);
 
 #endif
 

src/Game.cpp

     Camera::reset();
     Render::clearRoomList();
     SoundManager::clear();
-    getTextureManager().clear();
+    TextureManager::clear();
     getWorld().destroy();
 }
 

src/MenuFolder.cpp

     // Draw half-transparent overlay
     glm::vec4 color(0.0f, 0.0f, 0.0f, 0.75f);
     Render::drawTexture(0.0f, 0.0f, Window::getSize().x, Window::getSize().y,
-                        color, TEXTURE_WHITE, TextureManager::TextureStorage::SYSTEM);
+                        color, TEXTURE_WHITE, TextureStorage::SYSTEM);
 
     // Draw heading
     Font::drawTextCentered(0, 10, 1.2f, BLUE, Window::getSize().x, VERSION);

src/Mesh.cpp

 
     int vertIndex = 0;
     for (int i = 0; i < indicesBuff.size(); i++) {
-        unsigned int texture = getTextureManager().getTile(texturesBuff.at(i)).getTexture();
+        unsigned int texture = TextureManager::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));
+            uvBuff.push_back(TextureManager::getTile(texturesBuff.at(i)).getUV(v));
             tex.push_back(texture);
         }
 

src/Render.cpp

     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, TextureManager::TextureStorage::SYSTEM);
+                    color, TEXTURE_SPLASH, TextureStorage::SYSTEM);
         return;
     }
 
 }
 
 void Render::drawTexture(float x, float y, float w, float h, glm::vec4 color,
-                         unsigned int texture, TextureManager::TextureStorage s) {
+                         unsigned int texture, TextureStorage s) {
     std::vector<glm::vec2> vertices;
     std::vector<glm::vec2> uvs;
 

src/RoomMesh.cpp

 
     int vertIndex = 0;
     for (int i = 0; i < indicesBuff.size(); i++) {
-        unsigned int texture = getTextureManager().getTile(texturesBuff.at(i)).getTexture();
+        unsigned int texture = TextureManager::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));
+            uvBuff.push_back(TextureManager::getTile(texturesBuff.at(i)).getUV(v));
             tex.push_back(texture);
         }
 

src/TextureManager.cpp

 #include "utils/strings.h"
 #include "TextureManager.h"
 
-glm::vec2 TextureTile::getUV(unsigned int i) {
-    glm::vec2 uv(vertices.at(i).xPixel,
-                 vertices.at(i).yPixel);
-
-    /*! \fixme
-     * This is my somewhat hacky approach to fixing
-     * the bad texture-bleeding problems everywhere.
-     * That's better, but makes the seams between
-     * each sector much more visible!
-     */
-
-    if (vertices.at(i).xCoordinate == 1) {
-        uv.x += 0.375f;
-    }
-
-    if (vertices.at(i).yCoordinate == 1) {
-        uv.y += 0.375f;
-    }
-
-    return uv / 256.0f;
-}
-
-// ----------------------------------------------------------------------------
-
-TextureManager::~TextureManager() {
-    while (mTextureIdsSystem.size() > 0) {
-        unsigned int id = mTextureIdsSystem.at(mTextureIdsSystem.size() - 1);
-        glDeleteTextures(1, &id);
-        mTextureIdsSystem.pop_back();
-    }
-
-    clear();
-}
-
-void TextureManager::clear() {
-    while (mTextureIdsGame.size() > 0) {
-        unsigned int id = mTextureIdsGame.at(mTextureIdsGame.size() - 1);
-        glDeleteTextures(1, &id);
-        mTextureIdsGame.pop_back();
-    }
-
-    while (!tiles.empty()) {
-        delete tiles.at(tiles.size() - 1);
-        tiles.pop_back();
-    }
-
-    animations.clear();
-
-    gameUnits.clear();
-    systemUnits.clear();
-    nextFreeTextureUnit = 0;
-}
-
-void TextureManager::addTile(TextureTile* t) {
-    tiles.push_back(t);
-}
-
-int TextureManager::numTiles() {
-    return tiles.size();
-}
-
-TextureTile& TextureManager::getTile(int index) {
-    assert(index >= 0);
-    assert(index < tiles.size());
-    return *tiles.at(index);
-}
-
-void TextureManager::addAnimatedTile(int index, int tile) {
-    while (index >= animations.size())
-        animations.push_back(std::vector<int>());
-
-    animations.at(index).push_back(tile);
-}
-
-int TextureManager::numAnimatedTiles() {
-    return animations.size();
-}
-
-int TextureManager::getFirstTileAnimation(int index) {
-    assert(index < animations.size());
-    assert(animations.at(index).size() > 0);
-    return animations.at(index).at(0);
-}
-
-int TextureManager::getNextTileAnimation(int tile) {
-    for (int a = 0; a < animations.size(); a++) {
-        for (int i = 0; i < animations.at(a).size(); i++) {
-            if (animations.at(a).at(i) == tile) {
-                if (i < (animations.at(a).size() - 1))
-                    return animations.at(a).at(i + 1);
-                else
-                    return animations.at(a).at(0);
-            }
-        }
-    }
-    return -1;
-}
-
-std::vector<unsigned int>& TextureManager::getIds(TextureStorage s) {
-    if (s == TextureStorage::GAME)
-        return mTextureIdsGame;
-    else
-        return mTextureIdsSystem;
-}
-
-std::vector<int>& TextureManager::getUnits(TextureStorage s) {
-    if (s == TextureStorage::GAME)
-        return gameUnits;
-    else
-        return systemUnits;
-}
+std::vector<unsigned int> TextureManager::mTextureIdsGame;
+std::vector<unsigned int> TextureManager::mTextureIdsSystem;
+std::vector<TextureTile*> TextureManager::tiles;
+std::vector<std::vector<int>> TextureManager::animations;
+std::vector<int> TextureManager::gameUnits;
+std::vector<int> TextureManager::systemUnits;
+unsigned int TextureManager::nextFreeTextureUnit = 0;
 
 int TextureManager::initialize() {
     assert(mTextureIdsGame.size() == 0);
     return 0;
 }
 
+void TextureManager::shutdown() {
+    while (mTextureIdsSystem.size() > 0) {
+        unsigned int id = mTextureIdsSystem.at(mTextureIdsSystem.size() - 1);
+        glDeleteTextures(1, &id);
+        mTextureIdsSystem.pop_back();
+    }
+
+    clear();
+}
+
+void TextureManager::clear() {
+    while (mTextureIdsGame.size() > 0) {
+        unsigned int id = mTextureIdsGame.at(mTextureIdsGame.size() - 1);
+        glDeleteTextures(1, &id);
+        mTextureIdsGame.pop_back();
+    }
+
+    while (!tiles.empty()) {
+        delete tiles.at(tiles.size() - 1);
+        tiles.pop_back();
+    }
+
+    animations.clear();
+
+    gameUnits.clear();
+    systemUnits.clear();
+    nextFreeTextureUnit = 0;
+}
+
 int TextureManager::loadBufferSlot(unsigned char* image,
                                    unsigned int width, unsigned int height,
                                    ColorMode mode, unsigned int bpp,
     }
 }
 
+void TextureManager::addTile(TextureTile* t) {
+    tiles.push_back(t);
+}
+
+int TextureManager::numTiles() {
+    return tiles.size();
+}
+
+TextureTile& TextureManager::getTile(int index) {
+    assert(index >= 0);
+    assert(index < tiles.size());
+    return *tiles.at(index);
+}
+
+void TextureManager::addAnimatedTile(int index, int tile) {
+    while (index >= animations.size())
+        animations.push_back(std::vector<int>());
+
+    animations.at(index).push_back(tile);
+}
+
+int TextureManager::numAnimatedTiles() {
+    return animations.size();
+}
+
+int TextureManager::getFirstTileAnimation(int index) {
+    assert(index < animations.size());
+    assert(animations.at(index).size() > 0);
+    return animations.at(index).at(0);
+}
+
+int TextureManager::getNextTileAnimation(int tile) {
+    for (int a = 0; a < animations.size(); a++) {
+        for (int i = 0; i < animations.at(a).size(); i++) {
+            if (animations.at(a).at(i) == tile) {
+                if (i < (animations.at(a).size() - 1))
+                    return animations.at(a).at(i + 1);
+                else
+                    return animations.at(a).at(0);
+            }
+        }
+    }
+    return -1;
+}
+
 int TextureManager::loadImage(std::string filename, TextureStorage s, int slot) {
     if (stringEndsWith(filename, ".pcx")) {
         return loadPCX(filename, s, slot);
     return -4;
 }
 
+std::vector<unsigned int>& TextureManager::getIds(TextureStorage s) {
+    if (s == TextureStorage::GAME)
+        return mTextureIdsGame;
+    else
+        return mTextureIdsSystem;
+}
+
+std::vector<int>& TextureManager::getUnits(TextureStorage s) {
+    if (s == TextureStorage::GAME)
+        return gameUnits;
+    else
+        return systemUnits;
+}
+
+// ----------------------------------------------------------------------------
+
+glm::vec2 TextureTile::getUV(unsigned int i) {
+    glm::vec2 uv(vertices.at(i).xPixel,
+                 vertices.at(i).yPixel);
+
+    /*! \fixme
+     * This is my somewhat hacky approach to fixing
+     * the bad texture-bleeding problems everywhere.
+     * That's better, but makes the seams between
+     * each sector much more visible!
+     */
+
+    if (vertices.at(i).xCoordinate == 1) {
+        uv.x += 0.375f;
+    }
+
+    if (vertices.at(i).yCoordinate == 1) {
+        uv.y += 0.375f;
+    }
+
+    return uv / 256.0f;
+}
+

src/UI.cpp

     void* tex_data = stbi_load_from_memory((const unsigned char*)png_data,
                                            (int)png_size, &tex_x, &tex_y, &tex_comp, 0);
 
-    fontTex = getTextureManager().loadBufferSlot((unsigned char*)tex_data,
-              tex_x, tex_y, TextureManager::ColorMode::RGBA, 32,
-              TextureManager::TextureStorage::SYSTEM, -1, false);
+    fontTex = TextureManager::loadBufferSlot((unsigned char*)tex_data,
+                                             tex_x, tex_y, ColorMode::RGBA, 32,
+                                             TextureStorage::SYSTEM, -1, false);
 
     stbi_image_free(tex_data);
 
             static bool game = getGame().isLoaded();
             static int index = 0;
             ImGui::PushItemWidth(ImGui::GetWindowWidth() * 0.5f);
-            ImGui::SliderInt("##texslide", &index, 0, getTextureManager().numTextures(
-                                 game ? TextureManager::TextureStorage::GAME
-                                 : TextureManager::TextureStorage::SYSTEM) - 1);
+            ImGui::SliderInt("##texslide", &index, 0, TextureManager::.numTextures(
+                                 game ? TextureStorage::GAME : TextureStorage::SYSTEM) - 1);
             ImGui::PopItemWidth();
             ImGui::SameLine();
             if (ImGui::Button("+##texplus", ImVec2(0, 0), true)) {
-                if (index < (getTextureManager().numTextures(
-                                 game ? TextureManager::TextureStorage::GAME
-                                 : TextureManager::TextureStorage::SYSTEM) - 1))
+                if (index < (TextureManager::numTextures(
+                                 game ? TextureStorage::GAME : TextureStorage::SYSTEM) - 1))
                     index++;
                 else
                     index = 0;
                 if (index > 0)
                     index--;
                 else
-                    index = getTextureManager().numTextures(
-                                game ? TextureManager::TextureStorage::GAME
-                                : TextureManager::TextureStorage::SYSTEM) - 1;
+                    index = TextureManager::numTextures(
+                                game ? TextureStorage::GAME : TextureStorage::SYSTEM) - 1;
             }
             ImGui::SameLine();
-            if ((getTextureManager().numTextures() > 0)) {
+            if ((TextureManager::numTextures() > 0)) {
                 ImGui::Checkbox("Game##texgame", &game);
             } else {
                 game = false;
             }
             if (visibleTex) {
                 getRender().debugDisplayTexture(index,
-                                                game ? TextureManager::TextureStorage::GAME
-                                                : TextureManager::TextureStorage::SYSTEM,
+                                                game ? TextureStorage::GAME : TextureStorage::SYSTEM,
                                                 ImGui::GetWindowPos().x - ImGui::GetWindowWidth(),
                                                 ImGui::GetWindowPos().y,
                                                 ImGui::GetWindowWidth(), ImGui::GetWindowWidth());
         }
 
         if (ImGui::CollapsingHeader("Textile Viewer")) {
-            if (getTextureManager().numTiles() > 0) {
+            if (TextureManager::numTiles() > 0) {
                 static int index = 0;
                 ImGui::PushItemWidth(ImGui::GetWindowWidth() * 0.5f);
-                ImGui::SliderInt("##tileslide", &index, 0, getTextureManager().numTiles() - 1);
+                ImGui::SliderInt("##tileslide", &index, 0, TextureManager::numTiles() - 1);
                 ImGui::PopItemWidth();
                 ImGui::SameLine();
                 if (ImGui::Button("+##tileplus", ImVec2(0, 0), true)) {
-                    if (index < (getTextureManager().numTiles() - 1))
+                    if (index < (TextureManager::numTiles() - 1))
                         index++;
                     else
                         index = 0;
                     if (index > 0)
                         index--;
                     else
-                        index = getTextureManager().numTiles() - 1;
+                        index = TextureManager::numTiles() - 1;
                 }
                 ImGui::SameLine();
                 if (ImGui::Button("Show##tileshow")) {
                     getRender().debugDisplayTextile();
                     visibleTile = false;
                 }
-                if (visibleTile && (index < getTextureManager().numTiles())) {
-                    ImGui::Text(getTextureManager().getTile(index).isTriangle() ? "Triangle" : "Rectangle");
+                if (visibleTile && (index < TextureManager::numTiles())) {
+                    ImGui::Text(TextureManager::.getTile(index).isTriangle() ? "Triangle" : "Rectangle");
                 }
                 if (visibleTile) {
                     getRender().debugDisplayTextile(index,
         }
 
         if (ImGui::CollapsingHeader("Animated Textile Viewer")) {
-            if (getTextureManager().numAnimatedTiles() > 0) {
+            if (TextureManager::.numAnimatedTiles() > 0) {
                 static int index = 0;
-                static int tile = getTextureManager().getFirstTileAnimation(index);
+                static int tile = TextureManager::.getFirstTileAnimation(index);
                 ImGui::PushItemWidth(ImGui::GetWindowWidth() * 0.5f);
-                if (ImGui::SliderInt("##animslide", &index, 0, getTextureManager().numAnimatedTiles() - 1)) {
-                    tile = getTextureManager().getFirstTileAnimation(index);
+                if (ImGui::SliderInt("##animslide", &index, 0, TextureManager::.numAnimatedTiles() - 1)) {
+                    tile = TextureManager::.getFirstTileAnimation(index);
                 }
                 ImGui::PopItemWidth();
                 ImGui::SameLine();
                 if (ImGui::Button("+##animplus", ImVec2(0, 0), true)) {
-                    if (index < (getTextureManager().numAnimatedTiles() - 1))
+                    if (index < (TextureManager::.numAnimatedTiles() - 1))
                         index++;
                     else
                         index = 0;
-                    tile = getTextureManager().getFirstTileAnimation(index);
+                    tile = TextureManager::.getFirstTileAnimation(index);
                 }
                 ImGui::SameLine();
                 if (ImGui::Button("-##animminus", ImVec2(0, 0), true)) {
                     if (index > 0)
                         index--;
                     else
-                        index = getTextureManager().numAnimatedTiles() - 1;
-                    tile = getTextureManager().getFirstTileAnimation(index);
+                        index = TextureManager::.numAnimatedTiles() - 1;
+                    tile = TextureManager::.getFirstTileAnimation(index);
                 }
                 ImGui::SameLine();
                 if (ImGui::Button("Show##animshow")) {
                                                         ImGui::GetWindowPos().y,
                                                         (ImGui::GetWindowWidth() / 2), (ImGui::GetWindowWidth() / 2));
                         fr = RunTime::getFPS() / 2;
-                        tile = getTextureManager().getNextTileAnimation(tile);
+                        tile = TextureManager::.getNextTileAnimation(tile);
                     }
                     ImGui::Text("Current Tile: %d", tile);
                 }
 
     imguiShader.use();
     imguiShader.loadUniform(0, Window::getSize());
-    imguiShader.loadUniform(1, fontTex, TextureManager::TextureStorage::SYSTEM);
+    imguiShader.loadUniform(1, fontTex, TextureStorage::SYSTEM);
     vert.bindBuffer(0, 2);
     uv.bindBuffer(1, 2);
     col.bindBuffer(2, 4);

src/loader/LoaderTR2.cpp

 
         // Convert 16bit textile to 32bit textile
         unsigned char* img = argb16to32(&arr[0], 256, 256);
-        int r = getTextureManager().loadBufferSlot(img, 256, 256,
-                TextureManager::ColorMode::ARGB, 32,
-                TextureManager::TextureStorage::GAME, i);
+        int r = TextureManager::loadBufferSlot(img, 256, 256,
+                                               ColorMode::ARGB, 32,
+                                               TextureStorage::GAME, i);
         assert(r >= 0); //! \fixme properly handle error when texture could not be loaded!
         delete [] img;
     }
             t->add(TextureTileVertex(xCoordinate, xPixel, yCoordinate, yPixel));
         }
 
-        getTextureManager().addTile(t);
+        TextureManager::addTile(t);
     }
 
     if (numObjectTextures > 0)
         }
 
         for (int i = 0; i < count; i++) {
-            getTextureManager().addAnimatedTile(a, animatedTextures.at(pos + i + 1));
+            TextureManager::addAnimatedTile(a, animatedTextures.at(pos + i + 1));
         }
 
         pos += count + 1;

src/main.cpp

 static std::shared_ptr<Game> gGame;
 static std::shared_ptr<Log> gLog;
 static std::shared_ptr<MenuFolder> gMenu;
-static std::shared_ptr<TextureManager> gTextureManager;
 static std::shared_ptr<World> gWorld;
 
 Game& getGame() {
     return *gMenu;
 }
 
-TextureManager& getTextureManager() {
-    return *gTextureManager;
-}
-
 World& getWorld() {
     return *gWorld;
 }
     gGame.reset(new Game());
     gLog.reset(new Log());
     gMenu.reset(new MenuFolder());
-    gTextureManager.reset(new TextureManager());
     gWorld.reset(new World());
 
     Command::fillCommandList();
     }
 
     // Initialize Texture Manager
-    error = getTextureManager().initialize();
+    error = TextureManager::initialize();
     if (error != 0) {
         std::cout << "Could not initialize TextureManager (" << error << ")!" << std::endl;
         return -3;
         Command::executeFile(configFileToUse);
     }
 
-    error = getTextureManager().initializeSplash();
+    error = TextureManager::initializeSplash();
     if (error != 0) {
         std::cout << "Coult not load Splash Texture (" << error << ")!" << std::endl;
         return -4;

src/system/FontSDL.cpp

         }
 
         // Reserve slot
-        mFontTexture = getTextureManager().loadBufferSlot(nullptr, 256, 256,
-                       TextureManager::ColorMode::RGBA, 32, TextureManager::TextureStorage::SYSTEM);
+        mFontTexture = TextureManager::loadBufferSlot(nullptr, 256, 256,
+                                                      ColorMode::RGBA, 32,
+                                                      TextureStorage::SYSTEM);
 
         mFontInit = true;
     }
     int w = (int)((float)surface->w * scale);
     int h = (int)((float)surface->h * scale);
 
-    TextureManager::ColorMode textureFormat;
+    ColorMode textureFormat;
     unsigned int bpp = 0;
     if (surface->format->BytesPerPixel == 4) {
         if (surface->format->Rmask == 0x000000FF)
-            textureFormat = TextureManager::ColorMode::RGBA;
+            textureFormat = ColorMode::RGBA;
         else
-            textureFormat = TextureManager::ColorMode::BGRA;
+            textureFormat = ColorMode::BGRA;
         bpp = 32;
     } else {
         if (surface->format->Rmask == 0x000000FF)
-            textureFormat = TextureManager::ColorMode::RGB;
+            textureFormat = ColorMode::RGB;
         else
-            textureFormat = TextureManager::ColorMode::BGR;
+            textureFormat = ColorMode::BGR;
         bpp = 24;
     }
 
-    getTextureManager().loadBufferSlot(static_cast<unsigned char*>(surface->pixels),
-                                       surface->w, surface->h, textureFormat, bpp,
-                                       TextureManager::TextureStorage::SYSTEM, mFontTexture);
+    TextureManager::loadBufferSlot(static_cast<unsigned char*>(surface->pixels),
+                                   surface->w, surface->h, textureFormat, bpp,
+                                   TextureStorage::SYSTEM, mFontTexture);
     SDL_FreeSurface(surface);
 
     std::vector<glm::vec2> vertices;
     vertexBuffer.bufferData(vertices);
     uvBuffer.bufferData(uvs);
     Shader::drawGL(vertexBuffer, uvBuffer, glm::vec4(1.0f, 1.0f, 1.0f, 1.0f),
-                   mFontTexture, TextureManager::TextureStorage::SYSTEM);
+                   mFontTexture, TextureStorage::SYSTEM);
 }
 
 unsigned int FontSDL::heightText(float scale, unsigned int maxWidth, std::string s) {
     int w = (int)((float)surface->w * scale);
     int h = (int)((float)surface->h * scale);
 
-    TextureManager::ColorMode textureFormat;
+    ColorMode textureFormat;
     unsigned int bpp = 0;
     if (surface->format->BytesPerPixel == 4) {
         if (surface->format->Rmask == 0x000000FF)
-            textureFormat = TextureManager::ColorMode::RGBA;
+            textureFormat = ColorMode::RGBA;
         else
-            textureFormat = TextureManager::ColorMode::BGRA;
+            textureFormat = ColorMode::BGRA;
         bpp = 32;
     } else {
         if (surface->format->Rmask == 0x000000FF)
-            textureFormat = TextureManager::ColorMode::RGB;
+            textureFormat = ColorMode::RGB;
         else
-            textureFormat = TextureManager::ColorMode::BGR;
+            textureFormat = ColorMode::BGR;
         bpp = 24;
     }
 
-    getTextureManager().loadBufferSlot(static_cast<unsigned char*>(surface->pixels),
-                                       surface->w, surface->h, textureFormat, bpp,
-                                       TextureManager::TextureStorage::SYSTEM, mFontTexture);
+    TextureManager::loadBufferSlot(static_cast<unsigned char*>(surface->pixels),
+                                   surface->w, surface->h, textureFormat, bpp,
+                                   TextureStorage::SYSTEM, mFontTexture);
     SDL_FreeSurface(surface);
 
     std::vector<glm::vec2> vertices;
     vertexBuffer.bufferData(vertices);
     uvBuffer.bufferData(uvs);
     Shader::drawGL(vertexBuffer, uvBuffer, glm::vec4(1.0f, 1.0f, 1.0f, 1.0f),
-                   mFontTexture, TextureManager::TextureStorage::SYSTEM);
+                   mFontTexture, TextureStorage::SYSTEM);
 }
 

src/system/FontTRLE.cpp

         pixels[i] = pixels[i + 1] = pixels[i + 2] = (unsigned char)y;
     }
 
-    mFontTexture = getTextureManager().loadBufferSlot(pixels, 256, 256,
-                   TextureManager::ColorMode::BGRA, 32, TextureManager::TextureStorage::SYSTEM);
+    mFontTexture = TextureManager::loadBufferSlot(pixels, 256, 256,
+                                                  ColorMode::BGRA, 32,
+                                                  TextureStorage::SYSTEM);
     delete [] pixels;
 
     // Try to load .lps file or use default glyph positions

src/system/Shader.cpp

 
 #include "global.h"
 #include "Log.h"
-#include "TextureManager.h"
 #include "system/Window.h"
 #include "system/Shader.h"
 
     glUniformMatrix4fv(getUniform(uni), 1, GL_FALSE, &mat[0][0]);
 }
 
-void Shader::loadUniform(int uni, int texture, TextureManager::TextureStorage store) {
-    glUniform1i(getUniform(uni), getTextureManager().bindTexture(texture, store));
+void Shader::loadUniform(int uni, int texture, TextureStorage store) {
+    glUniform1i(getUniform(uni), TextureManager::bindTexture(texture, store));
 }
 
 void Shader::use() {
 }
 
 void Shader::drawGL(ShaderBuffer& vertices, ShaderBuffer& uvs, glm::vec4 color,
-                    unsigned int texture, TextureManager::TextureStorage store) {
+                    unsigned int texture, TextureStorage store) {
     assert(vertices.getSize() == uvs.getSize());
     assert((vertices.getSize() % 3) == 0);
 
 }
 
 void Shader::drawGL(ShaderBuffer& vertices, ShaderBuffer& uvs, unsigned int texture,
-                    glm::mat4 MVP, TextureManager::TextureStorage store) {
+                    glm::mat4 MVP, TextureStorage store) {
     assert(vertices.getSize() == uvs.getSize());
     assert((vertices.getSize() % 3) == 0);
 
 }
 
 void Shader::drawGL(ShaderBuffer& vertices, ShaderBuffer& uvs, ShaderBuffer& indices,
-                    unsigned int texture, glm::mat4 MVP, TextureManager::TextureStorage store) {
+                    unsigned int texture, glm::mat4 MVP, TextureStorage store) {
     assert(vertices.getSize() == uvs.getSize());
     assert((indices.getSize() % 3) == 0);
 

src/utils/pcx.cpp

 
 int pcxLoad(const char* filename, unsigned char** image,
             unsigned int* width, unsigned int* height,
-            TextureManager::ColorMode* mode, unsigned int* bpp) {
+            ColorMode* mode, unsigned int* bpp) {
     assert(filename != nullptr);
     assert(filename[0] != '\0');
     assert(image != nullptr);
         }
     }
 
-    *mode = TextureManager::ColorMode::RGBA;
+    *mode = ColorMode::RGBA;
     *bpp = 32;
 
     delete [] buffer;