Back face culling, log levels, clipboard support.

ChangeLog.md

 
 ## OpenRaider (0.1.3) xythobuz <xythobuz@xythobuz.de>
 
+    [ 20140111 ]
+    * Enabled back face culling --> triangles now oriented correctly
+    * Game is now completely static
+    * Shaders drawGL methods can now be given a specific Shader instance.
+    * Log now manages different log levels. Console displays them colored.
+    * Console can now log to the TTY, the clipboard or a file.
+    * Added system clipboard support for imgui in both WindowSDL and WindowGLFW.
+
     [ 20140109 ]
     * Display of Bounding Boxes can be individually toggled for Rooms/StaticMeshes
     * Tightened imgui Style and changed colors to match the _OpenRaider-blue_

cmake/Doxyfile.in

 # Note that relative paths are relative to the directory from which doxygen is
 # run.
 
-EXCLUDE                = ../bin ../build ../cmake ../data ../test/greatest.h
+EXCLUDE                = ../bin ../build ../cmake ../data ../src/deps
 
 # The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
 # directories that are symbolic links (a Unix file system feature) are excluded

include/Game.h

 
 class Game {
   public:
-    Game();
+    static void destroy();
 
-    int initialize();
-    void destroy();
+    static bool isLoaded() { return mLoaded; }
+    static int loadLevel(const char* level);
 
-    bool isLoaded() { return mLoaded; }
-    int loadLevel(const char* level);
+    static void handleAction(ActionEvents action, bool isFinished);
+    static void handleMouseMotion(int xrel, int yrel, int xabs, int yabs);
+    static void handleControllerAxis(float value, KeyboardButton axis);
+    static void handleControllerButton(KeyboardButton button, bool released);
 
-    void display();
-    void handleAction(ActionEvents action, bool isFinished);
-    void handleMouseMotion(int xrel, int yrel, int xabs, int yabs);
-    void handleControllerAxis(float value, KeyboardButton axis);
-    void handleControllerButton(KeyboardButton button, bool released);
-
-    Entity& getLara();
-    void setLara(long lara);
+    static Entity& getLara();
+    static void setLara(long lara);
 
   private:
-    bool mLoaded;
-    long mLara;
-    bool activeEvents[ActionEventCount];
+    static bool mLoaded;
+    static long mLara;
+    static bool activeEvents[ActionEventCount];
 };
 
-Game& getGame();
-
 #endif
 

include/Log.h

 
 #include <glm/gtc/type_precision.hpp>
 
-class Log {
+#define LOG_USER    0
+#define LOG_ERROR   1
+#define LOG_WARNING 2
+#define LOG_INFO    3
+#define LOG_DEBUG   4
+#define LOG_COUNT   5
+
+struct LogEntry {
   public:
+    std::string text;
+    int level;
+    LogEntry(std::string t, int l) : text(t), level(l) { }
+};
 
+class LogLevel;
+class Log {
+  public:
     const static char endl = '\n';
 
-    Log();
+    static LogLevel& get(int level);
+    static unsigned long size() { return wholeLog.size(); }
+    static LogEntry getEntry(unsigned long i) { return wholeLog.at(i); }
 
-    unsigned long size();
-    std::string get(unsigned long i);
+  private:
+    static LogLevel logs[LOG_COUNT];
 
-    template<typename T>
-    Log& operator<< (const T t) {
-        printBuffer << t;
-        if (printBuffer.str().back() == endl) {
-            mHistory.push_back(printBuffer.str().substr(0, printBuffer.str().length() - 1));
-            std::cout << printBuffer.str().substr(0, printBuffer.str().length() - 1) << std::endl;
-            printBuffer.str("");
-        }
-        return (*this);
-    }
+    static std::vector<LogEntry> wholeLog;
+    friend class LogLevel;
+};
+
+class LogLevel {
+  public:
+    LogLevel(int l) : level(l) { printBuffer << std::boolalpha; }
 
-    Log& operator<< (const glm::vec2& v) {
+    LogLevel& operator<< (const glm::vec2& v) {
         return (*this) << v.x << " " << v.y;
     }
 
-    Log& operator<< (const glm::i32vec2& v) {
+    LogLevel& operator<< (const glm::i32vec2& v) {
         return (*this) << v.x << " " << v.y;
     }
 
-    Log& operator<< (const glm::vec3& v) {
+    LogLevel& operator<< (const glm::vec3& v) {
         return (*this) << v.x << " " << v.y << " " << v.z;
     }
 
+    template<typename T>
+    LogLevel& operator<< (const T t) {
+        printBuffer << t;
+        if (printBuffer.str().back() == Log::endl) {
+            std::string s = printBuffer.str().substr(0, printBuffer.str().length() - 1);
+            printBuffer.str("");
+            Log::wholeLog.emplace_back(s, level);
+#ifdef DEBUG
+            std::cout << s << std::endl;
+#endif
+        }
+        return (*this);
+    }
+
   private:
-    std::vector<std::string> mHistory;
+    int level;
     std::ostringstream printBuffer;
 };
 
-Log& getLog();
-
 #endif
 

include/system/Shader.h

     static int initialize();
     static void shutdown();
 
+    static void set2DState(bool on);
+
     static void drawGL(ShaderBuffer& vertices, ShaderBuffer& uvs, glm::vec4 color, unsigned int texture,
-                       TextureStorage store = TextureStorage::SYSTEM);
+                       TextureStorage store = TextureStorage::SYSTEM, Shader& shader = textShader);
 
     static void drawGL(ShaderBuffer& vertices, ShaderBuffer& uvs, unsigned int texture, glm::mat4 MVP,
-                       TextureStorage store = TextureStorage::GAME);
+                       TextureStorage store = TextureStorage::GAME, Shader& shader = textureShader);
     static void drawGL(ShaderBuffer& vertices, ShaderBuffer& uvs, ShaderBuffer& indices,
                        unsigned int texture, glm::mat4 MVP,
-                       TextureStorage store = TextureStorage::GAME);
+                       TextureStorage store = TextureStorage::GAME, Shader& shader = textureShader);
 
     static void drawGL(ShaderBuffer& vertices, ShaderBuffer& colors, glm::mat4 MVP,
-                       unsigned int mode = GL_TRIANGLES);
+                       unsigned int mode = GL_TRIANGLES, Shader& shader = colorShader);
     static void drawGL(ShaderBuffer& vertices, ShaderBuffer& colors, ShaderBuffer& indices,
-                       glm::mat4 MVP, unsigned int mode = GL_TRIANGLES);
+                       glm::mat4 MVP, unsigned int mode = GL_TRIANGLES, Shader& shader = colorShader);
 
   private:
     int programID;

include/system/Window.h

 
     static void setTextInput(bool t);
     static bool getTextInput();
+
+    static void setClipboard(const char* s);
+    static const char* getClipboard();
 };
 
 #endif

include/system/WindowGLFW.h

     static void setTextInput(bool t);
     static bool getTextInput() { return textinput; }
 
+    static void setClipboard(const char* s);
+    static const char* getClipboard();
+
   private:
     static void errorCallback(int error, const char* desc);
     static void sizeCallback(GLFWwindow* w, int width, int height);

include/system/WindowSDL.h

     static void setTextInput(bool t);
     static bool getTextInput() { return textinput; }
 
+    static void setClipboard(const char* s);
+    static const char* getClipboard();
+
   private:
     static glm::i32vec2 size;
     static bool fullscreen;

