RunTime now static. StaticMesh displays bounding boxes.

ChangeLog.md

 ## OpenRaider (0.1.3) xythobuz <xythobuz@xythobuz.de>
 
     [ 20141228 ]
-    * Room Bounding Boxes are now visualized in Wireframe mode (again)
-    * Window/WindowSDL/WindowGLFW are now completely static
+    * Room Bounding Boxes are now visualized in Wireframe mode (again).
+    * Window/WindowSDL/WindowGLFW are now completely static.
     * Shader class got some helper methods. Now in own file, system/Shader.
     * Tried to limit camera vertical rotation.
+    * RunTime is now completely static.
+    * StaticMeshes store both (?) of their bounding boxes. Displayed in Wireframe mode.
 
     [ 20141227 ]
     * Added rudimentary SDL2 Game Controller support.

include/RoomData.h

         return corner[i];
     }
 
-    void display(glm::mat4 VP);
+    void display(glm::mat4 VP, glm::vec3 colorLine, glm::vec3 colorDot);
 
   private:
     glm::vec3 corner[8];

include/RunTime.h

 #include <string>
 #include <vector>
 
-/*!
- * \brief Main Game Singleton
- */
 class RunTime {
   public:
+    static void initialize();
+    static void updateFPS();
+    static void display();
 
-    RunTime();
+    static KeyboardButton getKeyBinding(ActionEvents event);
+    static void setKeyBinding(ActionEvents event, KeyboardButton button);
 
-    std::string getBaseDir();
-    void setBaseDir(std::string dir);
-    std::string getPakDir();
-    void setPakDir(std::string dir);
-    std::string getAudioDir();
-    void setAudioDir(std::string dir);
-    std::string getDataDir();
-    void setDataDir(std::string dir);
+    static std::string getBaseDir() { return baseDir; }
+    static void setBaseDir(std::string dir) { baseDir = dir; }
 
-    KeyboardButton getKeyBinding(ActionEvents event);
-    void setKeyBinding(ActionEvents event, KeyboardButton button);
+    static std::string getPakDir() { return pakDir; }
+    static void setPakDir(std::string dir) { pakDir = dir; }
 
-    bool isRunning();
-    void setRunning(bool run);
+    static std::string getAudioDir() { return audioDir; }
+    static void setAudioDir(std::string dir) { audioDir = dir; }
 
-    bool getShowFPS();
-    void setShowFPS(bool fps);
+    static std::string getDataDir() { return dataDir; }
+    static void setDataDir(std::string dir) { dataDir = dir; }
 
-    void updateFPS();
-    unsigned long getFPS();
-    const std::vector<float>& getHistoryFPS();
+    static bool isRunning() { return gameIsRunning; }
+    static void setRunning(bool run) { gameIsRunning = run; }
 
-    float getLastFrameTime();
+    static bool getShowFPS() { return showFPS; }
+    static void setShowFPS(bool fps) { showFPS = fps; }
+
+    static unsigned long getFPS() { return fps; }
+    static const std::vector<float>& getHistoryFPS() { return history; }
+    static float getLastFrameTime() { return lastFrameTime / 1000.0f; }
 
   private:
-    std::string baseDir;
-    std::string pakDir;
-    std::string audioDir;
-    std::string dataDir;
-
-    KeyboardButton keyBindings[ActionEventCount];
-    bool gameIsRunning;
-    bool showFPS;
-
-    unsigned long lastTime, lastFrameTime;
-    unsigned long frameCount, frameCount2;
-    unsigned long frameTimeSum, frameTimeSum2;
-    unsigned long fps;
-    std::vector<float> history;
+    static std::string baseDir;
+    static std::string pakDir;
+    static std::string audioDir;
+    static std::string dataDir;
+
+    static KeyboardButton keyBindings[ActionEventCount];
+    static bool gameIsRunning;
+    static bool showFPS;
+
+    static unsigned long lastTime, lastFrameTime;
+    static unsigned long frameCount, frameCount2;
+    static unsigned long frameTimeSum, frameTimeSum2;
+    static unsigned long fps;
+    static std::vector<float> history;
 };
 
-RunTime& getRunTime();
-
 #endif
 

include/SoundManager.h

     // index --> SoundMap --> SoundDetails --> SampleIndices --> play
     static int playSound(int index);
 
+    static void display();
+
   private:
     static std::vector<SoundSource> soundSources;
     static std::vector<int> soundMap;

include/StaticMesh.h

 #ifndef _STATIC_MODEL_H_
 #define _STATIC_MODEL_H_
 
