imgui integration working more or less

ChangeLog.md

 
 ## OpenRaider (0.1.3) xythobuz <xythobuz@xythobuz.de>
 
+    [ 20140903 ]
+    * Finishing imgui integration, but now as UI layer and not on top of everything
+    * All global objects are now explicitly allocated in main
+
     [ 20140901 ]
     * Created abstract UI class handling “windows” like menu and console. Windows
       can be stacked arbitrarily. The top most gets keyboard/mouse/action events.

README.md

 | -----------------:|:--------------------- |
 | <Esc>       | Toggle menu           |
 | <backquote> | Console toggle on/off |
+| q                 | Toggle debug windows  |
 | w                 | Move forward          |
 | s                 | Move back             |
 | a                 | Move left             |

TODO.md

 
 * Depend on physfs for easier file location management
 * Depend on libcdio, use it to read original CDs or CUE/TOC/ISO images
-* Depend on imgui for nicer GUIs?
 * Add ability to play the FMVs. Format? VLC can play them!
 * Cut TGA image reader, currently only used for menu background?!
     * Need useful, always available image writer alternative for screenshots then

data/OpenRaider.ini

 
 bind menu     "escape"
 bind console  "backquote"
+bind debug    'q'
 bind forward  'w'
 bind backward 's'
 bind left     'a'

include/Debug.h

+/*!
+ * \file include/Debug.h
+ * \brief Debug UI
+ *
+ * \author xythobuz
+ */
+
+#ifndef _DEBUG_H_
+#define _DEBUG_H_
+
+#include "UI.h"
+
+class Debug : public UI {
+public:
+    Debug();
+    virtual ~Debug();
+
+    virtual int initialize();
+    virtual void eventsFinished();
+    virtual void display();
+
+    virtual void handleKeyboard(KeyboardButton key, bool pressed);
+    virtual void handleText(char *text, bool notFinished);
+    virtual void handleMouseClick(unsigned int x, unsigned int y, KeyboardButton button, bool released);
+    virtual void handleMouseMotion(int xrel, int yrel, int xabs, int yabs);
+    virtual void handleMouseScroll(int xrel, int yrel);
+
+private:
+    static void renderImGui(ImDrawList** const draw_lists, int count);
+
+    static unsigned int fontTex;
+};
+
+Debug &getDebug();
+
+#endif
+

include/Game.h

     Game();
     ~Game();
 
-    int initialize();
+    virtual int initialize();
 
     bool isLoaded();
 
 
     virtual void display();
     virtual void handleAction(ActionEvents action, bool isFinished);
-    virtual void handleMouseMotion(int xrel, int yrel);
+    virtual void handleMouseMotion(int xrel, int yrel, int xabs, int yabs);
     virtual void moveToTop() { }
     virtual void makeInvisible() { }
 

include/MenuFolder.h

 
 private:
 
-    virtual int initialize(std::string s);
-
-    virtual int initialize(Folder *folder, bool filter = true);
-
+    int init(std::string s);
+    int init(Folder *folder, bool filter = true);
     virtual void loadOrOpen();
 
     long mCursor;

include/UI.h

 #define _UI_H_
 
 #include <functional>
-#include <list>
 #include <memory>
-#include <tuple>
 #include <vector>
 
 #include "imgui/imgui.h"
 public:
     virtual ~UI();
 
+    virtual int initialize();
+    virtual void eventsFinished();
     virtual void display();
+
     virtual void handleKeyboard(KeyboardButton key, bool pressed);
     virtual void handleText(char *text, bool notFinished);
     virtual void handleAction(ActionEvents action, bool isFinished);
     virtual void handleMouseClick(unsigned int x, unsigned int y, KeyboardButton button, bool released);
-    virtual void handleMouseMotion(int xrel, int yrel);
+    virtual void handleMouseMotion(int xrel, int yrel, int xabs, int yabs);
     virtual void handleMouseScroll(int xrel, int yrel);
 
     virtual bool isOnTop();
     virtual void moveToTop();
     virtual void makeInvisible();
 
-    static int initialize();
-    static void eventsFinished();
-    static void displayInOrder();
+    // ----------------------------------
+
+    static int passInitialize();
+    static void passEvents();
+    static void passDisplay();
     static void passKeyboard(KeyboardButton key, bool pressed);
     static void passText(char *text, bool notFinished);
     static void passMouseClick(unsigned int x, unsigned int y, KeyboardButton button, bool released);
-    static void passMouseMotion(int xrel, int yrel);
+    static void passMouseMotion(int xrel, int yrel, int xabs, int yabs);
     static void passMouseScroll(int xrel, int yrel);
 
 protected:
     long zPos;
 
 private:
-    static void sendKeyboard(KeyboardButton key, bool pressed);
-    static void sendText(char *text, bool notFinished);
-    static void sendMouseClick(unsigned int x, unsigned int y, KeyboardButton button, bool released);
-    static void sendMouseMotion(int xrel, int yrel);
-    static void sendMouseScroll(int xrel, int yrel);
-    static void renderImGui(ImDrawList** const draw_lists, int count);
     static void findInList(UI *w, std::function<void (unsigned long i)> func);
     static bool isOnTop(unsigned long windowID);
     static void moveToTop(unsigned long windowID);
     static bool compareUIs(UI* a, UI* b);
 
     static std::vector<UI*> windows;