src/Console.cpp

 
     static bool scrollToBottom = false;
     if (ImGui::Begin("Console", &visible, ImVec2(600, 400))) {
-        if (lastLogLength != getLog().size()) {
-            lastLogLength = getLog().size();
+        if (lastLogLength != Log::size()) {
+            lastLogLength = Log::size();
             scrollToBottom = true;
         }
 
+        static bool visibleLogs[LOG_COUNT] = { true, true, true, true, false };
+        ImGui::Checkbox("Error##log", &visibleLogs[1]);
+        ImGui::SameLine();
+        ImGui::Checkbox("Warning##log", &visibleLogs[2]);
+        ImGui::SameLine();
+        ImGui::Checkbox("User##log", &visibleLogs[0]);
+        ImGui::SameLine();
+        ImGui::Checkbox("Info##log", &visibleLogs[3]);
+        ImGui::SameLine();
+        ImGui::Checkbox("Debug##log", &visibleLogs[4]);
+        ImGui::SameLine();
+        static bool logToTTY = false, logToClipboard = false, logToFile = false;
+        if (ImGui::Button("Log to TTY")) { logToTTY = true; }
+        ImGui::SameLine();
+        if (ImGui::Button("Log to Clipboard")) { logToClipboard = true; }
+        ImGui::SameLine();
+        if (ImGui::Button("Log to File")) { logToFile = true; }
+        ImGui::Separator();
+
         ImGui::BeginChild("ConsoleText", ImVec2(0, -ImGui::GetTextLineSpacing() * 2));
-        for (unsigned long i = 0; i < getLog().size(); i++) {
-            ImGui::TextUnformatted(getLog().get(i).c_str());
+        if (logToTTY)
+            ImGui::LogToTTY();
+        else if (logToClipboard)
+            ImGui::LogToClipboard();
+        else if (logToFile)
+            ImGui::LogToFile();
+        for (unsigned long i = 0; i < Log::size(); i++) {
+            auto entry = Log::getEntry(i);
+
+            assert(entry.level < LOG_COUNT);
+            if (!visibleLogs[entry.level]) {
+                continue;
+            }
+
+            ImVec4 col(1.0f, 1.0f, 1.0f, 1.0f);
+            if (entry.level == LOG_ERROR) {
+                col = ImVec4(1.0f, 0.0f, 0.0f, 1.0f);
+            } else if (entry.level == LOG_WARNING) {
+                col = ImVec4(1.0f, 1.0f, 0.0f, 1.0f);
+            } else if (entry.level == LOG_DEBUG) {
+                col = ImVec4(0.0f, 1.0f, 0.0f, 1.0f);
+            } else if (entry.level == LOG_USER) {
+                col = ImVec4(0.5f, 0.75f, 1.0f, 1.0f);
+            }
+
+            ImGui::PushStyleColor(ImGuiCol_Text, col);
+            ImGui::TextUnformatted(entry.text.c_str());
+            ImGui::PopStyleColor();
+        }
+        if (logToTTY || logToClipboard || logToFile) {
+            ImGui::LogFinish();
+            logToTTY = logToClipboard = logToFile = false;
         }
         if (scrollToBottom) {
             ImGui::SetScrollPosHere();
                              | ImGuiInputTextFlags_CallbackCompletion
                              | ImGuiInputTextFlags_CallbackHistory,
                              &Console::callback)) {
-            getLog() << "> " << buffer << Log::endl;
+            Log::get(LOG_USER) << "> " << buffer << Log::endl;
             if (strlen(buffer) > 0) {
                 int error = Command::command(buffer);
                 if (error != 0) {
-                    getLog() << "Error code: " << error << Log::endl;
+                    Log::get(LOG_USER) << "Error code: " << error << Log::endl;
                 }
 
                 if ((lastCommands.size() == 0) || (lastCommands[lastCommands.size() - 1] != buffer))

src/Entity.cpp

 }
 
 void Entity::print() {
-    getLog() << "Entity " << objectId << ":" << Log::endl
+    Log::get(LOG_INFO) << "Entity " << objectId << ":" << Log::endl
              << "  Room " << room << " (" << getWorld().getRoom(room).getFlags()
              << ")" << Log::endl
              << "  " << pos[0] << "x " << pos[1] << "y " << pos[2] << "z"

src/Game.cpp

 
 #include "global.h"
 #include "Camera.h"
+#include "Console.h"
 #include "Game.h"
 #include "loader/Loader.h"
 #include "Log.h"
 #include "UI.h"
 #include "World.h"
 
-Game::Game() {
+bool Game::mLoaded = false;
+long Game::mLara = -1;
+bool Game::activeEvents[ActionEventCount];
+
+void Game::destroy() {
     mLoaded = false;
     mLara = -1;
 
     for (int i = 0; i < ActionEventCount; i++) {
         activeEvents[i] = false;
     }
-}
 
-int Game::initialize() {
-    // Enable Renderer
     Render::setMode(RenderMode::LoadScreen);
-
-    return 0;
-}
-
-void Game::display() {
-    Render::display();
-}
-
-void Game::destroy() {
-    mLoaded = false;
-    mLara = -1;
-    Render::setMode(RenderMode::LoadScreen);
-
     Camera::reset();
     Render::clearRoomList();
     SoundManager::clear();
 
 int Game::loadLevel(const char* level) {
     destroy();
-    getLog() << "Loading " << level << Log::endl;
+
+    Log::get(LOG_INFO) << "Loading " << level << Log::endl;
     auto loader = Loader::createLoader(level);
     if (loader) {
         int error = loader->load(level);
         if (error != 0) {
-            getLog() << "Error loading level (" << error << ")..." << Log::endl;
+            Log::get(LOG_ERROR) << "Error loading level (" << error << ")..." << Log::endl;
             destroy();
             return -2;
         }
 
         SoundManager::prepareSources();
 
+        mLoaded = true;
+        Render::setMode(RenderMode::Texture);
+
         if (mLara == -1) {
-            getLog() << "Can't find Lara entity in level?!" << Log::endl;
+            Log::get(LOG_WARNING) << "Can't find Lara entity in level?!" << Log::endl;
+            Console::setVisible(true);
             UI::setVisible(true);
         } else {
-            mLoaded = true;
-            Render::setMode(RenderMode::Texture);
-
             Camera::setPosition(glm::vec3(getLara().getPos(0),
                                           getLara().getPos(1) - 1024.0f,
                                           getLara().getPos(2)));
         }
     } else {
-        getLog() << "No suitable loader for this level!" << Log::endl;
+        Log::get(LOG_ERROR) << "No suitable loader for this level!" << Log::endl;
         return -1;
     }
 

src/Log.cpp

 #include "global.h"
 #include "Log.h"
 
-Log::Log() {
-    printBuffer << std::boolalpha;
-}
-
-unsigned long Log::size() {
-    return mHistory.size();
-}
+LogLevel Log::logs[LOG_COUNT] = { 0, 1, 2, 3, 4 };
+std::vector<LogEntry> Log::wholeLog;
 
-std::string Log::get(unsigned long i) {
-    assert(i < mHistory.size());
-    return mHistory.at(i);
+LogLevel& Log::get(int level) {
+    assert(level >= 0);
+    assert(level < LOG_COUNT);
+    return logs[level];
 }
 

src/Menu.cpp

     dialogState = false;
     dialogFunction = callback;
 
-    getLog() << dialogText << Log::endl;
+    Log::get(LOG_USER) << dialogText << Log::endl;
 }
 
 void Menu::ackDialog() {

src/MenuFolder.cpp

             // Check maps for validity
             Loader::LoaderVersion version = Loader::checkFile(f.getPath());
             if (version == Loader::TR_UNKNOWN) {
-                getLog() << "Error: pak file '" << f.getName().c_str()
+                Log::get(LOG_ERROR) << "Error: pak file '" << f.getName().c_str()
                          << "' invalid" << Log::endl;
                 return true; // delete file from list
             }
             showDialog("Error reading subfolder!", "OK", "");
         }
     } else {
-        int error = getGame().loadLevel(mapFolder->getFile((unsigned long)mCursor
+        int error = Game::loadLevel(mapFolder->getFile((unsigned long)mCursor
                                         - 1 - mapFolder->folderCount()).getPath().c_str());
         if (error == 0) {
             visible = false;

src/Mesh.cpp

     int vertIndex = 0;
     for (int i = 0; i < indicesBuff.size(); i++) {
         unsigned int texture = TextureManager::getTile(texturesBuff.at(i)).getTexture();
-        for (int v = 0; v < ((indicesBuff.at(i) == 0) ? 4 : 3); v++) {
+        for (int x = 0; x < ((indicesBuff.at(i) == 0) ? 4 : 3); x++) {
+            int v = x;
+            if (v == 0)
+                v = 2;
+            else if (v == 2)
+                v = 0;
             ind.push_back(vert.size());
             vert.push_back(verticesBuff.at(vertIndex + v));
             uvBuff.push_back(TextureManager::getTile(texturesBuff.at(i)).getUV(v));
         }
 
         if (indicesBuff.at(i) == 0) {
-            ind.push_back(ind.at(ind.size() - 2));
-            ind.push_back(ind.at(ind.size() - 5));
+            ind.push_back(ind.at(ind.size() - 4));
+            ind.push_back(ind.at(ind.size() - 3));
         }
 
         vertIndex += (indicesBuff.at(i) == 0) ? 4 : 3;
 
     vertIndex = 0;
     for (int i = 0; i < indicesColorBuff.size(); i++) {
-        for (int v = 0; v < ((indicesColorBuff.at(i) == 0) ? 4 : 3); v++) {
+        for (int x = 0; x < ((indicesColorBuff.at(i) == 0) ? 4 : 3); x++) {
+            int v = x;
+            if (v == 0)
+                v = 2;
+            else if (v == 2)
+                v = 0;
             indCol.push_back(vertCol.size());
             vertCol.push_back(verticesColorBuff.at(vertIndex + v));
             cols.push_back(colorsBuff.at(i));
         }
 
         if (indicesColorBuff.at(i) == 0) {
-            indCol.push_back(indCol.at(indCol.size() - 2));
-            indCol.push_back(indCol.at(indCol.size() - 5));
+            indCol.push_back(indCol.at(indCol.size() - 4));
+            indCol.push_back(indCol.at(indCol.size() - 3));
         }
 
         vertIndex += (indicesColorBuff.at(i) == 0) ? 4 : 3;

src/Render.cpp

     }
 
     if (!stbi_write_png(f.c_str(), w, h, 3, buffer, 0)) {
-        getLog() << "Error saving image \"" << f << "\"!" << Log::endl;
+        Log::get(LOG_ERROR) << "Error saving image \"" << f << "\"!" << Log::endl;
     }
 
     delete [] image;
     std::vector<glm::vec2> uvs;
 
     vertices.push_back(glm::vec2(x, y + h));
-    vertices.push_back(glm::vec2(x, y));
     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 + w, y + h));
     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(0.0f, 0.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(1.0f, 1.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);

src/RoomMesh.cpp

     int vertIndex = 0;
     for (int i = 0; i < indicesBuff.size(); i++) {
         unsigned int texture = TextureManager::getTile(texturesBuff.at(i)).getTexture();
-        for (int v = 0; v < ((indicesBuff.at(i) == 0) ? 4 : 3); v++) {
+        for (int x = 0; x < ((indicesBuff.at(i) == 0) ? 4 : 3); x++) {
+            int v = x;
+            if (v == 0)
+                v = 2;
+            else if (v == 2)
+                v = 0;
             ind.push_back(vert.size());
             vert.push_back(verticesBuff.at(vertIndex + v));
             uvBuff.push_back(TextureManager::getTile(texturesBuff.at(i)).getUV(v));
         }
 
         if (indicesBuff.at(i) == 0) {
-            ind.push_back(ind.at(ind.size() - 2));
-            ind.push_back(ind.at(ind.size() - 5));
+            ind.push_back(ind.at(ind.size() - 4));
+            ind.push_back(ind.at(ind.size() - 3));
         }
 
         vertIndex += (indicesBuff.at(i) == 0) ? 4 : 3;

src/TextureManager.cpp

         unsigned char* data = stbi_load(filename.c_str(), &x, &y, &n, 0);
         if (data) {
             if ((n < 3) || (n > 4)) {
-                getLog() << "Image \"" << filename << "\" has unsupported format ("
+                Log::get(LOG_ERROR) << "Image \"" << filename << "\" has unsupported format ("
                          << n << ")!" << Log::endl;
                 stbi_image_free(data);
                 return -2;
             stbi_image_free(data);
             return id;
         } else {
-            getLog() << "Can't load image \"" << filename << "\"!" << Log::endl;
+            Log::get(LOG_ERROR) << "Can't load image \"" << filename << "\"!" << Log::endl;
             return -1;
         }
     }

src/UI.cpp

     io.KeyMap[ImGuiKey_Z] = zKey;
 
     io.RenderDrawListsFn = UI::renderImGui;
+    io.GetClipboardTextFn = Window::getClipboard;
+    io.SetClipboardTextFn = Window::setClipboard;
 
     // Load font texture
     //! \todo Use our own font subsystem instead of this?
         while (!motionEvents.empty()) {
             auto i = motionEvents.front();
             if (!getMenu().isVisible()) {
-                getGame().handleMouseMotion(std::get<0>(i), std::get<1>(i),
+                Game::handleMouseMotion(std::get<0>(i), std::get<1>(i),
                                             std::get<2>(i), std::get<3>(i));
             }
             motionEvents.pop_front();
             } else {
                 for (int n = forwardAction; n < ActionEventCount; n++) {
                     if (RunTime::getKeyBinding((ActionEvents)n) == std::get<0>(i))
-                        getGame().handleAction((ActionEvents)n, !std::get<1>(i));
+                        Game::handleAction((ActionEvents)n, !std::get<1>(i));
                 }
             }
         }
         static bool visibleAnim = false;
         static bool visibleSprite = false;
         if (ImGui::CollapsingHeader("Texture Viewer")) {
-            static bool game = getGame().isLoaded();
+            static bool game = Game::isLoaded();
             static int index = 0;
             ImGui::PushItemWidth(ImGui::GetWindowWidth() * 0.5f);
             ImGui::SliderInt("##texslide", &index, 0, TextureManager::.numTextures(
 }
 
 void UI::handleControllerAxis(float value, KeyboardButton axis) {
-    getGame().handleControllerAxis(value, axis);
+    Game::handleControllerAxis(value, axis);
 }
 
 void UI::handleControllerButton(KeyboardButton button, bool released) {
-    getGame().handleControllerButton(button, released);
+    Game::handleControllerButton(button, released);
 }
 
 void UI::renderImGui(ImDrawList** const cmd_lists, int cmd_lists_count) {
     static ShaderBuffer vert, uv, col;
 
     glEnable(GL_SCISSOR_TEST);
-    glDisable(GL_DEPTH_TEST);
+    Shader::set2DState(true);
 
     imguiShader.use();
     imguiShader.loadUniform(0, Window::getSize());
     uv.unbind(1);
     col.unbind(2);
 
-    glEnable(GL_DEPTH_TEST);
+    Shader::set2DState(false);
     glDisable(GL_SCISSOR_TEST);
 }
 

src/commands/Command.cpp

 }
 
 void Command::printHelp() {
-    getLog() << "No help available!" << Log::endl;
+    Log::get(LOG_USER) << "No help available!" << Log::endl;
 }
 
 void Command::fillCommandList() {
         command >> arg;
         if (arg.length() == 0) {
             // List all available commands
-            getLog() << "Available commands:" << Log::endl;
-            getLog() << std::right << std::setw(11);
-            getLog() << "help" << " - print command help" << Log::endl;
+            Log::get(LOG_USER) << "Available commands:" << Log::endl;
+            Log::get(LOG_USER) << std::right << std::setw(11);
+            Log::get(LOG_USER) << "help" << " - print command help" << Log::endl;
             for (auto& x : commands) {
                 if (x) {
-                    getLog() << std::right << std::setw(11);
-                    getLog() << x->name() << " - " << x->brief() << Log::endl;
+                    Log::get(LOG_USER) << std::right << std::setw(11);
+                    Log::get(LOG_USER) << x->name() << " - " << x->brief() << Log::endl;
                 }
             }
-            getLog() << "Use help COMMAND to get additional info" << Log::endl;
-            getLog() << "Pass BOOLs as true or false" << Log::endl;
+            Log::get(LOG_USER) << "Use help COMMAND to get additional info" << Log::endl;
+            Log::get(LOG_USER) << "Pass BOOLs as true or false" << Log::endl;
             return 0;
         } else {
             // Show help for a specific command
                     }
                 }
             }
-            getLog() << "Unknown command: \"" << arg << "\"" << Log::endl;
+            Log::get(LOG_USER) << "Unknown command: \"" << arg << "\"" << Log::endl;
             return -1;
         }
     }
         }
     }
 
-    getLog() << "Unknown command: \"" << cmd << "\"" << Log::endl;
+    Log::get(LOG_USER) << "Unknown command: \"" << cmd << "\"" << Log::endl;
     return -1;
 }
 
 int Command::executeFile(std::string file) {
     std::string configFile = expandHomeDirectory(file);
-    getLog() << "Loading config from \"" << configFile << "\"..." << Log::endl;
+    Log::get(LOG_INFO) << "Loading config from \"" << configFile << "\"..." << Log::endl;
 
     std::ifstream f(configFile);
     if (!f) {
-        getLog() << "Could not open file!" << Log::endl;
+        Log::get(LOG_ERROR) << "Could not open file!" << Log::endl;
         return -1;
     }
 
 
         int error = Command::command(line);
         if (error != 0)
-            getLog() << "Error Code: " << error << Log::endl;
+            Log::get(LOG_ERROR) << "Error Code: " << error << Log::endl;
     }
 
     f.close();
     } else {
         std::string common = candidates.at(0);
         for (int i = 0; i < candidates.size(); i++) {
-            getLog() << candidates.at(i);
+            Log::get(LOG_USER) << candidates.at(i);
             if (i < (candidates.size() - 1))
-                getLog() << "/";
+                Log::get(LOG_USER) << "/";
 
             for (int c = 0; (c < common.size()) && (c < candidates.at(i).size()); c++) {
                 if (common.at(c) != candidates.at(i).at(c)) {
                 }
             }
         }
-        getLog() << Log::endl;
+        Log::get(LOG_USER) << Log::endl;
         return common;
     }
 }

src/commands/CommandBind.cpp

 }
 
 void CommandBind::printHelp() {
-    getLog() << "bind-Command Usage:" << Log::endl;
-    getLog() << "  bind ACTION KEY" << Log::endl;
-    getLog() << "Available Actions:" << Log::endl;
-    getLog() << "  menu" << Log::endl;
-    getLog() << "  debug" << Log::endl;
-    getLog() << "  forward" << Log::endl;
-    getLog() << "  backward" << Log::endl;
-    getLog() << "  left" << Log::endl;
-    getLog() << "  right" << Log::endl;
-    getLog() << "  jump" << Log::endl;
-    getLog() << "  crouch" << Log::endl;
-    getLog() << "  use" << Log::endl;
-    getLog() << "  holster" << Log::endl;
-    getLog() << "  walk" << Log::endl;
-    getLog() << "Key-Format:" << Log::endl;
-    getLog() << "  'a' or '1'    for character/number keys" << Log::endl;
-    getLog() << "  \"leftctrl\"  for symbols and special keys" << Log::endl;
+    Log::get(LOG_USER) << "bind-Command Usage:" << Log::endl;
+    Log::get(LOG_USER) << "  bind ACTION KEY" << Log::endl;
+    Log::get(LOG_USER) << "Available Actions:" << Log::endl;
+    Log::get(LOG_USER) << "  menu" << Log::endl;
+    Log::get(LOG_USER) << "  debug" << Log::endl;
+    Log::get(LOG_USER) << "  forward" << Log::endl;
+    Log::get(LOG_USER) << "  backward" << Log::endl;
+    Log::get(LOG_USER) << "  left" << Log::endl;
+    Log::get(LOG_USER) << "  right" << Log::endl;
+    Log::get(LOG_USER) << "  jump" << Log::endl;
+    Log::get(LOG_USER) << "  crouch" << Log::endl;
+    Log::get(LOG_USER) << "  use" << Log::endl;
+    Log::get(LOG_USER) << "  holster" << Log::endl;
+    Log::get(LOG_USER) << "  walk" << Log::endl;
+    Log::get(LOG_USER) << "Key-Format:" << Log::endl;
+    Log::get(LOG_USER) << "  'a' or '1'    for character/number keys" << Log::endl;
+    Log::get(LOG_USER) << "  \"leftctrl\"  for symbols and special keys" << Log::endl;
 }
 
 int CommandBind::execute(std::istream& args) {
     std::string a, b;
     if (!(args >> a >> b)) {
-        getLog() << "Invalid use of bind-command" << Log::endl;
+        Log::get(LOG_USER) << "Invalid use of bind-command" << Log::endl;
         return -1;
     } else {
         ActionEvents e = stringToActionEvent(a);
         if (e == ActionEventCount) {
-            getLog() << "bind-Error: Unknown action (" << a << ")" << Log::endl;
+            Log::get(LOG_USER) << "bind-Error: Unknown action (" << a << ")" << Log::endl;
             return -2;
         }
 
         KeyboardButton c = stringToKeyboardButton(b);
         if (c == unknownKey) {
-            getLog() << "bind-Error: Unknown key (" << b << ")" << Log::endl;
+            Log::get(LOG_USER) << "bind-Error: Unknown key (" << b << ")" << Log::endl;
             return -3;
         }
 

src/commands/CommandEngine.cpp

 }
 
 void CommandLoad::printHelp() {
-    getLog() << "load-Command Usage:" << Log::endl;
-    getLog() << "  load /path/to/level" << Log::endl;
+    Log::get(LOG_USER) << "load-Command Usage:" << Log::endl;
+    Log::get(LOG_USER) << "  load /path/to/level" << Log::endl;
 }
 
 int CommandLoad::execute(std::istream& args) {
     if (!RunTime::isRunning()) {
-        getLog() << "Use load command interactively!" << Log::endl;
+        Log::get(LOG_USER) << "Use load command interactively!" << Log::endl;
         return -1;
     }
 
     std::string map;
     args >> map;
-    int error = getGame().loadLevel(map.c_str());
+    int error = Game::loadLevel(map.c_str());
     return error;
 }
 
 }
 
 void CommandScreenshot::printHelp() {
-    getLog() << "sshot-Command Usage:" << Log::endl;
-    getLog() << "  sshot" << Log::endl;
-    getLog() << "You wont be able to capture imgui..." << Log::endl;
+    Log::get(LOG_USER) << "sshot-Command Usage:" << Log::endl;
+    Log::get(LOG_USER) << "  sshot" << Log::endl;
+    Log::get(LOG_USER) << "You wont be able to capture imgui..." << Log::endl;
 }
 
 int CommandScreenshot::execute(std::istream& args) {
     if (!RunTime::isRunning()) {
-        getLog() << "Use sshot command interactively!" << Log::endl;
+        Log::get(LOG_USER) << "Use sshot command interactively!" << Log::endl;
         return -1;
     }
 

src/commands/CommandGame.cpp

 }
 
 int CommandPos::execute(std::istream& args) {
-    if ((!RunTime::isRunning()) || (!getGame().isLoaded())) {
-        getLog() << "Use pos command interactively!" << Log::endl;
+    if ((!RunTime::isRunning()) || (!Game::isLoaded())) {
+        Log::get(LOG_USER) << "Use pos command interactively!" << Log::endl;
         return -1;
     }
 
-    getGame().getLara().print();
+    Game::getLara().print();
     return 0;
 }
 
 }
 
 int CommandViewmodel::execute(std::istream& args) {
-    if ((!RunTime::isRunning()) || (!getGame().isLoaded())) {
-        getLog() << "Use viewmodel command interactively!" << Log::endl;
+    if ((!RunTime::isRunning()) || (!Game::isLoaded())) {
+        Log::get(LOG_USER) << "Use viewmodel command interactively!" << Log::endl;
         return -1;
     }
 
     unsigned int n = atoi(s.c_str());
 
     if (n < getWorld().sizeSkeletalModel()) {
-        getGame().getLara().setSkeletalModel(n);
+        Game::getLara().setSkeletalModel(n);
         return 0;
     } else {
-        getLog() << "Invalid SkeletalModel index!" << Log::endl;
+        Log::get(LOG_USER) << "Invalid SkeletalModel index!" << Log::endl;
         return -2;
     }
 }

src/commands/CommandMove.cpp

 }
 
 void CommandMove::printHelp() {
-    getLog() << "move-Command Usage:" << Log::endl;
-    getLog() << "  move COMMAND" << Log::endl;
-    getLog() << "Where COMMAND is one of the following:" << Log::endl;
-    getLog() << "  walk" << Log::endl;
-    getLog() << "  fly" << Log::endl;
-    getLog() << "  noclip" << Log::endl;
+    Log::get(LOG_USER) << "move-Command Usage:" << Log::endl;
+    Log::get(LOG_USER) << "  move COMMAND" << Log::endl;
+    Log::get(LOG_USER) << "Where COMMAND is one of the following:" << Log::endl;
+    Log::get(LOG_USER) << "  walk" << Log::endl;
+    Log::get(LOG_USER) << "  fly" << Log::endl;
+    Log::get(LOG_USER) << "  noclip" << Log::endl;
 }
 
 int CommandMove::execute(std::istream& args) {
-    if ((!RunTime::isRunning()) || (!getGame().isLoaded())) {
-        getLog() << "Use move command interactively!" << Log::endl;
+    if ((!RunTime::isRunning()) || (!Game::isLoaded())) {
+        Log::get(LOG_USER) << "Use move command interactively!" << Log::endl;
         return -1;
     }
 
     std::string s;
     args >> s;
     if (s.compare("walk") == 0) {
-        getGame().getLara().setMoveType(Entity::MoveTypeWalk);
+        Game::getLara().setMoveType(Entity::MoveTypeWalk);
     } else if (s.compare("fly") == 0) {
-        getGame().getLara().setMoveType(Entity::MoveTypeFly);
+        Game::getLara().setMoveType(Entity::MoveTypeFly);
     } else if (s.compare("noclip") == 0) {
-        getGame().getLara().setMoveType(Entity::MoveTypeNoClipping);
+        Game::getLara().setMoveType(Entity::MoveTypeNoClipping);
     } else {
-        getLog() << "Invalid use of move command (" << s << ")!" << Log::endl;
+        Log::get(LOG_USER) << "Invalid use of move command (" << s << ")!" << Log::endl;
         return -2;
     }
 
-    getLog() << s  << "ing" << Log::endl;
+    Log::get(LOG_USER) << s  << "ing" << Log::endl;
     return 0;
 }
 

src/commands/CommandRender.cpp

 }
 
 void CommandMode::printHelp() {
-    getLog() << "mode-Command Usage:" << Log::endl;
-    getLog() << "  mode MODE" << Log::endl;
-    getLog() << "Where MODE is one of the following:" << Log::endl;
-    getLog() << "  wireframe" << Log::endl;
-    getLog() << "  solid" << Log::endl;
-    getLog() << "  texture" << Log::endl;
-    getLog() << "  titlescreen" << Log::endl;
+    Log::get(LOG_USER) << "mode-Command Usage:" << Log::endl;
+    Log::get(LOG_USER) << "  mode MODE" << Log::endl;
+    Log::get(LOG_USER) << "Where MODE is one of the following:" << Log::endl;
+    Log::get(LOG_USER) << "  wireframe" << Log::endl;
+    Log::get(LOG_USER) << "  solid" << Log::endl;
+    Log::get(LOG_USER) << "  texture" << Log::endl;
+    Log::get(LOG_USER) << "  titlescreen" << Log::endl;
 
 }
 
 
     if (s == "wireframe") {
         Render::setMode(RenderMode::Wireframe);
-        getLog() << "Wireframe mode" << Log::endl;
+        Log::get(LOG_USER) << "Wireframe mode" << Log::endl;
     } else if (s == "solid") {
         Render::setMode(RenderMode::Solid);
-        getLog() << "Solid mode" << Log::endl;
+        Log::get(LOG_USER) << "Solid mode" << Log::endl;
     } else if (s == "texture") {
         Render::setMode(RenderMode::Texture);
-        getLog() << "Texture Mode" << Log::endl;
+        Log::get(LOG_USER) << "Texture Mode" << Log::endl;
     } else if (s == "titlescreen") {
         Render::setMode(RenderMode::LoadScreen);
-        getLog() << "Titlescreen mode" << Log::endl;
+        Log::get(LOG_USER) << "Titlescreen mode" << Log::endl;
     } else {
-        getLog() << "Invalid use of mode command (" << s << ")!" << Log::endl;
+        Log::get(LOG_USER) << "Invalid use of mode command (" << s << ")!" << Log::endl;
         return -2;
     }
 

src/commands/CommandSet.cpp

 }
 
 void CommandSet::printHelp() {
-    getLog() << "set-Command Usage:" << Log::endl;
-    getLog() << "  set VAR VAL" << Log::endl;
-    getLog() << "Available Variables:" << Log::endl;
-    getLog() << "  basedir    STRING" << Log::endl;
-    getLog() << "  pakdir     STRING" << Log::endl;
-    getLog() << "  audiodir   STRING" << Log::endl;
-    getLog() << "  datadir    STRING" << Log::endl;
-    getLog() << "  font       STRING" << Log::endl;
-    getLog() << "  size       INT INT" << Log::endl;
-    getLog() << "  fullscreen BOOL" << Log::endl;
-    getLog() << "  audio      BOOL" << Log::endl;
-    getLog() << "  volume     BOOL" << Log::endl;
-    getLog() << "  mouse_x    FLOAT" << Log::endl;
-    getLog() << "  mouse_y    FLOAT" << Log::endl;
-    getLog() << "  fps        BOOL" << Log::endl;
-    getLog() << "Enclose STRINGs with \"\"!" << Log::endl;
+    Log::get(LOG_USER) << "set-Command Usage:" << Log::endl;
+    Log::get(LOG_USER) << "  set VAR VAL" << Log::endl;
+    Log::get(LOG_USER) << "Available Variables:" << Log::endl;
+    Log::get(LOG_USER) << "  basedir    STRING" << Log::endl;
+    Log::get(LOG_USER) << "  pakdir     STRING" << Log::endl;
+    Log::get(LOG_USER) << "  audiodir   STRING" << Log::endl;
+    Log::get(LOG_USER) << "  datadir    STRING" << Log::endl;
+    Log::get(LOG_USER) << "  font       STRING" << Log::endl;
+    Log::get(LOG_USER) << "  size       INT INT" << Log::endl;
+    Log::get(LOG_USER) << "  fullscreen BOOL" << Log::endl;
+    Log::get(LOG_USER) << "  audio      BOOL" << Log::endl;
+    Log::get(LOG_USER) << "  volume     BOOL" << Log::endl;
+    Log::get(LOG_USER) << "  mouse_x    FLOAT" << Log::endl;
+    Log::get(LOG_USER) << "  mouse_y    FLOAT" << Log::endl;
+    Log::get(LOG_USER) << "  fps        BOOL" << Log::endl;
+    Log::get(LOG_USER) << "Enclose STRINGs with \"\"!" << Log::endl;
 }
 
-namespace {
-    std::string expandNames(std::string s) {
-        // Remove quotes
-        if ((s.length() >= 3) &&
-            (((s[0] == '"') && (s[s.length() - 1] == '"'))
-             || ((s[0] == '\'') && (s[s.length() - 1] == '\'')))) {
-            s.erase(0, 1);
-            s.erase(s.length() - 1, 1);
-        }
+static std::string expandNames(std::string s) {
+    // Remove quotes
+    if ((s.length() >= 3) &&
+        (((s[0] == '"') && (s[s.length() - 1] == '"'))
+         || ((s[0] == '\'') && (s[s.length() - 1] == '\'')))) {
+        s.erase(0, 1);
+        s.erase(s.length() - 1, 1);
+    }
 
-        // Expand Names
-        s = findAndReplace(s, "$(pakdir)", RunTime::getPakDir());
-        s = findAndReplace(s, "$(audiodir)", RunTime::getAudioDir());
-        s = findAndReplace(s, "$(datadir)", RunTime::getDataDir());
-        s = findAndReplace(s, "$(basedir)", RunTime::getBaseDir());
+    // Expand Names
+    s = findAndReplace(s, "$(pakdir)", RunTime::getPakDir());
+    s = findAndReplace(s, "$(audiodir)", RunTime::getAudioDir());
+    s = findAndReplace(s, "$(datadir)", RunTime::getDataDir());
+    s = findAndReplace(s, "$(basedir)", RunTime::getBaseDir());
 
-        // Full path
-        s = expandHomeDirectory(s);
+    // Full path
+    s = expandHomeDirectory(s);
 
-        return s;
-    }
+    return s;
 }
 
 int CommandSet::execute(std::istream& args) {
     if (var.compare("size") == 0) {
         unsigned int w = DEFAULT_WIDTH, h = DEFAULT_HEIGHT;
         if (!(args >> w >> h)) {
-            getLog() << "set-size-Error: Invalid value(s)" << Log::endl;
+            Log::get(LOG_USER) << "set-size-Error: Invalid value(s)" << Log::endl;
             return -2;
         }
         Window::setSize(glm::i32vec2(w, h));
     } else if (var.compare("fullscreen") == 0) {
         bool fullscreen = false;
         if (!(args >> fullscreen)) {
-            getLog() << "set-fullscreen-Error: Invalid value" << Log::endl;
+            Log::get(LOG_USER) << "set-fullscreen-Error: Invalid value" << Log::endl;
             return -3;
         }
         Window::setFullscreen(fullscreen);
     } else if (var.compare("audio") == 0) {
         bool audio = false;
         if (!(args >> audio)) {
-            getLog() << "set-audio-Error: Invalid value" << Log::endl;
+            Log::get(LOG_USER) << "set-audio-Error: Invalid value" << Log::endl;
             return -4;
         }
         Sound::setEnabled(audio);
     } else if (var.compare("volume") == 0) {
         float vol = 1.0f;
         if (!(args >> vol)) {
-            getLog() << "set-volume-Error: Invalid value" << Log::endl;
+            Log::get(LOG_USER) << "set-volume-Error: Invalid value" << Log::endl;
             return -5;
         }
         Sound::setVolume(vol);
     } else if (var.compare("mouse_x") == 0) {
         float sense = 1.0f;
         if (!(args >> sense)) {
-            getLog() << "set-mouse_x-Error: Invalid value" << Log::endl;
+            Log::get(LOG_USER) << "set-mouse_x-Error: Invalid value" << Log::endl;
             return -6;
         }
         Camera::setSensitivityX(glm::radians(sense));
     } else if (var.compare("mouse_y") == 0) {
         float sense = 1.0f;
         if (!(args >> sense)) {
-            getLog() << "set-mouse_y-Error: Invalid value" << Log::endl;
+            Log::get(LOG_USER) << "set-mouse_y-Error: Invalid value" << Log::endl;
             return -7;
         }
         Camera::setSensitivityY(glm::radians(sense));
     } else if (var.compare("fps") == 0) {
         bool fps = false;
         if (!(args >> fps)) {
-            getLog() << "set-fps-Error: Invalid value" << Log::endl;
+            Log::get(LOG_USER) << "set-fps-Error: Invalid value" << Log::endl;
             return -8;
         }
         RunTime::setShowFPS(fps);
         args >> temp;
         int error = Font::initialize(expandNames(temp));
         if (error != 0)
-            getLog() << "Error initializing font: " << expandNames(temp) << "(" << error << ")" << Log::endl;
+            Log::get(LOG_USER) << "Error initializing font: " << expandNames(temp) << "(" << error << ")" << Log::endl;
     } else {
-        getLog() << "set-Error: Unknown variable (" << var.c_str() << ")" << Log::endl;
+        Log::get(LOG_USER) << "set-Error: Unknown variable (" << var.c_str() << ")" << Log::endl;
         return -1;
     }
 
 }
 
 void CommandGet::printHelp() {
-    getLog() << "get-Command Usage:" << Log::endl;
-    getLog() << "  get VAR" << Log::endl;
-    getLog() << "Available Variables:" << Log::endl;
-    getLog() << "  basedir" << Log::endl;
-    getLog() << "  pakdir" << Log::endl;
-    getLog() << "  audiodir" << Log::endl;
-    getLog() << "  datadir" << Log::endl;
-    getLog() << "  font" << Log::endl;
-    getLog() << "  size" << Log::endl;
-    getLog() << "  fullscreen" << Log::endl;
-    getLog() << "  audio" << Log::endl;
-    getLog() << "  volume" << Log::endl;
-    getLog() << "  mouse_x" << Log::endl;
-    getLog() << "  mouse_y" << Log::endl;
-    getLog() << "  fps" << Log::endl;
+    Log::get(LOG_USER) << "get-Command Usage:" << Log::endl;
+    Log::get(LOG_USER) << "  get VAR" << Log::endl;
+    Log::get(LOG_USER) << "Available Variables:" << Log::endl;
+    Log::get(LOG_USER) << "  basedir" << Log::endl;
+    Log::get(LOG_USER) << "  pakdir" << Log::endl;
+    Log::get(LOG_USER) << "  audiodir" << Log::endl;
+    Log::get(LOG_USER) << "  datadir" << Log::endl;
+    Log::get(LOG_USER) << "  font" << Log::endl;
+    Log::get(LOG_USER) << "  size" << Log::endl;
+    Log::get(LOG_USER) << "  fullscreen" << Log::endl;
+    Log::get(LOG_USER) << "  audio" << Log::endl;
+    Log::get(LOG_USER) << "  volume" << Log::endl;
+    Log::get(LOG_USER) << "  mouse_x" << Log::endl;
+    Log::get(LOG_USER) << "  mouse_y" << Log::endl;
+    Log::get(LOG_USER) << "  fps" << Log::endl;
 }
 
 int CommandGet::execute(std::istream& args) {
     args >> var;
 
     if (var.compare("size") == 0) {
-        getLog() << Window::getSize() << Log::endl;
+        Log::get(LOG_USER) << Window::getSize() << Log::endl;
     } else if (var.compare("fullscreen") == 0) {
-        getLog() << Window::getFullscreen() << Log::endl;
+        Log::get(LOG_USER) << Window::getFullscreen() << Log::endl;
     } else if (var.compare("audio") == 0) {
-        getLog() << Sound::getEnabled() << Log::endl;
+        Log::get(LOG_USER) << Sound::getEnabled() << Log::endl;
     } else if (var.compare("volume") == 0) {
-        getLog() << Sound::getVolume() << Log::endl;
+        Log::get(LOG_USER) << Sound::getVolume() << Log::endl;
     } else if (var.compare("mouse_x") == 0) {
-        getLog() << glm::degrees(Camera::getSensitivityX()) << Log::endl;
+        Log::get(LOG_USER) << glm::degrees(Camera::getSensitivityX()) << Log::endl;
     } else if (var.compare("mouse_y") == 0) {
-        getLog() << glm::degrees(Camera::getSensitivityY()) << Log::endl;
+        Log::get(LOG_USER) << glm::degrees(Camera::getSensitivityY()) << Log::endl;
     } else if (var.compare("fps") == 0) {
-        getLog() << RunTime::getShowFPS() << Log::endl;
+        Log::get(LOG_USER) << RunTime::getShowFPS() << Log::endl;
     } else if (var.compare("basedir") == 0) {
-        getLog() << RunTime::getBaseDir() << Log::endl;
+        Log::get(LOG_USER) << RunTime::getBaseDir() << Log::endl;
     } else if (var.compare("pakdir") == 0) {
-        getLog() << RunTime::getPakDir() << Log::endl;
+        Log::get(LOG_USER) << RunTime::getPakDir() << Log::endl;
     } else if (var.compare("audiodir") == 0) {
-        getLog() << RunTime::getAudioDir() << Log::endl;
+        Log::get(LOG_USER) << RunTime::getAudioDir() << Log::endl;
     } else if (var.compare("datadir") == 0) {
-        getLog() << RunTime::getDataDir() << Log::endl;
+        Log::get(LOG_USER) << RunTime::getDataDir() << Log::endl;
     } else if (var.compare("font") == 0) {
-        getLog() << Font::getFontName() << Log::endl;
+        Log::get(LOG_USER) << Font::getFontName() << Log::endl;
     } else {
-        getLog() << "get-Error: Unknown variable (" << var << ")" << Log::endl;
+        Log::get(LOG_USER) << "get-Error: Unknown variable (" << var << ")" << Log::endl;
         return -1;
     }
 

src/loader/LoaderTR2.cpp

     }
 
     if (numTextiles > 0)
-        getLog() << "LoaderTR2: Found " << numTextiles << " Textures!" << Log::endl;
+        Log::get(LOG_INFO) << "LoaderTR2: Found " << numTextiles << " Textures!" << Log::endl;
     else
-        getLog() << "LoaderTR2: No Textures in this level?!" << Log::endl;
+        Log::get(LOG_INFO) << "LoaderTR2: No Textures in this level?!" << Log::endl;
 }
 
 void LoaderTR2::loadTextures() {
     }
 
     if (numObjectTextures > 0)
-        getLog() << "LoaderTR2: Found " << numObjectTextures << " Textiles!" << Log::endl;
+        Log::get(LOG_INFO) << "LoaderTR2: Found " << numObjectTextures << " Textiles!" << Log::endl;
     else
-        getLog() << "LoaderTR2: No Textiles in this level?!" << Log::endl;
+        Log::get(LOG_INFO) << "LoaderTR2: No Textiles in this level?!" << Log::endl;
 }
 
 void LoaderTR2::loadAnimatedTextures() {
     for (unsigned int a = 0; a < numAnimatedTextures; a++) {
         int count = animatedTextures.at(pos) + 1;
         if ((pos + count) >= numWords) {
-            getLog() << "LoaderTR2: Invalid AnimatedTextures ("
+            Log::get(LOG_DEBUG) << "LoaderTR2: Invalid AnimatedTextures ("
                      << pos + count << " >= " << numWords << ")!" << Log::endl;
             return;
         }
     }
 
     if ((numAnimatedTextures > 0) || (numWords > 0))
-        getLog() << "LoaderTR2: Found " << numAnimatedTextures << " Animated Textures!" << Log::endl;
+        Log::get(LOG_INFO) << "LoaderTR2: Found " << numAnimatedTextures << " Animated Textures!" << Log::endl;
     else
-        getLog() << "LoaderTR2: No Animated Textures in this level?!" << Log::endl;
+        Log::get(LOG_INFO) << "LoaderTR2: No Animated Textures in this level?!" << Log::endl;
 
     if (pos != numWords)
-        getLog() << "LoaderTR2: Extra bytes at end of AnimatedTextures?!" << Log::endl;
+        Log::get(LOG_DEBUG) << "LoaderTR2: Extra bytes at end of AnimatedTextures?!" << Log::endl;
 }
 
 // ---- Rooms ----
         // Sanity check
         if ((numPortals == 0) && (numVertices == 0)
             && (numRectangles == 0) && (numTriangles == 0))
-            getLog() << "LoaderTR2: Room " << i << " seems invalid: " << numPortals << "p "
+            Log::get(LOG_DEBUG) << "LoaderTR2: Room " << i << " seems invalid: " << numPortals << "p "
                      << numRectangles << "r " << numTriangles << "t " << numVertices
                      << "v" << Log::endl;
     }
 
     if (numRooms > 0)
-        getLog() << "LoaderTR2: Found " << numRooms << " Rooms!" << Log::endl;
+        Log::get(LOG_INFO) << "LoaderTR2: Found " << numRooms << " Rooms!" << Log::endl;
     else
-        getLog() << "LoaderTR2: No Rooms in this Level?!" << Log::endl;
+        Log::get(LOG_INFO) << "LoaderTR2: No Rooms in this Level?!" << Log::endl;
 }
 
 void LoaderTR2::loadFloorData() {
     }
 
     if (numFloorData > 0)
-        getLog() << "LoaderTR2: Found " << numFloorData << " words FloorData, unimplemented!" << Log::endl;
+        Log::get(LOG_INFO) << "LoaderTR2: Found " << numFloorData << " words FloorData, unimplemented!" << Log::endl;
     else
-        getLog() << "LoaderTR2: No FloorData in this level?!" << Log::endl;
+        Log::get(LOG_INFO) << "LoaderTR2: No FloorData in this level?!" << Log::endl;
 }
 
 void LoaderTR2::loadSprites() {
     }
 
     if ((numSpriteTextures > 0) || (numSpriteSequences > 0))
-        getLog() << "LoaderTR2: Found " << numSpriteTextures << " Sprites in " << numSpriteSequences <<
+        Log::get(LOG_INFO) << "LoaderTR2: Found " << numSpriteTextures << " Sprites in " << numSpriteSequences <<
                  " Sequences!" << Log::endl;
     else
-        getLog() << "LoaderTR2: No Sprites in this level?!" << Log::endl;
+        Log::get(LOG_INFO) << "LoaderTR2: No Sprites in this level?!" << Log::endl;
 }
 
 // ---- Meshes ----
         uint32_t meshPointer = file.readU32();
 
         if (numMeshData < (meshPointer / 2)) {
-            getLog() << "LoaderTR2: Invalid Mesh: "
+            Log::get(LOG_DEBUG) << "LoaderTR2: Invalid Mesh: "
                      << (meshPointer / 2) << " > " << numMeshData << Log::endl;
             continue;
         }
     }
 
     if (numMeshPointers > 0)