+#include <memory>
+
+#include "RoomData.h"
+
 class StaticMesh {
   public:
-    StaticMesh(int i, int m) : id(i), mesh(m) { }
+    StaticMesh(int i, int m, BoundingBox* b1, BoundingBox* b2)
+        : id(i), mesh(m), bbox1(b1), bbox2(b2) { }
     void display(glm::mat4 model, glm::mat4 view, glm::mat4 projection);
 
     int getID() { return id; }
   private:
     int id;
     int mesh;
+    std::unique_ptr<BoundingBox> bbox1, bbox2;
 };
 
 #endif

src/Camera.cpp

     if ((!dirty) && equal(posSpeed, 0.0f) && equal(rotSpeed, 0.0f))
         return false;
 
-    float dT = getRunTime().getLastFrameTime();
+    float dT = RunTime::getLastFrameTime();
     pos += quaternion * posSpeed * dT;
 
     if (glm::epsilonNotEqual(rotSpeed.x, 0.0f, controllerDeadZone))

src/Game.cpp

 void Game::display() {
     Render::display();
 
-    if (getRunTime().getShowFPS()) {
+    if (RunTime::getShowFPS()) {
         std::ostringstream s;
-        s << getRunTime().getFPS() << "FPS";
+        s << RunTime::getFPS() << "FPS";
         Font::drawText(10, Window::getSize().y - 25, 0.6f, BLUE, s.str());
 
         s.str("");

src/MenuFolder.cpp

 }
 
 int MenuFolder::initialize() {
-    return init(getRunTime().getPakDir());
+    return init(RunTime::getPakDir());
 }
 
 int MenuFolder::init(std::string s) {

src/Room.cpp

     }
 
     if (Render::getMode() == RenderMode::Wireframe)
-        bbox->display(projection * view);
+        bbox->display(projection * view, glm::vec3(0.0f, 1.0f, 0.0f), glm::vec3(1.0f, 0.0f, 1.0f));
 }
 
 bool Room::isWall(unsigned long sector) {

src/RoomData.cpp

 #include "system/Window.h"
 #include "RoomData.h"
 
-void BoundingBox::display(glm::mat4 VP) {
+void BoundingBox::display(glm::mat4 VP, glm::vec3 colorLine, glm::vec3 colorDot) {
     std::vector<glm::vec3> verts;
     std::vector<glm::vec3> cols;
     std::vector<unsigned short> inds;
 
     for (int i = 0; i < 8; i++) {
         verts.push_back(corner[i]);
-        cols.push_back(glm::vec3(0.0f, 1.0f, 0.0f));
+        cols.push_back(colorLine);
     }
 
     inds.push_back(0);
     inds.clear();
 
     for (int i = 0; i < 8; i++) {
-        cols.push_back(glm::vec3(1.0f, 0.0f, 0.0f));
+        cols.push_back(colorDot);
         inds.push_back(i);
     }
 
         assert(cache >= 0);
     }
 
-    glm::mat4 model = glm::rotate(glm::translate(glm::mat4(1.0f), pos),
-                                  angle, glm::vec3(0.0f, 1.0f, 0.0f));
+    glm::mat4 translate = glm::translate(glm::mat4(1.0f), pos);
+    glm::mat4 rotate = glm::rotate(glm::mat4(1.0f), angle, glm::vec3(0.0f, 1.0f, 0.0f));
+    glm::mat4 model = translate * rotate;
     getWorld().getStaticMesh(cache).display(model, view, projection);
 }
 

src/RunTime.cpp

  */
 
 #include "global.h"
+#include "Camera.h"
+#include "Render.h"
+#include "UI.h"
+#include "system/Sound.h"
+#include "system/Window.h"
 #include "utils/strings.h"
 #include "utils/time.h"
 #include "RunTime.h"
 
-RunTime::RunTime()
-    : baseDir(expandHomeDirectory("~/.OpenRaider")) {
+std::string RunTime::baseDir;
+std::string RunTime::pakDir;
+std::string RunTime::audioDir;
+std::string RunTime::dataDir;
+KeyboardButton RunTime::keyBindings[ActionEventCount];
+bool RunTime::gameIsRunning = false;
+bool RunTime::showFPS = false;
+unsigned long RunTime::lastTime = 0;
+unsigned long RunTime::lastFrameTime = 0;
+unsigned long RunTime::frameCount = 0;
+unsigned long RunTime::frameCount2 = 0;
+unsigned long RunTime::frameTimeSum = 0;
+unsigned long RunTime::frameTimeSum2 = 0;
+unsigned long RunTime::fps = 0;
+std::vector<float> RunTime::history;
+
+void RunTime::initialize() {
+    baseDir = expandHomeDirectory("~/.OpenRaider");
     pakDir = baseDir + "/paks";
     audioDir = baseDir + "/music";
     dataDir = baseDir + "/data";
 
-    gameIsRunning = false;
-
 #ifdef DEBUG
     showFPS = true;
-#else
-    showFPS = false;
 #endif
 
     for (int i = 0; i < ActionEventCount; i++)
     keyBindings[backwardAction] = sKey;
     keyBindings[leftAction] = aKey;
     keyBindings[rightAction] = dKey;
-
-    lastTime = 0;
-    frameCount = 0;
-    frameCount2 = 0;
-    frameTimeSum = 0;
-    frameTimeSum2 = 0;
-    fps = 0;
-}
-
-std::string RunTime::getBaseDir() {
-    return baseDir;
-}
-
-void RunTime::setBaseDir(std::string dir) {
-    baseDir = dir;
-}
-
-std::string RunTime::getPakDir() {
-    return pakDir;
-}
-
-void RunTime::setPakDir(std::string dir) {
-    pakDir = dir;
-}
-
-std::string RunTime::getAudioDir() {
-    return audioDir;
-}
-
-void RunTime::setAudioDir(std::string dir) {
-    audioDir = dir;
-}
-
-std::string RunTime::getDataDir() {
-    return dataDir;
-}
-
-void RunTime::setDataDir(std::string dir) {
-    dataDir = dir;
 }
 
 KeyboardButton RunTime::getKeyBinding(ActionEvents event) {
     keyBindings[event] = button;
 }
 
-bool RunTime::isRunning() {
-    return gameIsRunning;
-}
-
-void RunTime::setRunning(bool run) {
-    gameIsRunning = run;
-}
-
-bool RunTime::getShowFPS() {
-    return showFPS;
-}
-
-void RunTime::setShowFPS(bool fps) {
-    showFPS = fps;
-}
-
 void RunTime::updateFPS() {
     frameCount++;
     lastFrameTime = systemTimerGet() - lastTime;
     frameCount2++;
 }
 
-unsigned long RunTime::getFPS() {
-    return fps;
-}
-
-const std::vector<float>& RunTime::getHistoryFPS() {
-    return history;
-}
+void RunTime::display() {
+    if (ImGui::CollapsingHeader("RunTime Settings")) {
+        bool showFPS = getShowFPS();
+        if (ImGui::Checkbox("Show FPS##runtime", &showFPS)) {
+            setShowFPS(showFPS);
+        }
+        ImGui::SameLine();
+        bool running = isRunning();
+        if (ImGui::Checkbox("Running (!)##runtime", &running)) {
+            setRunning(running);
+        }
+        ImGui::SameLine();
+        bool sound = Sound::getEnabled();
+        if (ImGui::Checkbox("Sound##runtime", &sound)) {
+            Sound::setEnabled(sound);
+        }
+        ImGui::SameLine();
+        bool fullscreen = Window::getFullscreen();
+        if (ImGui::Checkbox("Fullscreen##runtime", &fullscreen)) {
+            Window::setFullscreen(fullscreen);
+        }
+
+        bool updateViewFrustum = Camera::getUpdateViewFrustum();
+        if (ImGui::Checkbox("Update Frustum##runtime", &updateViewFrustum)) {
+            Camera::setUpdateViewFrustum(updateViewFrustum);
+        }
+        ImGui::SameLine();
+        bool displayViewFrustum = Render::getDisplayViewFrustum();
+        if (ImGui::Checkbox("Show Frustum##runtime", &displayViewFrustum)) {
+            Render::setDisplayViewFrustum(displayViewFrustum);
+        }
+
+        float vol = Sound::getVolume();
+        if (ImGui::InputFloat("Volume##runtime", &vol, 0.0f, 0.0f, 3,
+                              ImGuiInputTextFlags_EnterReturnsTrue)) {
+            if (vol < 0.0f)
+                vol = 0.0f;
+            if (vol > 1.0f)
+                vol = 1.0f;
+            Sound::setVolume(vol);
+        }
+
+        int w = Window::getSize().x;
+        if (ImGui::InputInt("Width##runtime", &w, 10, 100, ImGuiInputTextFlags_EnterReturnsTrue)) {
+            if (w < 1)
+                w = 1;
+            Window::setSize(glm::vec2(w, Window::getSize().y));
+        }
+        int h = Window::getSize().y;
+        if (ImGui::InputInt("Height##runtime", &h, 10, 100, ImGuiInputTextFlags_EnterReturnsTrue)) {
+            if (h < 1)
+                h = 1;
+            Window::setSize(glm::vec2(Window::getSize().x, h));
+        }
+
+        static int fr = 0;
+        char buff[1024];
+        strncpy(buff, getBaseDir().c_str(), 1024);
+        if (ImGui::InputText("BaseDir##runtime", buff, 1024, ImGuiInputTextFlags_EnterReturnsTrue)) {
+            setBaseDir(buff);
+            fr = getFPS();
+        }
+        if (fr > 0) {
+            ImGui::SameLine();
+            ImGui::Text("Done!##runtime1");
+            fr--;
+        }
+
+        static int fr2 = 0;
+        char buff2[1024];
+        strncpy(buff2, getPakDir().c_str(), 1024);
+        if (ImGui::InputText("PakDir##runtime", buff2, 1024, ImGuiInputTextFlags_EnterReturnsTrue)) {
+            setPakDir(buff2);
+            fr2 = getFPS();
+        }
+        if (fr2 > 0) {
+            ImGui::SameLine();
+            ImGui::Text("Done!##runtime2");
+            fr2--;
+        }
+
+        static int fr3 = 0;
+        char buff3[1024];
+        strncpy(buff3, getAudioDir().c_str(), 1024);
+        if (ImGui::InputText("AudioDir##runtime", buff3, 1024, ImGuiInputTextFlags_EnterReturnsTrue)) {
+            setAudioDir(buff3);
+            fr3 = getFPS();
+        }
+        if (fr3 > 0) {
+            ImGui::SameLine();
+            ImGui::Text("Done!##runtime3");
+            fr3--;
+        }
+
+        static int fr4 = 0;
+        char buff4[1024];
+        strncpy(buff4, getDataDir().c_str(), 1024);
+        if (ImGui::InputText("DataDir##runtime", buff4, 1024, ImGuiInputTextFlags_EnterReturnsTrue)) {
+            setDataDir(buff4);
+            fr4 = getFPS();
+        }
+        if (fr4 > 0) {
+            ImGui::SameLine();
+            ImGui::Text("Done!##runtime4");
+            fr4--;
+        }
+    }
 
-float RunTime::getLastFrameTime() {
-    return lastFrameTime / 1000.0f;
+    if (ImGui::CollapsingHeader("Performance")) {
+        ImGui::Text("Uptime: %lums", systemTimerGet());
+        ImGui::Text("Frames per Second: %luFPS", getFPS());
+        if (getHistoryFPS().size() > 1) {
+            static bool scroll = true;
+            if (scroll) {
+                int offset = getHistoryFPS().size() - 1;
+                if (offset > 10)
+                    offset = 10;
+                ImGui::PlotLines("FPS", &getHistoryFPS()[1],
+                                 getHistoryFPS().size() - 1,
+                                 getHistoryFPS().size() - offset - 1);
+            } else {
+                ImGui::PlotLines("FPS", &getHistoryFPS()[1],
+                                 getHistoryFPS().size() - 1);
+            }
+            ImGui::SameLine();
+            ImGui::Checkbox("Scroll##fpsscroll", &scroll);
+        }
+    }
 }
 

src/SoundManager.cpp

  */
 
 #include "global.h"
+#include "UI.h"
 #include "system/Sound.h"
 #include "SoundManager.h"
 
     }
 }
 
+void SoundManager::display() {
+    if (ImGui::CollapsingHeader("Sound Map Player")) {
+        if (!Sound::getEnabled()) {
+            ImGui::Text("Please enable Sound first!");
+            if (ImGui::Button("Enable Sound!")) {
+                Sound::setEnabled(true);
+            }
+        } else if (Sound::numBuffers() == 0) {
+            ImGui::Text("Please load a level!");
+        } else {
+            static int index = 0;
+            ImGui::PushItemWidth(ImGui::GetWindowWidth() * 0.5f);
+            ImGui::SliderInt("##soundslide", &index, 0, sizeSoundMap() - 1);
+            ImGui::PopItemWidth();
+            ImGui::SameLine();
+            if (ImGui::Button("+##soundplus", ImVec2(0, 0), true)) {
+                if (index < (sizeSoundMap() - 1))
+                    index++;
+                else
+                    index = 0;
+            }
+            ImGui::SameLine();
+            if (ImGui::Button("-##soundminus", ImVec2(0, 0), true)) {
+                if (index > 0)
+                    index--;
+                else
+                    index = sizeSoundMap() - 1;
+            }
+            ImGui::SameLine();
+            if (ImGui::Button("Play##soundplay")) {
+                playSound(index);
+            }
+
+            ImGui::Text("Index: %d", getIndex(index));
+        }
+    }
+}
+

src/StaticMesh.cpp

  */
 
 #include "global.h"
+#include "Render.h"
 #include "World.h"
 #include "StaticMesh.h"
 
 void StaticMesh::display(glm::mat4 model, glm::mat4 view, glm::mat4 projection) {
     getWorld().getMesh(mesh).display(model, view, projection);
+
+    if (Render::getMode() == RenderMode::Wireframe) {
+        bbox1->display(projection * view * model,
+                       glm::vec3(1.0f, 0.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f));
+        bbox2->display(projection * view * model,
+                       glm::vec3(1.0f, 0.0f, 1.0f), glm::vec3(0.0f, 0.0f, 1.0f));
+    }
 }
 

src/TextureManager.cpp

     }
 
     //! \fixme Temporary?
-    std::string filename = getRunTime().getPakDir() + "/tr2/TITLE.PCX";
+    std::string filename = RunTime::getPakDir() + "/tr2/TITLE.PCX";
     if (loadPCX(filename.c_str(), TextureStorage::SYSTEM, TEXTURE_SPLASH) < 0) {
-        filename = getRunTime().getDataDir() + "/splash.tga";
+        filename = RunTime::getDataDir() + "/splash.tga";
         if (loadTGA(filename.c_str(), TextureStorage::SYSTEM, TEXTURE_SPLASH) < 0) {
             return -2;
         }

src/UI.cpp

 std::list<std::tuple<int, int>> UI::scrollEvents;
 
 int UI::initialize() {
-    iniFilename = getRunTime().getBaseDir() + "/imgui.ini";
-    logFilename = getRunTime().getBaseDir() + "/imgui_log.txt";
+    iniFilename = RunTime::getBaseDir() + "/imgui.ini";
+    logFilename = RunTime::getBaseDir() + "/imgui_log.txt";
 
     ImGuiIO& io = ImGui::GetIO();
     io.DisplaySize = ImVec2(Window::getSize().x, Window::getSize().y);
                 getMenu().handleKeyboard(std::get<0>(i), std::get<1>(i));
             } else {
                 for (int n = forwardAction; n < ActionEventCount; n++) {
-                    if (getRunTime().getKeyBinding((ActionEvents)n) == std::get<0>(i))
+                    if (RunTime::getKeyBinding((ActionEvents)n) == std::get<0>(i))
                         getGame().handleAction((ActionEvents)n, !std::get<1>(i));
                 }
             }
 
         if (std::get<1>(i)) {
             if (!visible) {
-                if (getRunTime().getKeyBinding(menuAction) == std::get<0>(i)) {
+                if (RunTime::getKeyBinding(menuAction) == std::get<0>(i)) {
                     getMenu().setVisible(!getMenu().isVisible());
                 }
             }
 
             if ((!io.WantCaptureKeyboard) || (!visible)) {
-                if (getRunTime().getKeyBinding(debugAction) == std::get<0>(i)) {
+                if (RunTime::getKeyBinding(debugAction) == std::get<0>(i)) {
                     if (!metaKeyIsActive)
                         visible = !visible;
                 }
     Console::display();
 
     if (ImGui::Begin("Engine")) {
-        if (ImGui::CollapsingHeader("Engine Info")) {
-            ImGui::Text("Uptime: %lums", systemTimerGet());
-            ImGui::Text("Frames per Second: %luFPS", getRunTime().getFPS());
-            if (getRunTime().getHistoryFPS().size() > 1) {
-                static bool scroll = true;
-                if (scroll) {
-                    int offset = getRunTime().getHistoryFPS().size() - 1;
-                    if (offset > 10)
-                        offset = 10;
-                    ImGui::PlotLines("FPS", &getRunTime().getHistoryFPS()[1],
-                                     getRunTime().getHistoryFPS().size() - 1,
-                                     getRunTime().getHistoryFPS().size() - offset - 1);
-                } else {
-                    ImGui::PlotLines("FPS", &getRunTime().getHistoryFPS()[1],
-                                     getRunTime().getHistoryFPS().size() - 1);
-                }
-                ImGui::SameLine();
-                ImGui::Checkbox("Scroll##fpsscroll", &scroll);
-            }
-        }
-
-        if (ImGui::CollapsingHeader("RunTime Settings")) {
-            bool showFPS = getRunTime().getShowFPS();
-            if (ImGui::Checkbox("Show FPS##runtime", &showFPS)) {
-                getRunTime().setShowFPS(showFPS);
-            }
-            ImGui::SameLine();
-            bool running = getRunTime().isRunning();
-            if (ImGui::Checkbox("Running (!)##runtime", &running)) {
-                getRunTime().setRunning(running);
-            }
-            ImGui::SameLine();
-            bool sound = Sound::getEnabled();
-            if (ImGui::Checkbox("Sound##runtime", &sound)) {
-                Sound::setEnabled(sound);
-            }
-            ImGui::SameLine();
-            bool fullscreen = Window::getFullscreen();
-            if (ImGui::Checkbox("Fullscreen##runtime", &fullscreen)) {
-                Window::setFullscreen(fullscreen);
-            }
-
-            bool updateViewFrustum = Camera::getUpdateViewFrustum();
-            if (ImGui::Checkbox("Update Frustum##runtime", &updateViewFrustum)) {
-                Camera::setUpdateViewFrustum(updateViewFrustum);
-            }
-            ImGui::SameLine();
-            bool displayViewFrustum = Render::getDisplayViewFrustum();
-            if (ImGui::Checkbox("Show Frustum##runtime", &displayViewFrustum)) {
-                Render::setDisplayViewFrustum(displayViewFrustum);
-            }
-
-            float vol = Sound::getVolume();
-            if (ImGui::InputFloat("Volume##runtime", &vol, 0.0f, 0.0f, 3,
-                                  ImGuiInputTextFlags_EnterReturnsTrue)) {
-                if (vol < 0.0f)
-                    vol = 0.0f;
-                if (vol > 1.0f)
-                    vol = 1.0f;
-                Sound::setVolume(vol);
-            }
-
-            int w = Window::getSize().x;
-            if (ImGui::InputInt("Width##runtime", &w, 10, 100, ImGuiInputTextFlags_EnterReturnsTrue)) {
-                if (w < 1)
-                    w = 1;
-                Window::setSize(glm::vec2(w, Window::getSize().y));
-            }
-            int h = Window::getSize().y;
-            if (ImGui::InputInt("Height##runtime", &h, 10, 100, ImGuiInputTextFlags_EnterReturnsTrue)) {
-                if (h < 1)
-                    h = 1;
-                Window::setSize(glm::vec2(Window::getSize().x, h));
-            }
-
-            static int fr = 0;
-            char buff[1024];
-            strncpy(buff, getRunTime().getBaseDir().c_str(), 1024);
-            if (ImGui::InputText("BaseDir##runtime", buff, 1024, ImGuiInputTextFlags_EnterReturnsTrue)) {
-                getRunTime().setBaseDir(buff);
-                fr = getRunTime().getFPS();
-            }
-            if (fr > 0) {
-                ImGui::SameLine();
-                ImGui::Text("Done!##runtime1");
-                fr--;
-            }
-
-            static int fr2 = 0;
-            char buff2[1024];
-            strncpy(buff2, getRunTime().getPakDir().c_str(), 1024);
-            if (ImGui::InputText("PakDir##runtime", buff2, 1024, ImGuiInputTextFlags_EnterReturnsTrue)) {
-                getRunTime().setPakDir(buff2);
-                fr2 = getRunTime().getFPS();
-            }
-            if (fr2 > 0) {
-                ImGui::SameLine();
-                ImGui::Text("Done!##runtime2");
-                fr2--;
-            }
-
-            static int fr3 = 0;
-            char buff3[1024];
-            strncpy(buff3, getRunTime().getAudioDir().c_str(), 1024);
-            if (ImGui::InputText("AudioDir##runtime", buff3, 1024, ImGuiInputTextFlags_EnterReturnsTrue)) {
-                getRunTime().setAudioDir(buff3);
-                fr3 = getRunTime().getFPS();
-            }
-            if (fr3 > 0) {
-                ImGui::SameLine();
-                ImGui::Text("Done!##runtime3");
-                fr3--;
-            }
-
-            static int fr4 = 0;
-            char buff4[1024];
-            strncpy(buff4, getRunTime().getDataDir().c_str(), 1024);
-            if (ImGui::InputText("DataDir##runtime", buff4, 1024, ImGuiInputTextFlags_EnterReturnsTrue)) {
-                getRunTime().setDataDir(buff4);
-                fr4 = getRunTime().getFPS();
-            }
-            if (fr4 > 0) {
-                ImGui::SameLine();
-                ImGui::Text("Done!##runtime4");
-                fr4--;
-            }
-        }
-
-        ImGui::Separator();
-
-        if (ImGui::CollapsingHeader("Sound Map Player")) {
-            if (!Sound::getEnabled()) {
-                ImGui::Text("Please enable Sound first!");
-                if (ImGui::Button("Enable Sound!")) {
-                    Sound::setEnabled(true);
-                }
-            } else if (Sound::numBuffers() == 0) {
-                ImGui::Text("Please load a level!");
-            } else {
-                static int index = 0;
-                ImGui::PushItemWidth(ImGui::GetWindowWidth() * 0.5f);
-                ImGui::SliderInt("##soundslide", &index, 0, SoundManager::sizeSoundMap() - 1);
-                ImGui::PopItemWidth();
-                ImGui::SameLine();
-                if (ImGui::Button("+##soundplus", ImVec2(0, 0), true)) {
-                    if (index < (SoundManager::sizeSoundMap() - 1))
-                        index++;
-                    else
-                        index = 0;
-                }
-                ImGui::SameLine();
-                if (ImGui::Button("-##soundminus", ImVec2(0, 0), true)) {
-                    if (index > 0)
-                        index--;
-                    else
-                        index = SoundManager::sizeSoundMap() - 1;
-                }
-                ImGui::SameLine();
-                if (ImGui::Button("Play##soundplay")) {
-                    SoundManager::playSound(index);
-                }
-
-                ImGui::Text("Index: %d", SoundManager::getIndex(index));
-            }
-        }
+        RunTime::display();
+        SoundManager::display();
 
         /*
         static bool visibleTex = false;
                                                         ImGui::GetWindowPos().x - (ImGui::GetWindowWidth() / 2),
                                                         ImGui::GetWindowPos().y,
                                                         (ImGui::GetWindowWidth() / 2), (ImGui::GetWindowWidth() / 2));
-                        fr = getRunTime().getFPS() / 2;
+                        fr = RunTime::getFPS() / 2;
                         tile = getTextureManager().getNextTileAnimation(tile);
                     }
                     ImGui::Text("Current Tile: %d", tile);
                                                        ImGui::GetWindowPos().x - (ImGui::GetWindowWidth() / 2),
                                                        ImGui::GetWindowPos().y,
                                                        (ImGui::GetWindowWidth() / 2), (ImGui::GetWindowWidth() / 2));
-                        fr = getRunTime().getFPS() / 10;
+                        fr = RunTime::getFPS() / 10;
                         if (sprite < (getWorld().getSprite(index).size() - 1))
                             sprite++;
                         else
         }
         */
 
-        ImGui::Separator();
-
         if (ImGui::CollapsingHeader("ImGui/Debug UI Help")) {
             //ImGui::TextWrapped("DebugViewer Textures/Textiles/Sprites will be drawn on"
             //                   " the left side and scale with the size of this window!");

src/commands/CommandBind.cpp

             return -3;
         }
 
-        getRunTime().setKeyBinding(e, c);
+        RunTime::setKeyBinding(e, c);
         return 0;
     }
 }

src/commands/CommandEngine.cpp

 }
 
 int CommandLoad::execute(std::istream& args) {
-    if (!getRunTime().isRunning()) {
+    if (!RunTime::isRunning()) {
         getLog() << "Use load command interactively!" << Log::endl;
         return -1;
     }
 }
 
 int CommandScreenshot::execute(std::istream& args) {
-    if (!getRunTime().isRunning()) {
+    if (!RunTime::isRunning()) {
         getLog() << "Use sshot command interactively!" << Log::endl;
         return -1;
     }
 
-    std::string filename(getRunTime().getBaseDir());
+    std::string filename(RunTime::getBaseDir());
     filename += "/sshots/";
     filename += VERSION_SHORT;
 

src/commands/CommandGame.cpp

 }
 
 int CommandPos::execute(std::istream& args) {
-    if ((!getRunTime().isRunning()) || (!getGame().isLoaded())) {
+    if ((!RunTime::isRunning()) || (!getGame().isLoaded())) {
         getLog() << "Use pos command interactively!" << Log::endl;
         return -1;
     }
 }
 
 int CommandViewmodel::execute(std::istream& args) {
-    if ((!getRunTime().isRunning()) || (!getGame().isLoaded())) {
+    if ((!RunTime::isRunning()) || (!getGame().isLoaded())) {
         getLog() << "Use viewmodel command interactively!" << Log::endl;
         return -1;
     }

src/commands/CommandMove.cpp

 }
 
 int CommandMove::execute(std::istream& args) {
-    if ((!getRunTime().isRunning()) || (!getGame().isLoaded())) {
+    if ((!RunTime::isRunning()) || (!getGame().isLoaded())) {
         getLog() << "Use move command interactively!" << Log::endl;
         return -1;
     }

src/commands/CommandSet.cpp

         }
 
         // Expand Names
-        s = findAndReplace(s, "$(pakdir)", getRunTime().getPakDir());
-        s = findAndReplace(s, "$(audiodir)", getRunTime().getAudioDir());
-        s = findAndReplace(s, "$(datadir)", getRunTime().getDataDir());
-        s = findAndReplace(s, "$(basedir)", getRunTime().getBaseDir());
+        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);
             getLog() << "set-fps-Error: Invalid value" << Log::endl;
             return -8;
         }
-        getRunTime().setShowFPS(fps);
+        RunTime::setShowFPS(fps);
     } else if (var.compare("basedir") == 0) {
         std::string temp;
         args >> temp;
-        getRunTime().setBaseDir(expandNames(temp));
+        RunTime::setBaseDir(expandNames(temp));
     } else if (var.compare("pakdir") == 0) {
         std::string temp;
         args >> temp;
-        getRunTime().setPakDir(expandNames(temp));
+        RunTime::setPakDir(expandNames(temp));
     } else if (var.compare("audiodir") == 0) {
         std::string temp;
         args >> temp;
-        getRunTime().setAudioDir(expandNames(temp));
+        RunTime::setAudioDir(expandNames(temp));
     } else if (var.compare("datadir") == 0) {
         std::string temp;
         args >> temp;
-        getRunTime().setDataDir(expandNames(temp));
+        RunTime::setDataDir(expandNames(temp));
     } else if (var.compare("font") == 0) {
         std::string temp;
         args >> temp;
     } else if (var.compare("mouse_y") == 0) {
         getLog() << glm::degrees(Camera::getSensitivityY()) << Log::endl;
     } else if (var.compare("fps") == 0) {
-        getLog() << getRunTime().getShowFPS() << Log::endl;
+        getLog() << RunTime::getShowFPS() << Log::endl;
     } else if (var.compare("basedir") == 0) {
-        getLog() << getRunTime().getBaseDir() << Log::endl;
+        getLog() << RunTime::getBaseDir() << Log::endl;
     } else if (var.compare("pakdir") == 0) {
-        getLog() << getRunTime().getPakDir() << Log::endl;
+        getLog() << RunTime::getPakDir() << Log::endl;
     } else if (var.compare("audiodir") == 0) {
-        getLog() << getRunTime().getAudioDir() << Log::endl;
+        getLog() << RunTime::getAudioDir() << Log::endl;
     } else if (var.compare("datadir") == 0) {
-        getLog() << getRunTime().getDataDir() << Log::endl;
+        getLog() << RunTime::getDataDir() << Log::endl;
     } else if (var.compare("font") == 0) {
         getLog() << Font::getFontName() << Log::endl;
     } else {

src/loader/LoaderTR2.cpp

         // travel through, like TR2s skeletons and underwater plants
         uint16_t flags = file.readU16();
 
-        getWorld().addStaticMesh(new StaticMesh(objectID, mesh));
+        BoundingBox* bbox1 = new BoundingBox(glm::vec3(x11, y11, z11), glm::vec3(x12, y12, z12));
+        BoundingBox* bbox2 = new BoundingBox(glm::vec3(x21, y21, z21), glm::vec3(x22, y22, z22));
+        getWorld().addStaticMesh(new StaticMesh(objectID, mesh, bbox1, bbox2));
     }
 
     if (numStaticMeshes > 0)

src/main.cpp

 static std::shared_ptr<Game> gGame;
 static std::shared_ptr<Log> gLog;
 static std::shared_ptr<MenuFolder> gMenu;
-static std::shared_ptr<RunTime> gRunTime;
 static std::shared_ptr<TextureManager> gTextureManager;
 static std::shared_ptr<World> gWorld;
 
     return *gMenu;
 }
 
-RunTime& getRunTime() {
-    return *gRunTime;
-}
-
 TextureManager& getTextureManager() {
     return *gTextureManager;
 }
     command_free(&cmd);
 
     // RunTime is required by other constructors
-    gRunTime.reset(new RunTime());
+    RunTime::initialize();
 
     gGame.reset(new Game());
     gLog.reset(new Log());
     getLog() << "Starting " << VERSION << Log::endl;
     getMenu().setVisible(true);
     systemTimerReset();
-    getRunTime().setRunning(true);
+    RunTime::setRunning(true);
 
-    while (getRunTime().isRunning()) {
+    while (RunTime::isRunning()) {
         Window::eventHandling();
         renderFrame();
     }
     getMenu().display();
     UI::display();
     Window::swapBuffers();
-    getRunTime().updateFPS();
+    RunTime::updateFPS();
 }
 
 #endif // UNIT_TEST

src/system/WindowGLFW.cpp

     glfwPollEvents();
 
     if (glfwWindowShouldClose(window)) {
-        getRunTime().setRunning(false);
+        RunTime::setRunning(false);
     }
 
     UI::eventsFinished();

src/system/WindowSDL.cpp

                 break;
 
             case SDL_QUIT:
-                getRunTime().setRunning(false);
+                RunTime::setRunning(false);
                 break;
         }
     }