-    static std::list<std::tuple<KeyboardButton, bool>> keyboardEvents;
-    static std::list<std::tuple<char *, bool>> textEvents;
-    static std::list<std::tuple<unsigned int, unsigned int, KeyboardButton, bool>> clickEvents;
-    static std::list<std::tuple<int, int>> motionEvents;
-    static std::list<std::tuple<int, int>> scrollEvents;
 };
 
 #endif

include/global.h

 // Actions that can be bound to a key and sent to the game engine
 typedef enum {
     menuAction = 0,
-    consoleAction, // menu and console should always be the first two items
+    consoleAction,
+    debugAction,
+
     forwardAction,
     backwardAction,
     leftAction,

src/CMakeLists.txt

 # Set Source files
 set (SRCS ${SRCS} "Camera.cpp")
 set (SRCS ${SRCS} "Console.cpp")
+set (SRCS ${SRCS} "Debug.cpp")
 set (SRCS ${SRCS} "Entity.cpp")
 set (SRCS ${SRCS} "Exception.cpp")
 set (SRCS ${SRCS} "Font.cpp")

src/Camera.cpp

 #include "math/Matrix.h"
 #include "Camera.h"
 
-Camera &getCamera() {
-    static Camera gCamera;
-    return gCamera;
-}
-
 Camera::Camera() {
     mViewDistance = 14.0f;
     mRotationDeltaX = 1.0f;

src/Console.cpp

 #include "Window.h"
 #include "Console.h"
 
-Console &getConsole() {
-    static Console gConsole;
-    return gConsole;
-}
-
 Console::Console() {
     zPos = -1;
     mHistoryPointer = 0;

src/Debug.cpp

+/*!
+ * \file src/Debug.cpp
+ * \brief Debug UI
+ *
+ * \author xythobuz
+ */
+
+#include <algorithm>
+
+#include "global.h"
+#include "Debug.h"
+#include "TextureManager.h"
+#include "Window.h"
+
+#define STB_IMAGE_IMPLEMENTATION
+#include "imgui/stb_image.h"
+
+unsigned int Debug::fontTex;
+
+Debug::Debug() {
+    zPos = -1;
+
+    UI::addWindow(this);
+}
+
+Debug::~Debug() {
+    UI::removeWindow(this);
+}
+
+int Debug::initialize() {
+    ImGuiIO& io = ImGui::GetIO();
+    io.DisplaySize = ImVec2((float)getWindow().getWidth(), (float)getWindow().getHeight());
+    io.DeltaTime = 1.0f/60.0f;
+    io.PixelCenterOffset = 0.0f;
+
+    io.KeyMap[ImGuiKey_Tab] = tabKey;
+    io.KeyMap[ImGuiKey_LeftArrow] = leftKey;
+    io.KeyMap[ImGuiKey_RightArrow] = rightKey;
+    io.KeyMap[ImGuiKey_UpArrow] = upKey;
+    io.KeyMap[ImGuiKey_DownArrow] = downKey;
+    io.KeyMap[ImGuiKey_Home] = homeKey;
+    io.KeyMap[ImGuiKey_End] = endKey;
+    io.KeyMap[ImGuiKey_Delete] = delKey;
+    io.KeyMap[ImGuiKey_Backspace] = backspaceKey;
+    io.KeyMap[ImGuiKey_Enter] = enterKey;
+    io.KeyMap[ImGuiKey_Escape] = escapeKey;
+    io.KeyMap[ImGuiKey_A] = aKey;
+    io.KeyMap[ImGuiKey_C] = cKey;
+    io.KeyMap[ImGuiKey_V] = vKey;
+    io.KeyMap[ImGuiKey_X] = xKey;
+    io.KeyMap[ImGuiKey_Y] = yKey;
+    io.KeyMap[ImGuiKey_Z] = zKey;
+
+    io.RenderDrawListsFn = Debug::renderImGui;
+
+    // Load font texture
+    //glGenTextures(1, &fontTex);
+    //glBindTexture(GL_TEXTURE_2D, fontTex);
+    //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    const void* png_data;
+    unsigned int png_size;
+    ImGui::GetDefaultFontData(NULL, NULL, &png_data, &png_size);
+    int tex_x, tex_y, tex_comp;
+    void* tex_data = stbi_load_from_memory((const unsigned char*)png_data, (int)png_size, &tex_x, &tex_y, &tex_comp, 0);
+    //glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, tex_x, tex_y, 0, GL_RGBA, GL_UNSIGNED_BYTE, tex_data);
+    fontTex = getTextureManager().loadBufferSlot((unsigned char *)tex_data, tex_x, tex_y, RGBA, 32, 0);
+    stbi_image_free(tex_data);
+
+    return 0;
+}
+
+void Debug::display() {
+    ImGui::Render();
+}
+
+void Debug::eventsFinished() {
+    ImGui::NewFrame();
+}
+
+void Debug::handleKeyboard(KeyboardButton key, bool pressed) {
+    ImGuiIO& io = ImGui::GetIO();
+    io.KeysDown[key] = pressed;
+    io.KeyCtrl = io.KeysDown[leftctrlKey] | io.KeysDown[rightctrlKey];
+    io.KeyShift = io.KeysDown[leftshiftKey] | io.KeysDown[rightshiftKey];
+}
+
+void Debug::handleText(char *text, bool notFinished) {
+    ImGuiIO& io = ImGui::GetIO();
+    while (*text != '\0') {
+        io.AddInputCharacter(*text);
+        text++;
+    }
+}
+
+void Debug::handleMouseClick(unsigned int x, unsigned int y, KeyboardButton button, bool released) {
+    ImGuiIO& io = ImGui::GetIO();
+    io.MousePos = ImVec2((float)x, (float)y);
+    if (button == leftmouseKey) {
+        io.MouseDown[0] = !released;
+    } else if (button == rightmouseKey) {
+        io.MouseDown[1] = !released;
+    } else if (button == middlemouseKey) {
+        io.MouseDown[2] = !released;
+    } else if (button == fourthmouseKey) {
+        io.MouseDown[3] = !released;
+    } else if (button == fifthmouseKey) {
+        io.MouseDown[4] = !released;
+    }
+}
+
+void Debug::handleMouseMotion(int xrel, int yrel, int xabs, int yabs) {
+    ImGuiIO& io = ImGui::GetIO();
+    io.MousePos = ImVec2((float)xabs, (float)yabs);
+}
+
+void Debug::handleMouseScroll(int xrel, int yrel) {
+    ImGuiIO& io = ImGui::GetIO();
+    io.MouseWheel = (yrel != 0) ? yrel > 0 ? 1 : -1 : 0;
+}
+
+void Debug::renderImGui(ImDrawList** const cmd_lists, int cmd_lists_count) {
+    if (cmd_lists_count == 0)
+        return;
+
+    getWindow().glEnter2D();
+
+    glDisable(GL_CULL_FACE);
+    glDisable(GL_DEPTH_TEST);
+    glEnable(GL_SCISSOR_TEST);
+    //glEnableClientState(GL_VERTEX_ARRAY);
+    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+    glEnableClientState(GL_COLOR_ARRAY);
+
+    // Setup texture
+    getTextureManager().bindTextureId(fontTex);
+
+    const float width = ImGui::GetIO().DisplaySize.x;
+    const float height = ImGui::GetIO().DisplaySize.y;
+
+    // Render command lists
+    for (int n = 0; n < cmd_lists_count; n++) {
+        const ImDrawList* cmd_list = cmd_lists[n];
+        const unsigned char* vtx_buffer = (const unsigned char*)cmd_list->vtx_buffer.begin();
+        glVertexPointer(2, GL_FLOAT, sizeof(ImDrawVert), (void*)(vtx_buffer));
+        glTexCoordPointer(2, GL_FLOAT, sizeof(ImDrawVert), (void*)(vtx_buffer+8));
+        glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(ImDrawVert), (void*)(vtx_buffer+16));
+
+        int vtx_offset = 0;
+        const ImDrawCmd* pcmd_end = cmd_list->commands.end();
+        for (const ImDrawCmd* pcmd = cmd_list->commands.begin(); pcmd != pcmd_end; pcmd++) {
+            glScissor((int)pcmd->clip_rect.x, (int)(height - pcmd->clip_rect.w),
+                    (int)(pcmd->clip_rect.z - pcmd->clip_rect.x),
+                    (int)(pcmd->clip_rect.w - pcmd->clip_rect.y));
+            glDrawArrays(GL_TRIANGLES, vtx_offset, pcmd->vtx_count);
+            vtx_offset += pcmd->vtx_count;
+        }
+    }
+
+    glEnable(GL_CULL_FACE);
+    glEnable(GL_DEPTH_TEST);
+    glDisable(GL_SCISSOR_TEST);
+    glDisableClientState(GL_COLOR_ARRAY);
+    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+    //glDisableClientState(GL_VERTEX_ARRAY);
+
+    getWindow().glExit2D();
+}
+

src/Font.cpp

 #include "utils/strings.h"
 #include "Window.h"
 #include "Font.h"
-#include "FontManager.h"
-
-Font &getFont() {
-    static FontManager gFont;
-    return gFont;
-}
 
 Font::~Font() {
 }

src/Game.cpp

 std::map<int, int> gMapTex2Bump;
 #endif
 
-Game &getGame() {
-    static Game gGame;
-    return gGame;
-}
-
 Game::Game() {
     zPos = 0;
     mLoaded = false;
     }
 }
 
-void Game::handleMouseMotion(int xrel, int yrel) {
+void Game::handleMouseMotion(int xrel, int yrel, int xabs, int yabs) {
     if (mLoaded) {
         // Move Camera on X Axis
         if (xrel > 0)

src/Menu.cpp

 #include "Menu.h"
 #include "MenuFolder.h"
 
-Menu &getMenu() {
-    static MenuFolder gMenu;
-    return gMenu;
-}
-
 void Menu::showDialog(std::string msg, std::string btn1, std::string btn2,
         std::function<int (bool state)> callback) {
     // Only show one dialog at a time

src/MenuFolder.cpp

 }
 
 int MenuFolder::initialize() {
-    return initialize(getOpenRaider().getPakDir());
+    return init(getOpenRaider().getPakDir());
 }
 
-int MenuFolder::initialize(std::string s) {
-    return initialize(new Folder(s));
+int MenuFolder::init(std::string s) {
+    return init(new Folder(s));
 }
 
-int MenuFolder::initialize(Folder *folder, bool filter) {
+int MenuFolder::init(Folder *folder, bool filter) {
     if (mapFolder != nullptr)
         delete mapFolder;
+
     mapFolder = folder;
     mMin = mCursor = 0;
 
 
 void MenuFolder::loadOrOpen() {
     if (mCursor == 0) {
-        if (initialize(mapFolder->getParent().getPath()) != 0) {
+        if (init(mapFolder->getParent().getPath()) != 0) {
             showDialog("Error reading parent folder!", "OK", "");
         }
     } else if ((mCursor - 1) < mapFolder->folderCount()) {
-        if (initialize(mapFolder->getFolder(mCursor - 1).getPath()) != 0) {
+        if (init(mapFolder->getFolder(mCursor - 1).getPath()) != 0) {
             showDialog("Error reading subfolder!", "OK", "");
         }
     } else {
         loadOrOpen();
     } else if (key == dotKey) {
         hiddenState = !hiddenState;
-        initialize(mapFolder->getPath());
+        init(mapFolder->getPath());
     }
 
     if (mCursor > (mMin + items - 1)) {

src/OpenRaider.cpp

 #include "Window.h"
 #include "OpenRaider.h"
 
-OpenRaider &getOpenRaider() {
-    static OpenRaider gOpenRaider;
-    return gOpenRaider;
-}
-
 OpenRaider::OpenRaider() {
     mRunning = false;
     mFPS = false;
 
     for (int i = 0; i < ActionEventCount; i++)
         keyBindings[i] = unknownKey;
-
-    Command::fillCommandList();
 }
 
 std::string OpenRaider::getBaseDir() {
         return -5;
     }
 
-    // Initialize game engine
-    error = getGame().initialize();
+    // Initialize UIs
+    error = UI::passInitialize();
     if (error != 0) {
-        printf("Could not initialize Game (%d)!\n", error);
+        printf("Could not initialize UIs (%d)!\n", error);
         return -6;
     }
 
-    // Initialize main menu
-    error = getMenu().initialize();
-    if (error != 0) {
-        printf("Could not initialize Menu (%d)!\n", error);
-        return -7;
-    }
-
-    error = UI::initialize();
-    if (error != 0) {
-        printf("Could not Initialize UI (%d)!\n", error);
-        return -8;
-    }
-
 #ifdef DEBUG
     mFPS = true;
 #endif
     // Get keyboard and mouse input
     getWindow().eventHandling();
 
-    UI::displayInOrder();
+    ImGui::SetNewWindowDefaultPos(ImVec2(50, 50));
+    bool show_test_window = true;
+    ImGui::ShowTestWindow(&show_test_window);
+
+    UI::passDisplay();
 
     getWindow().glEnter2D();
 

src/Render.cpp

 #include "Window.h"
 #include "World.h"
 
-Render &getRender() {
-    static Render gRender;
-    return gRender;
-}
-
 Render::Render() {
     mSkyMesh = -1;
     mSkyMeshRotation = false;

src/Sound.cpp

 #include "global.h"
 #include "Sound.h"
 
-#ifdef USING_AL
-#include "SoundAL.h"
-#else
-#include "SoundNull.h"
-#endif
-
-Sound &getSound() {
-#ifdef USING_AL
-    static SoundAL gSound;
-#else
-    static SoundNull gSound;
-#endif
-    return gSound;
-}
-
 Sound::~Sound() {
 }
 

src/TextureManager.cpp

 #include "utils/png.h"
 #endif
 
-TextureManager &getTextureManager() {
-    static TextureManager gTextureManager;
-    return gTextureManager;
-}
-
 TextureManager::TextureManager() {
     mFlags = 0;
 }

src/UI.cpp

 
 #include "global.h"
 #include "Console.h"
+#include "Debug.h"
 #include "Menu.h"
 #include "OpenRaider.h"
 #include "TextureManager.h"
 #include "Window.h"
 
-#define STB_IMAGE_IMPLEMENTATION
-#include "imgui/stb_image.h"
-
 std::vector<UI*> UI::windows;
-std::list<std::tuple<KeyboardButton, bool>> UI::keyboardEvents;
-std::list<std::tuple<char *, bool>> UI::textEvents;
-std::list<std::tuple<unsigned int, unsigned int, KeyboardButton, bool>> UI::clickEvents;
-std::list<std::tuple<int, int>> UI::motionEvents;
-std::list<std::tuple<int, int>> UI::scrollEvents;
-
-static GLuint fontTex;
 
 UI::~UI() {
 }
 
+int UI::initialize() { return 0; }
+void UI::eventsFinished() { }
 void UI::display() { }
 void UI::handleKeyboard(KeyboardButton key, bool pressed) { }
 void UI::handleText(char *text, bool notFinished) { }
 void UI::handleAction(ActionEvents action, bool isFinished) { }
 void UI::handleMouseClick(unsigned int x, unsigned int y, KeyboardButton button, bool released) { }
-void UI::handleMouseMotion(int xrel, int yrel) { }
+void UI::handleMouseMotion(int xrel, int yrel, int xabs, int yabs) { }
 void UI::handleMouseScroll(int xrel, int yrel) { }
 
-int UI::initialize() {
-    ImGuiIO& io = ImGui::GetIO();
-    io.DisplaySize = ImVec2((float)getWindow().getWidth(), (float)getWindow().getHeight());
-    io.DeltaTime = 1.0f/60.0f;
-    io.PixelCenterOffset = 0.0f;
-
-    io.KeyMap[ImGuiKey_Tab] = tabKey;
-    io.KeyMap[ImGuiKey_LeftArrow] = leftKey;
-    io.KeyMap[ImGuiKey_RightArrow] = rightKey;
-    io.KeyMap[ImGuiKey_UpArrow] = upKey;
-    io.KeyMap[ImGuiKey_DownArrow] = downKey;
-    io.KeyMap[ImGuiKey_Home] = homeKey;
-    io.KeyMap[ImGuiKey_End] = endKey;
-    io.KeyMap[ImGuiKey_Delete] = delKey;
-    io.KeyMap[ImGuiKey_Backspace] = backspaceKey;
-    io.KeyMap[ImGuiKey_Enter] = enterKey;
-    io.KeyMap[ImGuiKey_Escape] = escapeKey;
-    io.KeyMap[ImGuiKey_A] = aKey;
-    io.KeyMap[ImGuiKey_C] = cKey;
-    io.KeyMap[ImGuiKey_V] = vKey;
-    io.KeyMap[ImGuiKey_X] = xKey;
-    io.KeyMap[ImGuiKey_Y] = yKey;
-    io.KeyMap[ImGuiKey_Z] = zKey;
-
-    io.RenderDrawListsFn = UI::renderImGui;
-
-    // Load font texture
-    //glGenTextures(1, &fontTex);
-    //glBindTexture(GL_TEXTURE_2D, fontTex);
-    //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-    //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-    const void* png_data;
-    unsigned int png_size;
-    ImGui::GetDefaultFontData(NULL, NULL, &png_data, &png_size);
-    int tex_x, tex_y, tex_comp;
-    void* tex_data = stbi_load_from_memory((const unsigned char*)png_data, (int)png_size, &tex_x, &tex_y, &tex_comp, 0);
-    //glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, tex_x, tex_y, 0, GL_RGBA, GL_UNSIGNED_BYTE, tex_data);
-    fontTex = getTextureManager().loadBufferSlot((unsigned char *)tex_data, tex_x, tex_y, RGBA, 32, 0);
-    stbi_image_free(tex_data);
-
-    return 0;
-}
-
-void UI::eventsFinished() {
-    ImGui::NewFrame();
-    ImGuiIO& io = ImGui::GetIO();
-
-    if (!io.WantCaptureKeyboard) {
-        while (keyboardEvents.size() > 0) {
-            sendKeyboard(std::get<0>(keyboardEvents.front()), std::get<1>(keyboardEvents.front()));
-            keyboardEvents.pop_front();
-        }
-
-        while (textEvents.size() > 0) {
-            sendText(std::get<0>(textEvents.front()), std::get<1>(textEvents.front()));
-            textEvents.pop_front();
-        }
-    }
-
-    if (!io.WantCaptureMouse) {
-        while (clickEvents.size() > 0) {
-            sendMouseClick(std::get<0>(clickEvents.front()), std::get<1>(clickEvents.front()),
-                    std::get<2>(clickEvents.front()), std::get<3>(clickEvents.front()));
-            clickEvents.pop_front();
-        }
-
-        while (motionEvents.size() > 0) {
-            sendMouseMotion(std::get<0>(motionEvents.front()), std::get<1>(motionEvents.front()));
-            motionEvents.pop_front();
-        }
-
-        while (scrollEvents.size() > 0) {
-            sendMouseScroll(std::get<0>(scrollEvents.front()), std::get<1>(scrollEvents.front()));
-            scrollEvents.pop_front();
+void UI::passKeyboard(KeyboardButton key, bool pressed) {
+    if (pressed) {
+        if (getOpenRaider().keyBindings[menuAction] == key) {
+            if (getMenu().isOnTop()) {
+                getMenu().makeInvisible();
+            } else {
+                getMenu().moveToTop();
+            }
+        } else if (getOpenRaider().keyBindings[consoleAction] == key) {
+            if (getConsole().isOnTop()) {
+                getConsole().makeInvisible();
+            } else {
+                getConsole().moveToTop();
+            }
+        } else if (getOpenRaider().keyBindings[debugAction] == key) {
+            if (getDebug().isOnTop()) {
+                getDebug().makeInvisible();
+            } else {
+                getDebug().moveToTop();
+            }
         }
     }
 
-    keyboardEvents.clear();
-    textEvents.clear();
-    clickEvents.clear();
-    motionEvents.clear();
-    scrollEvents.clear();
-
-    ImGui::SetNewWindowDefaultPos(ImVec2(50, 50));
-    bool show_test_window = true;
-    ImGui::ShowTestWindow(&show_test_window);
-}
+    auto maxIterator = std::max_element(windows.begin(), windows.end(), compareUIs);
+    (*maxIterator)->handleKeyboard(key, pressed);
 
-void UI::renderImGui(ImDrawList** const cmd_lists, int cmd_lists_count) {
-    if (cmd_lists_count == 0)
-        return;
-
-    glDisable(GL_CULL_FACE);
-    glDisable(GL_DEPTH_TEST);
-    glEnable(GL_SCISSOR_TEST);
-    //glEnableClientState(GL_VERTEX_ARRAY);
-    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
-    glEnableClientState(GL_COLOR_ARRAY);
-
-    // Setup texture
-    //glBindTexture(GL_TEXTURE_2D, fontTex);
-    //glEnable(GL_TEXTURE_2D);
-    getTextureManager().bindTextureId(fontTex);
-
-    const float width = ImGui::GetIO().DisplaySize.x;
-    const float height = ImGui::GetIO().DisplaySize.y;
-
-    /*
-    // Setup orthographic projection matrix
-    glMatrixMode(GL_PROJECTION);
-    glLoadIdentity();
-    glOrtho(0.0f, width, height, 0.0f, -1.0f, +1.0f);
-    glMatrixMode(GL_MODELVIEW);
-    glLoadIdentity();
-    */
-
-    // Render command lists
-    for (int n = 0; n < cmd_lists_count; n++) {
-        const ImDrawList* cmd_list = cmd_lists[n];
-        const unsigned char* vtx_buffer = (const unsigned char*)cmd_list->vtx_buffer.begin();
-        glVertexPointer(2, GL_FLOAT, sizeof(ImDrawVert), (void*)(vtx_buffer));
-        glTexCoordPointer(2, GL_FLOAT, sizeof(ImDrawVert), (void*)(vtx_buffer+8));
-        glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(ImDrawVert), (void*)(vtx_buffer+16));
-
-        int vtx_offset = 0;
-        const ImDrawCmd* pcmd_end = cmd_list->commands.end();
-        for (const ImDrawCmd* pcmd = cmd_list->commands.begin(); pcmd != pcmd_end; pcmd++) {
-            glScissor((int)pcmd->clip_rect.x, (int)(height - pcmd->clip_rect.w),
-                    (int)(pcmd->clip_rect.z - pcmd->clip_rect.x),
-                    (int)(pcmd->clip_rect.w - pcmd->clip_rect.y));
-            glDrawArrays(GL_TRIANGLES, vtx_offset, pcmd->vtx_count);
-            vtx_offset += pcmd->vtx_count;
+    for (int i = forwardAction; i < ActionEventCount; i++) {
+        if (getOpenRaider().keyBindings[i] == key) {
+            (*maxIterator)->handleAction((ActionEvents)i, !pressed);
         }
     }
 
-    glEnable(GL_CULL_FACE);
-    glEnable(GL_DEPTH_TEST);
-    glDisable(GL_SCISSOR_TEST);
-    glDisableClientState(GL_COLOR_ARRAY);
-    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
-    //glDisableClientState(GL_VERTEX_ARRAY);
-}
-
-void UI::passKeyboard(KeyboardButton key, bool pressed) {
-    keyboardEvents.push_back(std::make_tuple(key, pressed));
-
-    ImGuiIO& io = ImGui::GetIO();
-    io.KeysDown[key] = pressed;
-    io.KeyCtrl = io.KeysDown[leftctrlKey] | io.KeysDown[rightctrlKey];
-    io.KeyShift = io.KeysDown[leftshiftKey] | io.KeysDown[rightshiftKey];
+    bool mousegrab = (*maxIterator)->zPos == 0;
+    if (mousegrab != getWindow().getMousegrab())
+        getWindow().setMousegrab(mousegrab);
 }
 
 void UI::passText(char *text, bool notFinished) {
-    textEvents.push_back(std::make_tuple(text, notFinished));
-    // TODO
+    auto maxIterator = std::max_element(windows.begin(), windows.end(), compareUIs);
+    (*maxIterator)->handleText(text, notFinished);
 }
 
 void UI::passMouseClick(unsigned int x, unsigned int y, KeyboardButton button, bool released) {
-    clickEvents.push_back(std::make_tuple(x, y, button, released));
-    // TODO
+    auto maxIterator = std::max_element(windows.begin(), windows.end(), compareUIs);
+    (*maxIterator)->handleMouseClick(x, y, button, released);
+
+    for (int i = forwardAction; i < ActionEventCount; i++) {
+        if (getOpenRaider().keyBindings[i] == button) {
+            (*maxIterator)->handleAction((ActionEvents)i, released);
+        }
+    }
 }
 
-void UI::passMouseMotion(int xrel, int yrel) {
-    motionEvents.push_back(std::make_tuple(xrel, yrel));
-    // TODO
+void UI::passMouseMotion(int xrel, int yrel, int xabs, int yabs) {
+    auto maxIterator = std::max_element(windows.begin(), windows.end(), compareUIs);
+    (*maxIterator)->handleMouseMotion(xrel, yrel, xabs, yabs);
 }
 
 void UI::passMouseScroll(int xrel, int yrel) {
-    scrollEvents.push_back(std::make_tuple(xrel, yrel));
-
-    ImGuiIO& io = ImGui::GetIO();
-    io.MouseWheel = (yrel != 0) ? yrel > 0 ? 1 : -1 : 0;
+    auto maxIterator = std::max_element(windows.begin(), windows.end(), compareUIs);
+    (*maxIterator)->handleMouseScroll(xrel, yrel);
 }
 
 void UI::addWindow(UI* window) {
     });
 }
 
-void UI::displayInOrder() {
-    std::sort(windows.begin(), windows.end(), compareUIs);
+int UI::passInitialize() {
     for (auto &x : windows) {
-        if (x->zPos >= 0) {
-            x->display();
-        }
+        int error = x->initialize();
+        if (error != 0)
+            return error;
     }
 
-    ImGui::Render();
+    return 0;
 }
 
-void UI::sendKeyboard(KeyboardButton key, bool pressed) {
-    if (pressed) {
-        if (getOpenRaider().keyBindings[menuAction] == key) {
-            if (getMenu().isOnTop()) {
-                getMenu().makeInvisible();
-            } else {
-                getMenu().moveToTop();
-            }
-        } else if (getOpenRaider().keyBindings[consoleAction] == key) {
-            if (getConsole().isOnTop()) {
-                getConsole().makeInvisible();
-            } else {
-                getConsole().moveToTop();
-            }
-        }
-    }
-
-    auto maxIterator = std::max_element(windows.begin(), windows.end(), compareUIs);
-    (*maxIterator)->handleKeyboard(key, pressed);
-
-    for (int i = forwardAction; i < ActionEventCount; i++) {
-        if (getOpenRaider().keyBindings[i] == key) {
-            (*maxIterator)->handleAction((ActionEvents)i, !pressed);
-        }
+void UI::passEvents() {
+    for (auto &x : windows) {
+        x->eventsFinished();
     }
-
-    bool mousegrab = (*maxIterator)->zPos == 0;
-    if (mousegrab != getWindow().getMousegrab())
-        getWindow().setMousegrab(mousegrab);
 }
 
-void UI::sendText(char *text, bool notFinished) {
-    auto maxIterator = std::max_element(windows.begin(), windows.end(), compareUIs);
-    (*maxIterator)->handleText(text, notFinished);
-}
-
-void UI::sendMouseClick(unsigned int x, unsigned int y, KeyboardButton button, bool released) {
-    auto maxIterator = std::max_element(windows.begin(), windows.end(), compareUIs);
-    (*maxIterator)->handleMouseClick(x, y, button, released);
-
-    for (int i = forwardAction; i < ActionEventCount; i++) {
-        if (getOpenRaider().keyBindings[i] == button) {
-            (*maxIterator)->handleAction((ActionEvents)i, released);
+void UI::passDisplay() {
+    std::sort(windows.begin(), windows.end(), compareUIs);
+    for (auto &x : windows) {
+        if (x->zPos >= 0) {
+            x->display();
         }
     }
 }
 
-void UI::sendMouseMotion(int xrel, int yrel) {
-    auto maxIterator = std::max_element(windows.begin(), windows.end(), compareUIs);
-    (*maxIterator)->handleMouseMotion(xrel, yrel);
-}
-
-void UI::sendMouseScroll(int xrel, int yrel) {
-    auto maxIterator = std::max_element(windows.begin(), windows.end(), compareUIs);
-    (*maxIterator)->handleMouseScroll(xrel, yrel);
-}
-

src/Window.cpp

 #include "utils/strings.h"
 #include "Window.h"
 
-#ifdef USING_SDL
-#include "WindowSDL.h"
-#else
-#error No Windowing Library selected!
-#endif
-
-Window &getWindow() {
-#ifdef USING_SDL
-    static WindowSDL gWindow;
-#endif
-    return gWindow;
-}
-
 unsigned int Window::getWidth() {
     return mWidth;
 }

src/WindowSDL.cpp

     while(SDL_PollEvent(&event)) {
         switch (event.type) {
             case SDL_MOUSEMOTION:
-                UI::passMouseMotion(event.motion.xrel, event.motion.yrel);
+                UI::passMouseMotion(event.motion.xrel, event.motion.yrel, event.motion.x, event.motion.y);
                 break;
 
             case SDL_MOUSEBUTTONDOWN:
         }
     }
 
-    UI::eventsFinished();
+    UI::passEvents();
 }
 
 void WindowSDL::setTextInput(bool on) {

src/World.cpp

 #include "global.h"
 #include "World.h"
 
-World &getWorld() {
-    static World gWorld;
-    return gWorld;
-}
-
 World::~World() {
     destroy();
 }

src/commands/CommandBind.cpp

     getConsole() << "Available Actions:" << Console::endl;
     getConsole() << "  menu" << Console::endl;
     getConsole() << "  console" << Console::endl;
+    getConsole() << "  debug" << Console::endl;
     getConsole() << "  forward" << Console::endl;
     getConsole() << "  backward" << Console::endl;
     getConsole() << "  left" << Console::endl;
         return menuAction;
     } else if (action == "console") {
         return consoleAction;
+    } else if (action == "debug") {
+        return debugAction;
     } else if (action == "forward") {
         return forwardAction;
     } else if (action == "backward") {

src/main.cpp

 #include "Exception.h"
 #include "OpenRaider.h"
 #include "commander/commander.h"
+#include "commands/Command.h"
+
+#include "Camera.h"
+#include "Debug.h"
+#include "FontManager.h"
+#include "Game.h"
+#include "MenuFolder.h"
+#include "Render.h"
+#include "TextureManager.h"
+#include "World.h"
+
+#ifdef USING_AL
+#include "SoundAL.h"
+#else
+#include "SoundNull.h"
+#endif
+
+#ifdef USING_SDL
+#include "WindowSDL.h"
+#else
+#error No Windowing Library selected!
+#endif
 
 #ifndef UNIT_TEST
 
 namespace {
+    Camera* gCamera;
+    Console* gConsole;
+    Debug* gDebug;
+    FontManager* gFont;
+    Game* gGame;
+    MenuFolder* gMenu;
+    OpenRaider* gOpenRaider;
+    Render* gRender;
+    Sound* gSound;
+    TextureManager* gTextureManager;
+    Window* gWindow;
+    World* gWorld;
+
+    void createGlobals() {
+        gOpenRaider = new OpenRaider();
+        gCamera = new Camera();
+        gConsole = new Console();
+        gDebug = new Debug();
+        gFont = new FontManager();
+        gGame = new Game();
+        gMenu = new MenuFolder();
+        gRender = new Render();
+        gTextureManager = new TextureManager();
+        gWorld = new World();
+
+#ifdef USING_AL
+        gSound = new SoundAL();
+#else
+        gSound = new SoundNull();
+#endif
+
+#ifdef USING_SDL
+        gWindow = new WindowSDL();
+#endif
+    }
+
+    void deleteGlobals() {
+        delete gCamera;
+        delete gConsole;
+        delete gFont;
+        delete gGame;
+        delete gMenu;
+        delete gOpenRaider;
+        delete gRender;
+        delete gSound;
+        delete gTextureManager;
+        delete gWindow;
+        delete gWorld;
+    }
+
     bool configFileWasSpecified = false;
 
     void configFileCallback(command_t *self) {
         std::cout << "Web site  : http://github.com/xythobuz/OpenRaider" << std::endl;
         std::cout << "Contact   : xythobuz@xythobuz.de" << std::endl;
 #endif
+
+        deleteGlobals();
     }
 }
 
+Camera &getCamera() {
+    return *gCamera;
+}
+
+Console &getConsole() {
+    return *gConsole;
+}
+
+Debug& getDebug() {
+    return *gDebug;
+}
+
+Font &getFont() {
+    return *gFont;
+}
+
+Game &getGame() {
+    return *gGame;
+}
+
+Menu &getMenu() {
+    return *gMenu;
+}
+
+OpenRaider &getOpenRaider() {
+    return *gOpenRaider;
+}
+
+Render &getRender() {
+    return *gRender;
+}
+
+Sound &getSound() {
+    return *gSound;
+}
+
+TextureManager &getTextureManager() {
+    return *gTextureManager;
+}
+
+Window &getWindow() {
+    return *gWindow;
+}
+
+World &getWorld() {
+    return *gWorld;
+}
+
 int main(int argc, char* argv[]) {
+    createGlobals();
+    atexit(cleanupHandler);
+    Command::fillCommandList();
+
     command_t cmd;
     command_init(&cmd, argv[0], VERSION);
     //command_option(&cmd, "-v", "--verbose", "enable verbose output", functionPointer);
     getConsole() << "Initializing " << VERSION << Console::endl;
 #endif
 
-    atexit(cleanupHandler);
-
     int error = getOpenRaider().initialize();
     if (error != 0) {
         std::cout << "Could not initialize OpenRaider (" << error << ")!" << std::endl;

src/utils/tga.cpp

         fread(&comment, 1, header.comment_lenght, f);
         for (i = 0; i < 255; ++i) {
             if (!(comment[i] > 32 && comment[i] < 127))
-                comment[i] = 183; // print a dot for invalid text
+                comment[i] = '.'; // print a dot for invalid text
         }
         comment[255] = 0;
         printf("Comment: '%s'\n", comment);