-        getLog() << "LoaderTR2: Found " << numMeshPointers << " Meshes!" << Log::endl;
+        Log::get(LOG_INFO) << "LoaderTR2: Found " << numMeshPointers << " Meshes!" << Log::endl;
     else
-        getLog() << "LoaderTR2: No Meshes in this level?!" << Log::endl;
+        Log::get(LOG_INFO) << "LoaderTR2: No Meshes in this level?!" << Log::endl;
 }
 
 void LoaderTR2::loadStaticMeshes() {
     }
 
     if (numStaticMeshes > 0)
-        getLog() << "LoaderTR2: Found " << numStaticMeshes << " StaticMeshes!" << Log::endl;
+        Log::get(LOG_INFO) << "LoaderTR2: Found " << numStaticMeshes << " StaticMeshes!" << Log::endl;
     else
-        getLog() << "LoaderTR2: No StaticMeshes in this level?!" << Log::endl;
+        Log::get(LOG_INFO) << "LoaderTR2: No StaticMeshes in this level?!" << Log::endl;
 }
 
 // ---- Moveables ----
     }
 
     if (numAnimations > 0)
-        getLog() << "LoaderTR2: Found " << numAnimations << " Animations!" << Log::endl;
+        Log::get(LOG_INFO) << "LoaderTR2: Found " << numAnimations << " Animations!" << Log::endl;
     else
-        getLog() << "LoaderTR2: No Animations in this level?!" << Log::endl;
+        Log::get(LOG_INFO) << "LoaderTR2: No Animations in this level?!" << Log::endl;
 
     uint32_t numStateChanges = file.readU32();
     std::vector<StateChange_t> stateChanges;
     }
 
     if (numStateChanges > 0)
-        getLog() << "LoaderTR2: Found " << numStateChanges << " StateChanges!" << Log::endl;
+        Log::get(LOG_INFO) << "LoaderTR2: Found " << numStateChanges << " StateChanges!" << Log::endl;
     else
-        getLog() << "LoaderTR2: No StateChanges in this level?!" << Log::endl;
+        Log::get(LOG_INFO) << "LoaderTR2: No StateChanges in this level?!" << Log::endl;
 
     uint32_t numAnimDispatches = file.readU32();
     std::vector<AnimDispatch_t> animDispatches;
     }
 
     if (numAnimDispatches > 0)
-        getLog() << "LoaderTR2: Found " << numAnimDispatches << " AnimationDispatches!" << Log::endl;
+        Log::get(LOG_INFO) << "LoaderTR2: Found " << numAnimDispatches << " AnimationDispatches!" << Log::endl;
     else
-        getLog() << "LoaderTR2: No AnimationDispatches in this level?!" << Log::endl;
+        Log::get(LOG_INFO) << "LoaderTR2: No AnimationDispatches in this level?!" << Log::endl;
 
     uint32_t numAnimCommands = file.readU32();
     std::vector<int16_t> animCommands;
     }
 
     if (numAnimCommands > 0)
-        getLog() << "LoaderTR2: Found " << numAnimCommands << " AnimationCommands!" << Log::endl;
+        Log::get(LOG_INFO) << "LoaderTR2: Found " << numAnimCommands << " AnimationCommands!" << Log::endl;
     else
-        getLog() << "LoaderTR2: No AnimationCommands in this level?!" << Log::endl;
+        Log::get(LOG_INFO) << "LoaderTR2: No AnimationCommands in this level?!" << Log::endl;
 
     // This is really one uint32_t flags, followed by
     // three int32_t x, y, z. However, we're given the number
     }
 
     if (numMeshTrees > 0)
-        getLog() << "LoaderTR2: Found " << numMeshTrees << " MeshTrees!" << Log::endl;
+        Log::get(LOG_INFO) << "LoaderTR2: Found " << numMeshTrees << " MeshTrees!" << Log::endl;
     else
-        getLog() << "LoaderTR2: No MeshTrees in this level?!" << Log::endl;
+        Log::get(LOG_INFO) << "LoaderTR2: No MeshTrees in this level?!" << Log::endl;
 
     uint32_t numFrames = file.readU32();
     std::vector<uint16_t> frames;
     }
 
     if (numFrames > 0)
-        getLog() << "LoaderTR2: Found " << numFrames << " Frames!" << Log::endl;
+        Log::get(LOG_INFO) << "LoaderTR2: Found " << numFrames << " Frames!" << Log::endl;
     else
-        getLog() << "LoaderTR2: No Frames in this level?!" << Log::endl;
+        Log::get(LOG_INFO) << "LoaderTR2: No Frames in this level?!" << Log::endl;
 
     uint32_t numMoveables = file.readU32();
     for (unsigned int m = 0; m < numMoveables; m++) {
     }
 
     if (numMoveables > 0)
-        getLog() << "LoaderTR2: Found " << numMoveables << " Moveables!" << Log::endl;
+        Log::get(LOG_INFO) << "LoaderTR2: Found " << numMoveables << " Moveables!" << Log::endl;
     else
-        getLog() << "LoaderTR2: No Moveables in this level?!" << Log::endl;
+        Log::get(LOG_INFO) << "LoaderTR2: No Moveables in this level?!" << Log::endl;
 }
 
 void LoaderTR2::loadItems() {
                 getWorld().addEntity(e);
 
                 if (objectID == 0) {
-                    getGame().setLara(getWorld().sizeEntity() - 1);
+                    Game::setLara(getWorld().sizeEntity() - 1);
                 }
             }
         }
     }
 
     if (numItems > 0)
-        getLog() << "LoaderTR2: Found " << numItems << " Items!" << Log::endl;
+        Log::get(LOG_INFO) << "LoaderTR2: Found " << numItems << " Items!" << Log::endl;
     else
-        getLog() << "LoaderTR2: No Items in this level?!" << Log::endl;
+        Log::get(LOG_INFO) << "LoaderTR2: No Items in this level?!" << Log::endl;
 }
 
 void LoaderTR2::loadBoxesOverlapsZones() {
     }
 
     if ((numBoxes > 0) || (numOverlaps > 0))
-        getLog() << "LoaderTR2: Found NPC NavigationHints (" << numBoxes
+        Log::get(LOG_INFO) << "LoaderTR2: Found NPC NavigationHints (" << numBoxes
                  << ", " << numOverlaps << ", " << list << "), unimplemented!" << Log::endl;
     else
-        getLog() << "LoaderTR2: No NPC NavigationHints in this level?!" << Log::endl;
+        Log::get(LOG_INFO) << "LoaderTR2: No NPC NavigationHints in this level?!" << Log::endl;
 }
 
 // ---- Sound ----
     }
 
     if (numSoundSources > 0)
-        getLog() << "LoaderTR2: Found " << numSoundSources << " SoundSources" << Log::endl;
+        Log::get(LOG_INFO) << "LoaderTR2: Found " << numSoundSources << " SoundSources" << Log::endl;
     else
-        getLog() << "LoaderTR2: No SoundSources in this level?!" << Log::endl;
+        Log::get(LOG_INFO) << "LoaderTR2: No SoundSources in this level?!" << Log::endl;
 }
 
 void LoaderTR2::loadSoundMap() {
     }
 
     if (numSoundDetails > 0)
-        getLog() << "LoaderTR2: Found " << numSoundDetails << " SoundDetails" << Log::endl;
+        Log::get(LOG_INFO) << "LoaderTR2: Found " << numSoundDetails << " SoundDetails" << Log::endl;
     else
-        getLog() << "LoaderTR2: No SoundDetails in this level?!" << Log::endl;
+        Log::get(LOG_INFO) << "LoaderTR2: No SoundDetails in this level?!" << Log::endl;
 }
 
 void LoaderTR2::loadSampleIndices() {
     }
 
     if (numSampleIndices > 0)
-        getLog() << "LoaderTR2: Found " << numSampleIndices << " SampleIndices" << Log::endl;
+        Log::get(LOG_INFO) << "LoaderTR2: Found " << numSampleIndices << " SampleIndices" << Log::endl;
     else
-        getLog() << "LoaderTR2: No SampleIndices in this level?!" << Log::endl;
+        Log::get(LOG_INFO) << "LoaderTR2: No SampleIndices in this level?!" << Log::endl;
 }
 
 void LoaderTR2::loadExternalSoundFile(std::string f) {
 
     BinaryFile sfx;
     if (sfx.open(f) != 0) {
-        getLog() << "LoaderTR2: Can't open \"" << f << "\"!" << Log::endl;
+        Log::get(LOG_INFO) << "LoaderTR2: Can't open \"" << f << "\"!" << Log::endl;
         return;
     }
 
             test[i] = sfx.read8();
 
         if (std::string("RIFF") != std::string(test)) {
-            getLog() << "LoaderTR2: External SFX invalid! (" << riffCount
+            Log::get(LOG_DEBUG) << "LoaderTR2: External SFX invalid! (" << riffCount
                      << ", \"" << test << "\" != \"RIFF\")" << Log::endl;
             return;
         }
     }
 
     if (riffCount > 0)
-        getLog() << "LoaderTR2: Found " << riffCount << " SoundSamples in SFX" << Log::endl;
+        Log::get(LOG_INFO) << "LoaderTR2: Found " << riffCount << " SoundSamples in SFX" << Log::endl;
     else
-        getLog() << "LoaderTR2: No SoundSamples in SFX?!" << Log::endl;
+        Log::get(LOG_INFO) << "LoaderTR2: No SoundSamples in SFX?!" << Log::endl;
 }
 
 // ---- Stuff ----
     }
 
     if (numCameras > 0)
-        getLog() << "LoaderTR2: Found " << numCameras << " Cameras, unimplemented!" << Log::endl;
+        Log::get(LOG_INFO) << "LoaderTR2: Found " << numCameras << " Cameras, unimplemented!" << Log::endl;
 }
 
 void LoaderTR2::loadCinematicFrames() {
     }
 
     if (numCinematicFrames > 0)
-        getLog() << "LoaderTR2: Found " << numCinematicFrames
+        Log::get(LOG_INFO) << "LoaderTR2: Found " << numCinematicFrames
                  << " CinematicFrames, unimplemented!" << Log::endl;
 }
 
 
     // TODO store demo data somewhere, find out meaning
     if (numDemoData > 0)
-        getLog() << "LoaderTR2: Found " << numDemoData << " bytes DemoData, unimplemented!" <<
+        Log::get(LOG_INFO) << "LoaderTR2: Found " << numDemoData << " bytes DemoData, unimplemented!" <<
                  Log::endl;
 }
 

src/main.cpp

 
 #include "global.h"
 #include "Camera.h"
-#include "Game.h"
 #include "Log.h"
 #include "MenuFolder.h"
+#include "Render.h"
 #include "RunTime.h"
 #include "SoundManager.h"
 #include "TextureManager.h"
 
 static std::string configFileToUse;
 
-static std::shared_ptr<Game> gGame;
-static std::shared_ptr<Log> gLog;
 static std::shared_ptr<MenuFolder> gMenu;
 static std::shared_ptr<World> gWorld;
 
-Game& getGame() {
-    return *gGame;
-}
-
-Log& getLog() {
-    return *gLog;
-}
-
 Menu& getMenu() {
     return *gMenu;
 }
     // RunTime is required by other constructors
     RunTime::initialize();
 
-    gGame.reset(new Game());
-    gLog.reset(new Log());
     gMenu.reset(new MenuFolder());
     gWorld.reset(new World());
 
     Command::fillCommandList();
 
-    getLog() << "Initializing " << VERSION << Log::endl;
+    Log::get(LOG_INFO) << "Initializing " << VERSION << Log::endl;
 
     // Initialize Windowing
     int error = Window::initialize();
         return -7;
     }
 
-    // Initialize Game Engine
-    error = getGame().initialize();
-    if (error != 0) {
-        std::cout << "Could not initialize Game (" << error << ")!" << std::endl;
-        return -8;
-    }
-
-    getLog() << "Starting " << VERSION << Log::endl;
+    Log::get(LOG_INFO) << "Starting " << VERSION << Log::endl;
     Camera::setSize(Window::getSize());
     getMenu().setVisible(true);
     systemTimerReset();
     RunTime::setRunning(true);
+    Render::setMode(RenderMode::LoadScreen);
 
     while (RunTime::isRunning()) {
         Window::eventHandling();
 }
 
 void renderFrame() {
-    getGame().display();
+    Render::display();
     getMenu().display();
     UI::display();
     Window::swapBuffers();
 #include <exception>
 #include <execinfo.h>
 
-namespace {
-    extern std::terminate_handler oldTerminateHandler;
-
-    [[noreturn]] void terminateHandler() {
-        const unsigned int maxSize = 128;
-        void* callstack[maxSize];
-        int frames = backtrace(callstack, maxSize);
-        char** strs = backtrace_symbols(callstack, frames);
+[[noreturn]] static void terminateHandler();
+static std::terminate_handler oldTerminateHandler = std::set_terminate(terminateHandler);
 
-        std::cout << std::endl;
-        for (int i = frames; i > 0; i++)
-            std::cout << strs[i - 1] << std::endl;
+[[noreturn]] static void terminateHandler() {
+    const unsigned int maxSize = 128;
+    void* callstack[maxSize];
+    int frames = backtrace(callstack, maxSize);
+    char** strs = backtrace_symbols(callstack, frames);
 
-        delete [] strs;
+    std::cout << std::endl;
+    for (int i = frames; i > 0; i++)
+        std::cout << strs[i - 1] << std::endl;
 
-        oldTerminateHandler();
-        abort();
-    }
+    delete [] strs;
 
-    std::terminate_handler oldTerminateHandler = std::set_terminate(terminateHandler);
+    oldTerminateHandler();
+    abort();
 }
 
 #endif // NODEBUG

src/system/Font.cpp

     }
 
     if (font != "") {
-        getLog() << "Unknown font file format: " << font << Log::endl;
+        Log::get(LOG_ERROR) << "Unknown font file format: " << font << Log::endl;
         return -1;
     } else {
         return 0;

src/system/FontTTF.cpp

     unsigned char* pixels = new unsigned char[MAP_WIDTH * MAP_HEIGHT];
     if (!stbtt_PackBegin(&context, pixels, MAP_WIDTH, MAP_HEIGHT, 0, 1, nullptr)) {
         delete [] pixels;
-        getLog() << "Error initializing font map in stbtt_PackBegin!" << Log::endl;
+        Log::get(LOG_ERROR) << "Error initializing font map in stbtt_PackBegin!" << Log::endl;
         return -1;
     }
 
         delete [] pixels;
         delete [] charInfo;
         charInfo = nullptr;
-        getLog() << "Error packing font map!" << Log::endl;
+        Log::get(LOG_ERROR) << "Error packing font map!" << Log::endl;
         return -2;
     }
 
     if (texture < 0) {
         delete [] charInfo;
         charInfo = nullptr;
-        getLog() << "Error loading new font map texture!" << Log::endl;
+        Log::get(LOG_ERROR) << "Error loading new font map texture!" << Log::endl;
         return -3;
     }
 
 
     std::ifstream file(f, std::ios::binary);
     if (!file) {
-        getLog() << "Couldn't open file \"" << f << "\"!" << Log::endl;
+        Log::get(LOG_ERROR) << "Couldn't open file \"" << f << "\"!" << Log::endl;
         return -1;
     }
 
 
     fontData = new unsigned char[size];
     if (!file.read(reinterpret_cast<char*>(fontData), size)) {
-        getLog() << "Couldn't read data in \"" << f << "\"" << Log::endl;
+        Log::get(LOG_ERROR) << "Couldn't read data in \"" << f << "\"" << Log::endl;
         delete [] fontData;
         fontData = nullptr;
         return -2;
     if (c >= (MAP_NUM_CHARS / 2))
         begin -= (MAP_NUM_CHARS / 2);
 
-    getLog() << "Unmapped character '" << char(c) << "', new map from " << begin << " to "
+    Log::get(LOG_INFO) << "Unmapped character '" << char(c) << "', new map from " << begin << " to "
              << begin + MAP_NUM_CHARS - 1 << "..." << Log::endl;
 
     int p = maps.size();

src/system/Shader.cpp

     assert(programID >= 0);
     int r = glGetUniformLocation(programID, name);
     if (r < 0) {
-        getLog() << "Can't find GLSL Uniform \"" << name << "\"!" << Log::endl;
+        Log::get(LOG_ERROR) << "Can't find GLSL Uniform \"" << name << "\"!" << Log::endl;
         return -1;
     }
     uniforms.push_back(r);
         std::vector<char> message(logLength + 1);
         glGetShaderInfoLog(vertexID, logLength, nullptr, &message[0]);
         if (result != GL_TRUE)
-            getLog() << "Vertex Shader compilation error:" << Log::endl;
-        getLog() << &message[0] << Log::endl;
+            Log::get(LOG_ERROR) << "Vertex Shader compilation error:" << Log::endl;
+        Log::get(LOG_ERROR) << &message[0] << Log::endl;
         glDeleteShader(vertexID);
         glDeleteShader(fragmentID);
         return -1;
         std::vector<char> message(logLength + 1);
         glGetShaderInfoLog(fragmentID, logLength, nullptr, &message[0]);
         if (result != GL_TRUE)
-            getLog() << "Fragment Shader compilation error:" << Log::endl;
-        getLog() << &message[0] << Log::endl;
+            Log::get(LOG_ERROR) << "Fragment Shader compilation error:" << Log::endl;
+        Log::get(LOG_ERROR) << &message[0] << Log::endl;
         glDeleteShader(vertexID);
         glDeleteShader(fragmentID);
         return -2;
         std::vector<char> message(logLength + 1);
         glGetProgramInfoLog(programID, logLength, nullptr, &message[0]);
         if (result != GL_TRUE)
-            getLog() << "Shader link error:" << Log::endl;
-        getLog() << &message[0] << Log::endl;
+            Log::get(LOG_ERROR) << "Shader link error:" << Log::endl;
+        Log::get(LOG_ERROR) << &message[0] << Log::endl;
         glDeleteShader(vertexID);
         glDeleteShader(fragmentID);
         glDeleteProgram(programID);
 unsigned int Shader::vertexArrayID = 0;
 
 int Shader::initialize() {
-    getLog() << "GL Ven.: " << glGetString(GL_VENDOR) << Log::endl;
-    getLog() << "GL Ren.: " << glGetString(GL_RENDERER) << Log::endl;
-    getLog() << "GL Ver.: " << glGetString(GL_VERSION) << Log::endl;
-    getLog() << "GLSL V.: " << glGetString(GL_SHADING_LANGUAGE_VERSION) << Log::endl;
+    Log::get(LOG_DEBUG) << "GL Ven.: " << glGetString(GL_VENDOR) << Log::endl;
+    Log::get(LOG_DEBUG) << "GL Ren.: " << glGetString(GL_RENDERER) << Log::endl;
+    Log::get(LOG_DEBUG) << "GL Ver.: " << glGetString(GL_VERSION) << Log::endl;
+    Log::get(LOG_DEBUG) << "GLSL V.: " << glGetString(GL_SHADING_LANGUAGE_VERSION) << Log::endl;
 
     glGenVertexArrays(1, &vertexArrayID);
     glBindVertexArray(vertexArrayID);
     //glClearColor(BLACK[0] / 256.0f, BLACK[1] / 256.0f, BLACK[2] / 256.0f, BLACK[3] / 256.0f);
     glClearColor(0.0f, 0.0f, 0.4f, 1.0f);
 
-    // Set up Z buffer
-    glEnable(GL_DEPTH_TEST);
-    // Accept fragment if closer to camera
+    set2DState(false);
     glDepthFunc(GL_LESS);
 
     glEnable(GL_BLEND);
     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
-    // Set up culling
-    //glEnable(GL_CULL_FACE); //! \todo Transparency?
-
     glPointSize(5.0f);
 
     if (textShader.compile(textShaderVertex, textShaderFragment) < 0)
     glDeleteVertexArrays(1, &vertexArrayID);
 }
 
+void Shader::set2DState(bool on) {
+    if (on) {
+        glDisable(GL_CULL_FACE);
+        glDisable(GL_DEPTH_TEST);
+    } else {
+        glEnable(GL_DEPTH_TEST);
+        glEnable(GL_CULL_FACE);
+    }
+}
+
 void Shader::drawGL(ShaderBuffer& vertices, ShaderBuffer& uvs, glm::vec4 color,
-                    unsigned int texture, TextureStorage store) {
+                    unsigned int texture, TextureStorage store, Shader& shader) {
     assert(vertices.getSize() == uvs.getSize());
     assert((vertices.getSize() % 3) == 0);
 
-    textShader.use();
-    textShader.loadUniform(0, Window::getSize());
-    textShader.loadUniform(1, texture, store);
-    textShader.loadUniform(2, color);
+    shader.use();
+    shader.loadUniform(0, Window::getSize());
+    shader.loadUniform(1, texture, store);
+    shader.loadUniform(2, color);
     vertices.bindBuffer(0, 2);
     uvs.bindBuffer(1, 2);
 
-    glDisable(GL_DEPTH_TEST);
+    set2DState(true);
     glDrawArrays(GL_TRIANGLES, 0, vertices.getSize());
-    glEnable(GL_DEPTH_TEST);
+    set2DState(false);
 
     vertices.unbind(0);
     uvs.unbind(1);
 }
 
 void Shader::drawGL(ShaderBuffer& vertices, ShaderBuffer& uvs, unsigned int texture,
-                    glm::mat4 MVP, TextureStorage store) {
+                    glm::mat4 MVP, TextureStorage store, Shader& shader) {
     assert(vertices.getSize() == uvs.getSize());
     assert((vertices.getSize() % 3) == 0);
 
-    textureShader.use();
-    textureShader.loadUniform(0, MVP);
-    textureShader.loadUniform(1, texture, store);
+    shader.use();
+    shader.loadUniform(0, MVP);
+    shader.loadUniform(1, texture, store);
     vertices.bindBuffer(0, 3);
     uvs.bindBuffer(1, 2);
     glDrawArrays(GL_TRIANGLES, 0, vertices.getSize());
 }
 
 void Shader::drawGL(ShaderBuffer& vertices, ShaderBuffer& uvs, ShaderBuffer& indices,
-                    unsigned int texture, glm::mat4 MVP, TextureStorage store) {
+                    unsigned int texture, glm::mat4 MVP, TextureStorage store,
+                    Shader& shader) {
     assert(vertices.getSize() == uvs.getSize());
     assert((indices.getSize() % 3) == 0);
 
-    textureShader.use();
-    textureShader.loadUniform(0, MVP);
-    textureShader.loadUniform(1, texture, store);
+    shader.use();
+    shader.loadUniform(0, MVP);
+    shader.loadUniform(1, texture, store);
     vertices.bindBuffer(0, 3);
     uvs.bindBuffer(1, 2);
     indices.bindBuffer();
     uvs.unbind(1);
 }
 
-void Shader::drawGL(ShaderBuffer& vertices, ShaderBuffer& colors, glm::mat4 MVP, unsigned int mode) {
+void Shader::drawGL(ShaderBuffer& vertices, ShaderBuffer& colors, glm::mat4 MVP,
+                    unsigned int mode, Shader& shader) {
     assert(vertices.getSize() == colors.getSize());
 
-    colorShader.use();
-    colorShader.loadUniform(0, MVP);
+    shader.use();
+    shader.loadUniform(0, MVP);
     vertices.bindBuffer(0, 3);
     colors.bindBuffer(1, 3);
     glDrawArrays(mode, 0, vertices.getSize());
 }
 
 void Shader::drawGL(ShaderBuffer& vertices, ShaderBuffer& colors, ShaderBuffer& indices,
-                    glm::mat4 MVP, unsigned int mode) {
+                    glm::mat4 MVP, unsigned int mode, Shader& shader) {
     assert(vertices.getSize() == colors.getSize());
 
-    colorShader.use();
-    colorShader.loadUniform(0, MVP);
+    shader.use();
+    shader.loadUniform(0, MVP);
     vertices.bindBuffer(0, 3);
     colors.bindBuffer(1, 3);
     indices.bindBuffer();

src/system/SoundAL.cpp

     alcMakeContextCurrent(context);
 
     if (alutInitWithoutContext(nullptr, nullptr) == AL_FALSE) {
-        getLog() << "SoundAL Error: " << alutGetErrorString(alutGetError()) << Log::endl;
+        Log::get(LOG_ERROR) << "SoundAL Error: " << alutGetErrorString(alutGetError()) << Log::endl;
         return -1;
     }
 
 
     clear();
     if (alutExit() == AL_FALSE)
-        getLog() << "SoundAL Error: " << alutGetErrorString(alutGetError()) << Log::endl;
+        Log::get(LOG_ERROR) << "SoundAL Error: " << alutGetErrorString(alutGetError()) << Log::endl;
     init = false;
 }
 
     alDeleteSources(sources.size(), &sources[0]);
     sources.clear();
     if (alGetError() != AL_NO_ERROR) {
-        getLog() << "SoundAL: Error while deleting sources!" << Log::endl;
+        Log::get(LOG_ERROR) << "SoundAL: Error while deleting sources!" << Log::endl;
     }
 
     alGetError();
     alDeleteSources(listenerSources.size(), &listenerSources[0]);
     listenerSources.clear();
     if (alGetError() != AL_NO_ERROR) {
-        getLog() << "SoundAL: Error while deleting listener sources!" << Log::endl;
+        Log::get(LOG_ERROR) << "SoundAL: Error while deleting listener sources!" << Log::endl;
     }
 
     alGetError();
     alDeleteBuffers(buffers.size(), &buffers[0]);
     buffers.clear();
     if (alGetError() != AL_NO_ERROR) {
-        getLog() << "SoundAL: Error while deleting buffers!" << Log::endl;
+        Log::get(LOG_ERROR) << "SoundAL: Error while deleting buffers!" << Log::endl;
     }
 
     for (int i = 0; i < 3; i++)
     alGetError();
     unsigned int r = alutCreateBufferFromFileImage(buffer, length);
     if (r == AL_NONE) {
-        getLog() << "SoundAL Error: " << alutGetErrorString(alutGetError()) << Log::endl;
+        Log::get(LOG_ERROR) << "SoundAL Error: " << alutGetErrorString(alutGetError()) << Log::endl;
         return -2;
     }
     buffers.push_back(r);
     alGetError();
     alGenSources(1, &id);
     if (alGetError() != AL_NO_ERROR) {
-        getLog() << "SoundAL Error: Could not create source!" << Log::endl;
+        Log::get(LOG_ERROR) << "SoundAL Error: Could not create source!" << Log::endl;
         return -2;
     }
 
         return -1;
 
     if ((source < 0) || (source >= sources.size()) || (pos == nullptr)) {
-        getLog() << "SoundAL: Can't position non-existing source!" << Log::endl;
+        Log::get(LOG_ERROR) << "SoundAL: Can't position non-existing source!" << Log::endl;
         return -2;
     }
 
         if ((source >= 0) && (source < listenerSources.size()))
             alSourcePlay(listenerSources.at(source));
         else
-            getLog() << "SoundAL: Can't play non-existing listener source!" << Log::endl;
+            Log::get(LOG_ERROR) << "SoundAL: Can't play non-existing listener source!" << Log::endl;
     } else {
         if ((source >= 0) && (source < sources.size()))
             alSourcePlay(sources.at(source));
         else
-            getLog() << "SoundAL: Can't play non-existing source!" << Log::endl;
+            Log::get(LOG_ERROR) << "SoundAL: Can't play non-existing source!" << Log::endl;
     }
 }
 

src/system/Window.cpp

 
 int Window::initialize() {
     int res;
+
 #ifdef USING_SDL
     res = WindowSDL::initialize();
 #elif defined(USING_GLFW)
 #else
     res = -1;
 #endif
+
     return res;
 }
 
 
 glm::i32vec2 Window::getSize() {
     glm::i32vec2 ret(-1, -1);
+
 #ifdef USING_SDL
     ret = WindowSDL::getSize();
 #elif defined(USING_GLFW)
 
 bool Window::getFullscreen() {
     bool ret;
+
 #ifdef USING_SDL
     ret = WindowSDL::getFullscreen();
 #elif defined(USING_GLFW)
 
 bool Window::getMousegrab() {
     bool ret;
+
 #ifdef USING_SDL
     ret = WindowSDL::getMousegrab();
 #elif defined(USING_GLFW)
 
 bool Window::getTextInput() {
     bool ret;
+
 #ifdef USING_SDL
     ret = WindowSDL::getTextInput();
 #elif defined(USING_GLFW)
     return ret;
 }
 
+void Window::setClipboard(const char* s) {
+#ifdef USING_SDL
+    WindowSDL::setClipboard(s);
+#elif defined(USING_GLFW)
+    WindowGLFW::setClipboard(s);
+#endif
+}
+
+const char* Window::getClipboard() {
+    const char* ret;
+
+#ifdef USING_SDL
+    ret = WindowSDL::getClipboard();
+#elif defined(USING_GLFW)
+    ret = WindowGLFW::getClipboard();
+#else
+    ret = nullptr;
+#endif
+
+    return ret;
+}
+

src/system/WindowGLFW.cpp

     textinput = t;
 }
 
+void WindowGLFW::setClipboard(const char* s) {
+    if (window)
+        glfwSetClipboardString(window, s);
+}
+
+const char* WindowGLFW::getClipboard() {
+    if (window)
+        return glfwGetClipboardString(window);
+
+    return nullptr;
+}
+
 void WindowGLFW::errorCallback(int error, const char* desc) {
-    getLog() << "GLFW Error (" << error << "): " << desc << Log::endl;
+    Log::get(LOG_ERROR) << "GLFW Error (" << error << "): " << desc << Log::endl;
 }
 
 void WindowGLFW::sizeCallback(GLFWwindow* w, int width, int height) {

src/system/WindowSDL.cpp

 
 int WindowSDL::initialize() {
     if (SDL_Init(SUBSYSTEMS_USED) != 0) {
-        getLog() << "SDL_Init Error: " << SDL_GetError() << Log::endl;
+        Log::get(LOG_ERROR) << "SDL_Init Error: " << SDL_GetError() << Log::endl;
         return -1;
     }
 
         || (SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3) != 0)
         || (SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3) != 0)
         || (SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE))) {
-        getLog() << "SDL_GL_SetAttribute Error: " << SDL_GetError() << Log::endl;
+        Log::get(LOG_ERROR) << "SDL_GL_SetAttribute Error: " << SDL_GetError() << Log::endl;
         return -2;
     }
 
     window = SDL_CreateWindow(VERSION, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
                               size.x, size.y, flags);
     if (!window) {
-        getLog() << "SDL_CreateWindow Error: " << SDL_GetError() << Log::endl;
+        Log::get(LOG_ERROR) << "SDL_CreateWindow Error: " << SDL_GetError() << Log::endl;
         return -3;
     }
 
     context = SDL_GL_CreateContext(window);
     if (!context) {
-        getLog() << "SDL_GL_CreateContext Error: " << SDL_GetError() << Log::endl;
+        Log::get(LOG_ERROR) << "SDL_GL_CreateContext Error: " << SDL_GetError() << Log::endl;
         return -4;
     }
 
     setTextInput(textinput);
 
     if (SDL_NumJoysticks() == 0) {
-        getLog() << "No Joystick found!" << Log::endl;
+        Log::get(LOG_INFO) << "No Joystick found!" << Log::endl;
         return 0;
     }
 
         if (SDL_IsGameController(i)) {
             controller = SDL_GameControllerOpen(i);
             if (controller) {
-                getLog() << "Using controller \"" << SDL_GameControllerName(controller)
+                Log::get(LOG_INFO) << "Using controller \"" << SDL_GameControllerName(controller)
                          << "\"..." << Log::endl;
                 break;
             } else {
-                getLog() << "Couldn't open controller \"" << SDL_GameControllerNameForIndex(i)
+                Log::get(LOG_WARNING) << "Couldn't open controller \"" << SDL_GameControllerNameForIndex(i)
                          << "\"!" << Log::endl;
             }
         } else {
-            getLog() << "Joystick \"" << SDL_JoystickNameForIndex(i)
-                     << "\" is no controller!" << Log::endl;
+            Log::get(LOG_WARNING) << "Joystick \"" << SDL_JoystickNameForIndex(i)
+                     << "\" is no compatible controller!" << Log::endl;
         }
     }
 
         SDL_StopTextInput();
 }
 
+void WindowSDL::setClipboard(const char* s) {
+    if (window) {
+        if (SDL_SetClipboardText(s) < 0) {
+            Log::get(LOG_ERROR) << "SDL_SetClipboardText Error: " << SDL_GetError() << Log::endl;
+        }
+    }
+}
+
+const char* WindowSDL::getClipboard() {
+    if (window) {
+        //! \fixme Should be freed with SDL_free(). But how, where, when?
+        const char* ret = SDL_GetClipboardText();
+        if (ret == nullptr) {
+            Log::get(LOG_ERROR) << "SDL_GetClipboardText Error: " << SDL_GetError() << Log::endl;
+        }
+        return ret;
+    }
+
+    return nullptr;
+}
+

src/utils/Folder.cpp

 
     std::vector<std::string> foundFiles, foundFolders;
     if (readFolderItems(foundFiles, foundFolders) != 0) {
-        getLog() << "Could not open folder " << name << Log::endl;
+        Log::get(LOG_ERROR) << "Could not open folder " << name << Log::endl;
     }
 
     if (!listDot) {

src/utils/binary.cpp

     return ret;
 }
 
-namespace {
-    /*! \fixme Left-Shift with signed integer is undefined!
-     *  So we can't use the same method as for unsigned integers.
-     *  Is there a portable way to read multi-byte signed integers,
-     *  without having to detect the endianness at run-time?
-     */
-    const int bigendiandetection = 1;
+/*! \fixme Left-Shift with signed integer is undefined!
+ *  So we can't use the same method as for unsigned integers.
+ *  Is there a portable way to read multi-byte signed integers,
+ *  without having to detect the endianness at run-time?
+ */
+const static int bigendiandetection = 1;
 #define ISBIGENDIAN() ((*reinterpret_cast<const char *>(&bigendiandetection)) == 0)
 
-    void swapByteOrder(char* d, unsigned int n) {
-        if (ISBIGENDIAN()) {
-            for (unsigned int i = 0; i < (n / 2); i++) {
-                char tmp = d[i];
-                d[i] = d[n - i - 1];
-                d[n - i - 1] = tmp;
-            }
+static void swapByteOrder(char* d, unsigned int n) {
+    if (ISBIGENDIAN()) {
+        for (unsigned int i = 0; i < (n / 2); i++) {
+            char tmp = d[i];
+            d[i] = d[n - i - 1];
+            d[n - i - 1] = tmp;
         }
     }
 }

src/utils/pcx.cpp

 
     // Basic validation
     if (!file.read((char*)(&header[0]), 128)) {
-        getLog() << "File not big enough for valid PCX header!" << Log::endl;
+        Log::get(LOG_ERROR) << "File not big enough for valid PCX header!" << Log::endl;
         delete [] header;
         return -1;
     }
 
     if (header[0] != 0x0A) {
-        getLog() << "Magic number at file start is wrong (" << header[0] << " != 0x0A)" << Log::endl;
+        Log::get(LOG_ERROR) << "Magic number at file start is wrong (" << header[0] << " != 0x0A)" << Log::endl;
         delete [] header;
         return -2;
     }
 
     if ((header[1] != 0) && ((header[1] < 2) || (header[1] > 5))) {
         // Valid: 0, 2, 3, 4, 5
-        getLog() << "Unknown PCX file format version (" << header[1] << ")" << Log::endl;
+        Log::get(LOG_ERROR) << "Unknown PCX file format version (" << header[1] << ")" << Log::endl;
         delete [] header;
         return -3;
     }
 
     if ((header[2] != 0) && (header[2] != 1)) {
-        getLog() << "Unknown PCX file encoding (" << header[2] << ")" << Log::endl;
+        Log::get(LOG_ERROR) << "Unknown PCX file encoding (" << header[2] << ")" << Log::endl;
         delete [] header;
         return -4;
     }
 
     if (header[3] != 8) {
-        getLog() << "Only supporting 8bit (" << header[3] << "bit)" << Log::endl;
+        Log::get(LOG_ERROR) << "Only supporting 8bit (" << header[3] << "bit)" << Log::endl;
         delete [] header;
         return -5;
     }
 
     if (header[64] != 0) {
-        getLog() << "Reserved field is  used (" << header[64] << " != 0)" << Log::endl;
+        Log::get(LOG_ERROR) << "Reserved field is  used (" << header[64] << " != 0)" << Log::endl;
         delete [] header;
         return -6;
     }
 
     // Basic validation
     if (!file.read((char*)(&header[0]), 128)) {
-        getLog() << "File not big enough for valid PCX header!" << Log::endl;
+        Log::get(LOG_ERROR) << "File not big enough for valid PCX header!" << Log::endl;
         delete [] header;
         return -1;
     }
 
     if (header[0] != 0x0A) {
-        getLog() << "Magic number at file start is wrong (" << header[0] << " != 0x0A)" << Log::endl;
+        Log::get(LOG_ERROR) << "Magic number at file start is wrong (" << header[0] << " != 0x0A)" << Log::endl;
         delete [] header;
         return -2;
     }
 
     if ((header[1] != 0) && ((header[1] < 2) || (header[1] > 5))) {
         // Valid: 0, 2, 3, 4, 5
-        getLog() << "Unknown PCX file format version (" << header[1] << ")" << Log::endl;
+        Log::get(LOG_ERROR) << "Unknown PCX file format version (" << header[1] << ")" << Log::endl;
         delete [] header;
         return -3;
     }
 
     if ((header[2] != 0) && (header[2] != 1)) {
-        getLog() << "Unknown PCX file encoding (" << header[2] << ")" << Log::endl;
+        Log::get(LOG_ERROR) << "Unknown PCX file encoding (" << header[2] << ")" << Log::endl;
         delete [] header;
         return -4;
     }
 
     if (header[3] != 8) {
-        getLog() << "Only supporting 8bit (" << header[3] << "bit)" << Log::endl;
+        Log::get(LOG_ERROR) << "Only supporting 8bit (" << header[3] << "bit)" << Log::endl;
         delete [] header;
         return -5;
     }
 
     if (header[64] != 0) {
-        getLog() << "Reserved field is  used (" << header[64] << " != 0)" << Log::endl;
+        Log::get(LOG_ERROR) << "Reserved field is  used (" << header[64] << " != 0)" << Log::endl;
         delete [] header;
         return -6;
     }
         unsigned int n = 1; // Run-length-encoding assumes 1
         int c = file.get();
         if (!file) {
-            getLog() << "Could not read data (" << i
-                      << (file.eof() ? " EOF" : "") << ")" << Log::endl;
+            Log::get(LOG_ERROR) << "Could not read data (" << i
+                                << (file.eof() ? " EOF" : "") << ")" << Log::endl;
             delete [] buffer;
             return -7;
         }
                 n = c & 0x3F;
                 c = file.get();
                 if (!file) {
-                    getLog() << "Could not read data rle (" << i
-                              << (file.eof() ? " EOF" : "") << ")" << Log::endl;
+                    Log::get(LOG_ERROR) << "Could not read data rle (" << i
+                                        << (file.eof() ? " EOF" : "") << ")" << Log::endl;
                     delete [] buffer;
                     return -8;
                 }
             for (unsigned int i = 0; i < 768; i++) {
                 palette[i] = (unsigned char)file.get();
                 if (!file) {
-                    getLog() << "Could not read 256 color palette (" << i << ")" << Log::endl;
+                    Log::get(LOG_ERROR) << "Could not read 256 color palette (" << i << ")" << Log::endl;
                     delete [] buffer;
                     delete [] palette;
                     return -9;
                     green = palette[(buffer[(y * totalBytes) + x] * 3) + 1];
                     blue = palette[(buffer[(y * totalBytes) + x] * 3) + 2];
                 } else {
-                    getLog() << "Unsupported number of planes (" << nPlanes << ")" << Log::endl;
+                    Log::get(LOG_ERROR) << "Unsupported number of planes (" << nPlanes << ")" << Log::endl;
                     delete [] buffer;
                     delete [] palette;
                     delete [] *image;
                 } else if (nPlanes == 1) {
                     red = green = blue = buffer[(y * totalBytes) + x];
                 } else {
-                    getLog() << "Unsupported number of planes (" << nPlanes << ")" << Log::endl;
+                    Log::get(LOG_ERROR) << "Unsupported number of planes (" << nPlanes << ")" << Log::endl;
                     delete [] buffer;
                     delete [] palette;
                     delete [] *image;

test/Script.cpp

     }); \
 }
 
-namespace {
-    int printDataScript(Script& s, bool strings) {
-        if (strings) {
-            printStrings(s.levelCount(), s.getLevelName, "Level Names");
-            printStrings(s.levelCount(), s.getLevelFilename, "Level Filenames");
-            printStrings(s.pictureCount(), s.getPictureFilename, "Picture Filenames");
-            printStrings(s.cutsceneCount(), s.getCutsceneFilename, "Cutscenes");
-            printStrings(s.titleCount(), s.getTitleFilename, "Titles");
-            printStrings(s.videoCount(), s.getVideoFilename, "Videos");
-            printStrings(s.gameStringCount(), s.getGameString, "Game Strings");
-            printStrings(s.pcStringCount(), s.getPCString, "PC Strings");
-
-            printStrings2D(4, s.levelCount(), s.getPuzzleString, "Puzzles");
-            printStrings2D(2, s.levelCount(), s.getPickupString, "Pickups");
-            printStrings2D(4, s.levelCount(), s.getKeyString, "Keys");
-        } else {
-            registerLambda(Script::OP_PICTURE, "Picture");
-            registerLambda(Script::OP_PSX_TRACK, "PSX-Track");
-            registerLambda(Script::OP_PSX_FMV, "PSX-FMV");
-            registerLambda(Script::OP_FMV, "Show FMV");
-            registerLambda(Script::OP_GAME, "Load level");
-            registerLambda(Script::OP_CUT, "Cutscene");
-            registerLambda(Script::OP_COMPLETE, "Level finished");
-            registerLambda(Script::OP_DEMO, "Demo sequence");
-            registerLambda(Script::OP_PSX_DEMO, "PSX-Demo");
-            registerLambda(Script::OP_END, "End of script");
-            registerLambda(Script::OP_TRACK, "Sound Track");
-            registerLambda(Script::OP_SUNSET, "Sunset");
-            registerLambda(Script::OP_LOAD_PIC, "Load picture");
-            registerLambda(Script::OP_DEADLY_WATER, "Deadly water");
-            registerLambda(Script::OP_REMOVE_WEAPONS, "Remove weapons");
-            registerLambda(Script::OP_GAMECOMPLETE, "End of game!");
-            registerLambda(Script::OP_CUTANGLE, "Cutscene angle");
-            registerLambda(Script::OP_NOFLOOR, "No floor, fall death");
-            registerLambda(Script::OP_STARTINV, "Inventory/Bonus");
-            registerLambda(Script::OP_STARTANIM, "Start animation");
-            registerLambda(Script::OP_SECRETS, "Secrets");
-            registerLambda(Script::OP_KILLTOCOMPLETE, "Kill to complete level");
-            registerLambda(Script::OP_REMOVE_AMMO, "Remove ammo");
-
-            for (unsigned int i = 0; i < (s.levelCount() + 1); i++) {
-                if (i == 0)
-                    std::cout << "Script for Title:" << std::endl;
-                else
-                    std::cout << "Script for \"" << s.getLevelName(i - 1) << "\" (" << i - 1 << "):" << std::endl;
-                int error = s.runScript(i);
-                if (error != 0) {
-                    std::cout << "Returned " << error << "..." << std::endl;
-                    return error;
-                }
-                std::cout << std::endl;
+static int printDataScript(Script& s, bool strings) {
+    if (strings) {
+        printStrings(s.levelCount(), s.getLevelName, "Level Names");
+        printStrings(s.levelCount(), s.getLevelFilename, "Level Filenames");
+        printStrings(s.pictureCount(), s.getPictureFilename, "Picture Filenames");
+        printStrings(s.cutsceneCount(), s.getCutsceneFilename, "Cutscenes");
+        printStrings(s.titleCount(), s.getTitleFilename, "Titles");
+        printStrings(s.videoCount(), s.getVideoFilename, "Videos");
+        printStrings(s.gameStringCount(), s.getGameString, "Game Strings");
+        printStrings(s.pcStringCount(), s.getPCString, "PC Strings");
+
+        printStrings2D(4, s.levelCount(), s.getPuzzleString, "Puzzles");
+        printStrings2D(2, s.levelCount(), s.getPickupString, "Pickups");
+        printStrings2D(4, s.levelCount(), s.getKeyString, "Keys");
+    } else {
+        registerLambda(Script::OP_PICTURE, "Picture");
+        registerLambda(Script::OP_PSX_TRACK, "PSX-Track");
+        registerLambda(Script::OP_PSX_FMV, "PSX-FMV");
+        registerLambda(Script::OP_FMV, "Show FMV");
+        registerLambda(Script::OP_GAME, "Load level");
+        registerLambda(Script::OP_CUT, "Cutscene");
+        registerLambda(Script::OP_COMPLETE, "Level finished");
+        registerLambda(Script::OP_DEMO, "Demo sequence");
+        registerLambda(Script::OP_PSX_DEMO, "PSX-Demo");
+        registerLambda(Script::OP_END, "End of script");
+        registerLambda(Script::OP_TRACK, "Sound Track");
+        registerLambda(Script::OP_SUNSET, "Sunset");
+        registerLambda(Script::OP_LOAD_PIC, "Load picture");
+        registerLambda(Script::OP_DEADLY_WATER, "Deadly water");
+        registerLambda(Script::OP_REMOVE_WEAPONS, "Remove weapons");
+        registerLambda(Script::OP_GAMECOMPLETE, "End of game!");
+        registerLambda(Script::OP_CUTANGLE, "Cutscene angle");
+        registerLambda(Script::OP_NOFLOOR, "No floor, fall death");
+        registerLambda(Script::OP_STARTINV, "Inventory/Bonus");
+        registerLambda(Script::OP_STARTANIM, "Start animation");
+        registerLambda(Script::OP_SECRETS, "Secrets");
+        registerLambda(Script::OP_KILLTOCOMPLETE, "Kill to complete level");
+        registerLambda(Script::OP_REMOVE_AMMO, "Remove ammo");
+
+        for (unsigned int i = 0; i < (s.levelCount() + 1); i++) {
+            if (i == 0)
+                std::cout << "Script for Title:" << std::endl;
+            else
+                std::cout << "Script for \"" << s.getLevelName(i - 1) << "\" (" << i - 1 << "):" << std::endl;
+            int error = s.runScript(i);
+            if (error != 0) {
+                std::cout << "Returned " << error << "..." << std::endl;
+                return error;
             }
+            std::cout << std::endl;
         }
-
-        return 0;
     }
 
-    int test(const char* file, unsigned int n) {
-        Script s;
+    return 0;
+}
 
-        std::cout << "Testing " << testDescription[n] << std::endl;
+static int test(const char* file, unsigned int n) {
+    Script s;
 
-        if (s.load(file) != 0) {
-            std::cout << "Could not open file " << file << std::endl;
-            return 1;
-        }
+    std::cout << "Testing " << testDescription[n] << std::endl;
 
-        if (s.gameStringCount() != testExpectedGameStringCount[n]) {
-            std::cout << "Game String Count " << s.gameStringCount() << " != " << testExpectedGameStringCount[n]
-                      << std::endl;
-            return 2;
-        }
+    if (s.load(file) != 0) {
+        std::cout << "Could not open file " << file << std::endl;
+        return 1;
+    }
 
-        if (s.pcStringCount() != testExpectedPlatformStringCount[n]) {
-            std::cout << "Platform String Count " << s.pcStringCount() << " != " <<
-                      testExpectedPlatformStringCount[n] << std::endl;
-            return 3;
-        }
+    if (s.gameStringCount() != testExpectedGameStringCount[n]) {
+        std::cout << "Game String Count " << s.gameStringCount() << " != " << testExpectedGameStringCount[n]
+                  << std::endl;
+        return 2;
+    }
 
-        std::cout << "Success!" << std::endl << std::endl;
-        return 0;
+    if (s.pcStringCount() != testExpectedPlatformStringCount[n]) {
+        std::cout << "Platform String Count " << s.pcStringCount() << " != " <<
+                  testExpectedPlatformStringCount[n] << std::endl;
+        return 3;
     }
 
-    int readPayloadChunk(const unsigned char* data, unsigned int size, const char* file) {
-        static const unsigned int bufferSize = 16384; // 16K should be enough for everybody :)
-        unsigned char buffer[bufferSize];
-
-        // Initialize decompression
-        z_stream stream;
-        stream.zalloc = Z_NULL;
-        stream.zfree =  Z_NULL;
-        stream.opaque = Z_NULL;
-        int error = inflateInit(&stream);
-        if (error != Z_OK) {
-            std::cout << "inflateInit() Error " << error << std::endl;
-            return 1;
-        }
+    std::cout << "Success!" << std::endl << std::endl;
+    return 0;
+}
 
-        // Inflate data in one go
-        stream.avail_in = size;
-        stream.next_in = const_cast<unsigned char*>(data);
-        stream.avail_out = bufferSize;
-        stream.next_out = buffer;
-        error = inflate(&stream, Z_FINISH);
-        if (error != Z_STREAM_END) {
-            std::cout << "inflate() Error " << error << std::endl;
-            return 2;
-        }
-        inflateEnd(&stream);
+static int readPayloadChunk(const unsigned char* data, unsigned int size, const char* file) {
+    static const unsigned int bufferSize = 16384; // 16K should be enough for everybody :)
+    unsigned char buffer[bufferSize];
+
+    // Initialize decompression
+    z_stream stream;
+    stream.zalloc = Z_NULL;
+    stream.zfree =  Z_NULL;
+    stream.opaque = Z_NULL;
+    int error = inflateInit(&stream);
+    if (error != Z_OK) {
+        std::cout << "inflateInit() Error " << error << std::endl;
+        return 1;
+    }
 
-        // Write buffer to file
-        std::ofstream s(file, std::ios_base::out | std::ios_base::binary);
-        s.write(reinterpret_cast<const char*>(buffer), bufferSize - stream.avail_out);
+    // Inflate data in one go
+    stream.avail_in = size;
+    stream.next_in = const_cast<unsigned char*>(data);
+    stream.avail_out = bufferSize;
+    stream.next_out = buffer;
+    error = inflate(&stream, Z_FINISH);
+    if (error != Z_STREAM_END) {
+        std::cout << "inflate() Error " << error << std::endl;
+        return 2;
+    }
+    inflateEnd(&stream);
 
-        return 0;
+    // Write buffer to file
+    std::ofstream s(file, std::ios_base::out | std::ios_base::binary);
+    s.write(reinterpret_cast<const char*>(buffer), bufferSize - stream.avail_out);
+
+    return 0;
+}
+
+static int runForPayload(unsigned int n, bool print, bool printData) {
+    assert(n < testPayloadCount);
+    // Get temp file name
+    char tmpFile[] = "/tmp/openraider_unit_test_0";
+    FILE* f;
+    while ((f = fopen(tmpFile, "r")) != NULL) {
+        fclose(f);
+        tmpFile[26]++;
     }
 
-    int runForPayload(unsigned int n, bool print, bool printData) {
-        assert(n < testPayloadCount);
-        // Get temp file name
-        char tmpFile[] = "/tmp/openraider_unit_test_0";
-        FILE* f;
-        while ((f = fopen(tmpFile, "r")) != NULL) {
-            fclose(f);
-            tmpFile[26]++;
-        }
+    std::cout << "Temporary test file: " << tmpFile << std::endl;
 
-        std::cout << "Temporary test file: " << tmpFile << std::endl;
-
-        int error = readPayloadChunk(testPayloads[n], testSizes[n], tmpFile);
-        if (error == 0) {
-            if (print) {
-                Script s;
-                error = s.load(tmpFile);
-                if (error == 0)
-                    error = printDataScript(s, printData);
-                else
-                    std::cout << "Error loading script!" << std::endl;
-            } else {
-                error = test(tmpFile, n);
-            }
+    int error = readPayloadChunk(testPayloads[n], testSizes[n], tmpFile);
+    if (error == 0) {
+        if (print) {
+            Script s;
+            error = s.load(tmpFile);
+            if (error == 0)
+                error = printDataScript(s, printData);
+            else
+                std::cout << "Error loading script!" << std::endl;
+        } else {
+            error = test(tmpFile, n);
         }
-
-        remove(tmpFile);
-        return error;
     }
+
+    remove(tmpFile);
+    return error;
 }
 
 int main(int argc, char* argv[]) {

test/binary.cpp

 #include "global.h"
 #include "utils/binary.h"
 
+const static char testData[] = {
+    // Unsigned Integers
+    -1,
+    -1, -1,
+    42, 42, 42, 42,
+    -1, -1, -1, -1, -1, 0, 0, 0,
+
+    // Signed Integers
+    -1,
+    92, -2,
+    102, -3, -1, -1,
+    66, 66, 66, 66, 66, 66, 66, 66
+};
+
+static float f1 = 3.1415926f;
+static float f2 = 42.23f;
+
+static void fillFile(const char* name) {
+    std::ofstream file(name, std::ios_base::out | std::ios_base::binary);
+    file.write(testData, sizeof(testData) / sizeof(testData[0]));
+    file.write(reinterpret_cast<char*>(&f1), sizeof(f1));
+    file.write(reinterpret_cast<char*>(&f2), sizeof(f2));
+}
+
+static int test(const char* name) {
+    BinaryFile file;
+    if (file.open(name) != 0) {
+        std::cout << "Error opening file " << name << std::endl;
+        return 1;
+    }
+
+    if (file.readU8() != 255) {
+        std::cout << "Error reading U8!" << std::endl;
+        return 2;
+    }
+
+    if (file.readU16() != 65535) {
+        std::cout << "Error reading U16!" << std::endl;
+        return 3;
+    }
+
+    if (file.readU32() != 707406378) {
+        std::cout << "Error reading U32!" << std::endl;
+        return 4;
+    }
 
-namespace {
-    const char testData[] = {
-        // Unsigned Integers
-        -1,
-        -1, -1,
-        42, 42, 42, 42,
-        -1, -1, -1, -1, -1, 0, 0, 0,
-
-        // Signed Integers
-        -1,
-        92, -2,
-        102, -3, -1, -1,
-        66, 66, 66, 66, 66, 66, 66, 66
-    };
-
-    float f1 = 3.1415926f;
-    float f2 = 42.23f;
-
-    void fillFile(const char* name) {
-        std::ofstream file(name, std::ios_base::out | std::ios_base::binary);
-        file.write(testData, sizeof(testData) / sizeof(testData[0]));
-        file.write(reinterpret_cast<char*>(&f1), sizeof(f1));
-        file.write(reinterpret_cast<char*>(&f2), sizeof(f2));
+    if (file.readU64() != 1099511627775) {
+        std::cout << "Error reading U64!" << std::endl;
+        return 5;
     }
 
-    int test(const char* name) {
-        BinaryFile file;
-        if (file.open(name) != 0) {
-            std::cout << "Error opening file " << name << std::endl;
-            return 1;
-        }
-
-        if (file.readU8() != 255) {
-            std::cout << "Error reading U8!" << std::endl;
-            return 2;
-        }
-
-        if (file.readU16() != 65535) {
-            std::cout << "Error reading U16!" << std::endl;
-            return 3;
-        }
-
-        if (file.readU32() != 707406378) {
-            std::cout << "Error reading U32!" << std::endl;
-            return 4;
-        }
-
-        if (file.readU64() != 1099511627775) {
-            std::cout << "Error reading U64!" << std::endl;
-            return 5;
-        }
-
-        if (file.read8() != -1) {
-            std::cout << "Error reading 8!" << std::endl;
-            return 6;
-        }
-
-        if (file.read16() != -420) {
-            std::cout << "Error reading 16!" << std::endl;
-            return 7;
-        }
-
-        if (file.read32() != -666) {
-            std::cout << "Error reading 32!" << std::endl;
-            return 8;
-        }
-
-        if (file.read64() != 4774451407313060418) {
-            std::cout << "Error reading 64!" << std::endl;
-            return 9;
-        }
-
-        std::cout << "This test will fail on big-endian machines!" << std::endl;
-
-        if (file.readFloat() != f1) {
-            std::cout << "Error reading float1!" << std::endl;
-            return 10;
-        }
-
-        if (file.readFloat() != f2) {
-            std::cout << "Error reading float2!" << std::endl;
-            return 11;
-        }
-
-        if (file.tell() != 38) {
-            std::cout << "Error, file position wrong!" << std::endl;
-            return 12;
-        }
-
-        return 0;
+    if (file.read8() != -1) {
+        std::cout << "Error reading 8!" << std::endl;
+        return 6;
     }
+
+    if (file.read16() != -420) {
+        std::cout << "Error reading 16!" << std::endl;
+        return 7;
+    }
+
+    if (file.read32() != -666) {
+        std::cout << "Error reading 32!" << std::endl;
+        return 8;
+    }
+
+    if (file.read64() != 4774451407313060418) {
+        std::cout << "Error reading 64!" << std::endl;
+        return 9;
+    }
+
+    std::cout << "This test will fail on big-endian machines!" << std::endl;
+
+    if (file.readFloat() != f1) {
+        std::cout << "Error reading float1!" << std::endl;
+        return 10;
+    }
+
+    if (file.readFloat() != f2) {
+        std::cout << "Error reading float2!" << std::endl;
+        return 11;
+    }
+
+    if (file.tell() != 38) {
+        std::cout << "Error, file position wrong!" << std::endl;
+        return 12;
+    }
+
+    return 0;
 }
 
 int main() {