Debug info now displayed as imgui overlay

ChangeLog.md

 
 ## OpenRaider (0.1.3) xythobuz <xythobuz@xythobuz.de>
 
+    [ 20140108 ]
+    * FPS and Camera position now displayed in imgui Overlay
+    * Removed many unnecessary includes
+
     [ 20140107 ]
     * Fixed problems with FontTTFs Glyph Baseline
     * No longer using wrong assert() when glm is included

include/Game.h

 class Game {
   public:
     Game();
-    ~Game();
 
     int initialize();
+    void destroy();
 
-    bool isLoaded();
-
+    bool isLoaded() { return mLoaded; }
     int loadLevel(const char* level);
 
-    void destroy();
-
     void display();
     void handleAction(ActionEvents action, bool isFinished);
     void handleMouseMotion(int xrel, int yrel, int xabs, int yabs);
     void setLara(long lara);
 
   private:
-    void processPakSounds();
-    void processTextures();
-    void processSprites();
-    void processMoveables();
-    void processMoveable(int index, int i, int object_id);
-    void processModels();
-    void processRooms();
-
-    std::string levelName;
     bool mLoaded;
-
     long mLara;
-
     bool activeEvents[ActionEventCount];
 };
 

include/Log.h

 #ifndef _LOG_H_
 #define _LOG_H_
 
+#include <iostream>
 #include <string>
 #include <sstream>
 #include <vector>
         printBuffer << t;
         if (printBuffer.str().back() == endl) {
             mHistory.push_back(printBuffer.str().substr(0, printBuffer.str().length() - 1));
-#ifdef DEBUG
             std::cout << printBuffer.str().substr(0, printBuffer.str().length() - 1) << std::endl;
-#endif
             printBuffer.str("");
         }
         return (*this);

include/Render.h

 
 class Render {
   public:
-    static RenderMode getMode();
-    static void setMode(RenderMode m);
+
+    static void clearRoomList() { roomList.clear(); }
 
     static void display();
     static void displayUI();
 
-    static void clearRoomList();
-
     static void screenShot(const char* filenameBase);
 
     static void drawTexture(float x, float y, float w, float h, glm::vec4 color,
                             unsigned int texture, TextureStorage s);
 
+    static RenderMode getMode() { return mode; }
+    static void setMode(RenderMode m) { mode = m; }
+
     static void setDisplayViewFrustum(bool d) { displayViewFrustum = d; }
     static bool getDisplayViewFrustum() { return displayViewFrustum; }
 

include/global.h

 
 template<typename T, typename U>
 [[noreturn]] void assertEqualImplementation(const char* exp, T a, U b, const char* file, int line,
-        bool print) {
+                                            bool print = false, const char* str = nullptr) {
     const unsigned int maxSize = 128;
     void* callstack[maxSize];
     int frames = backtrace(callstack, maxSize);
     std::cout << std::endl << "assertion failed:" << std::endl;
     std::cout << "\t" << exp << std::endl;
     if (print)
-        std::cout << "\t (" << a << " != " << b << ")" << std::endl;
-    std::cout << "in " << file << ":" << line << std::endl << std::endl;
-
-    for (int i = 0; i < frames; i++)
-        std::cout << strs[i] << std::endl;
-
-    delete [] strs;
-    abort();
-}
-
-template<typename T, typename U>
-[[noreturn]] void assertNotEqualImplementation(const char* exp, T a, U b, const char* file,
-        int line, bool print) {
-    const unsigned int maxSize = 128;
-    void* callstack[maxSize];
-    int frames = backtrace(callstack, maxSize);
-    char** strs = backtrace_symbols(callstack, frames);
-
-    std::cout << std::endl << "assertion failed:" << std::endl;
-    std::cout << "\t" << exp << std::endl;
-    if (print)
-        std::cout << "\t (" << a << " == " << b << ")" << std::endl;
+        std::cout << "\t (" << a << " " << str << " " << b << ")" << std::endl;
     std::cout << "in " << file << ":" << line << std::endl << std::endl;
 
     for (int i = 0; i < frames; i++)
 #define assert(x) { \
     auto assertEvalTemp = x; \
     if (!assertEvalTemp) \
-        assertEqualImplementation(#x, assertEvalTemp, true, __FILE__, __LINE__, false); \
+        assertEqualImplementation(#x, assertEvalTemp, true, __FILE__, __LINE__); \
 }
 
 #define assertEqual(x, y) { \
     auto assertEvalTemp = x; \
     auto assertEvalTemp2 = y; \
     if (assertEvalTemp != assertEvalTemp2) \
-        assertEqualImplementation(#x " == " #y, assertEvalTemp, assertEvalTemp2, __FILE__, __LINE__, true); \
+        assertEqualImplementation(#x " == " #y, assertEvalTemp, assertEvalTemp2, \
+                                  __FILE__, __LINE__, true, "!="); \
 }
 
 #define assertNotEqual(x, y) { \
     auto assertEvalTemp = x; \
     auto assertEvalTemp2 = y; \
     if (assertEvalTemp == assertEvalTemp2) \
-        assertNotEqualImplementation(#x " != " #y, assertEvalTemp, assertEvalTemp2, __FILE__, __LINE__, true); \
+        assertEqualImplementation(#x " != " #y, assertEvalTemp, assertEvalTemp2, \
+                                  __FILE__, __LINE__, true, "=="); \
 }
 
 #else // NODEBUG

src/Console.cpp

 
 #include "global.h"
 #include "Log.h"
-#include "UI.h"
 #include "commands/Command.h"
 #include "Console.h"
 

src/Game.cpp

  * \author xythobuz
  */
 
-#include <algorithm>
-#include <map>
-#include <sstream>
-#include <cstdlib>
-#include <cstring>
-
 #include "global.h"
 #include "Camera.h"
 #include "Game.h"
 #include "loader/Loader.h"
 #include "Log.h"
 #include "Render.h"
-#include "RunTime.h"
 #include "SoundManager.h"
-#include "StaticMesh.h"
-#include "system/Font.h"
-#include "system/Sound.h"
-#include "system/Window.h"
 #include "TextureManager.h"
 #include "UI.h"
 #include "World.h"
-#include "utils/strings.h"
 
 Game::Game() {
     mLoaded = false;
     }
 }
 
-Game::~Game() {
-}
-
 int Game::initialize() {
     // Enable Renderer
     Render::setMode(RenderMode::LoadScreen);
 
 void Game::display() {
     Render::display();
-
-    if (RunTime::getShowFPS()) {
-        std::ostringstream s;
-        s << RunTime::getFPS() << "FPS";
-        Font::drawText(10, Window::getSize().y - 25, 0.6f, BLUE, s.str());
-
-        s.str("");
-        s << "X: " << Camera::getPosition().x << " (" << Camera::getRotation().x << ")";
-        Font::drawText(10, Window::getSize().y - 70, 0.6f, BLUE, s.str());
-
-        s.str("");
-        s << "Y: " << Camera::getPosition().y << " (" << Camera::getRotation().y << ")";
-        Font::drawText(10, Window::getSize().y - 55, 0.6f, BLUE, s.str());
-
-        s.str("");
-        s << "Z: " << Camera::getPosition().z;
-        Font::drawText(10, Window::getSize().y - 40, 0.6f, BLUE, s.str());
-    }
 }
 
 void Game::destroy() {
     getWorld().destroy();
 }
 
-bool Game::isLoaded() {
-    return mLoaded;
-}
-
 int Game::loadLevel(const char* level) {
     destroy();
-    levelName = level;
-    getLog() << "Loading " << levelName << Log::endl;
+    getLog() << "Loading " << level << Log::endl;
     auto loader = Loader::createLoader(level);
     if (loader) {
         int error = loader->load(level);

src/Menu.cpp

 #include "global.h"
 #include "Log.h"
 #include "Menu.h"
-#include "MenuFolder.h"
 #include "system/Font.h"
 #include "system/Window.h"
 

src/Mesh.cpp

 
 #include "global.h"
 #include "TextureManager.h"
-#include "system/Shader.h"
 #include "Mesh.h"
 
 Mesh::Mesh(const std::vector<glm::vec3>& vert,

src/Render.cpp

  * \author xythobuz
  */
 
-#include <algorithm>
 #include <sstream>
 
 #include "global.h"
 #include "Camera.h"
-#include "Game.h"
 #include "Log.h"
-#include "UI.h"
 #include "World.h"
 #include "system/Shader.h"
 #include "system/Window.h"
-#include "utils/strings.h"
 #include "Render.h"
 
 #include <glm/gtc/matrix_transform.hpp>
 std::vector<Room*> Render::roomList;
 bool Render::displayViewFrustum = false;
 
-RenderMode Render::getMode() {
-    return mode;
-}
-
-void Render::setMode(RenderMode m) {
-    mode = m;
-    switch (mode) {
-        case RenderMode::Solid:
-        case RenderMode::Wireframe:
-            //glClearColor(PURPLE[0] / 256.0f, PURPLE[1] / 256.0f,
-            //             PURPLE[2] / 256.0f, PURPLE[3] / 256.0f);
-            break;
-        default:
-            //glClearColor(BLACK[0] / 256.0f, BLACK[1] / 256.0f,
-            //             BLACK[2] / 256.0f, BLACK[3] / 256.0f);
-            break;
-    }
-}
-
 void Render::display() {
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
     }
 }
 
-void Render::clearRoomList() {
-    roomList.clear();
-}
-
 void Render::buildRoomList(int room) {
     if (room < -1) {
         // Check if the camera currently is in a room...

src/Room.cpp

  * \author xythobuz
  */
 
-#include <algorithm>
-
 #include "global.h"
-#include "Game.h"
 #include "Log.h"
 #include "Render.h"
 #include "Room.h"
-#include "TextureManager.h"
 
 #include <glm/gtc/matrix_transform.hpp>
 #include <glm/gtx/intersect.hpp>

src/RoomData.cpp

  */
 
 #include "global.h"
-#include "SkeletalModel.h"
 #include "World.h"
 #include "system/Shader.h"
 #include "RoomData.h"

src/RunTime.cpp

 #include "imgui/imgui.h"
 
 #include "global.h"
-#include "Camera.h"
-#include "UI.h"
 #include "system/Sound.h"
 #include "system/Window.h"
 #include "utils/strings.h"

src/SoundManager.cpp

 #include "imgui/imgui.h"
 
 #include "global.h"
-#include "UI.h"
 #include "system/Sound.h"
 #include "SoundManager.h"
 

src/Sprite.cpp

 
 #include "global.h"
 #include "Camera.h"
-#include "Game.h"
 #include "Render.h"
 #include "TextureManager.h"
 #include "Sprite.h"

src/TextureManager.cpp

  * \author xythobuz
  */
 
-#include <string.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <stdarg.h>
-
 #include "stb/stb_image.h"
 
 #include "global.h"

src/UI.cpp

  * \author xythobuz
  */
 
-#include <algorithm>
-#include <cstring>
-
 #include "imgui/imgui.h"
 #include "stb/stb_image.h"
 
 }
 
 void UI::display() {
+    if (RunTime::getShowFPS()) {
+        if (ImGui::Begin("Debug Overlay", nullptr, ImVec2(0,0), 0.3f,
+                         ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize
+                         | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoSavedSettings
+                         | ImGuiWindowFlags_AlwaysAutoResize)) {
+            ImGui::Text("%d FPS", RunTime::getFPS());
+            ImGui::Text("X: %.1f (%.2f)", Camera::getPosition().x, Camera::getRotation().x);
+            ImGui::Text("Y: %.2f (%.2f)", Camera::getPosition().y, Camera::getRotation().y);
+            ImGui::Text("Z: %.2f", Camera::getPosition().z);
+
+            auto window = ImGui::GetWindowSize();
+            auto screen = Window::getSize();
+            ImGui::SetWindowPos(ImVec2(10, screen.y - window.y - 10));
+        }
+        ImGui::End();
+    }
+
     Console::display();
 
     if (!visible) {

src/World.cpp

  * \author Mongoose
  */
 
-#include <cstdio>
-#include <math.h>
-
 #include "global.h"
 #include "World.h"
 

src/system/Font.cpp

 #include "global.h"
 #include "Log.h"
 #include "utils/strings.h"
-#include "system/Window.h"
 #include "system/FontImGui.h"
 #include "system/FontTRLE.h"
 #include "system/FontTTF.h"

src/system/FontTRLE.cpp

  * \author xythobuz
  */
 
-#include <algorithm>
 #include <fstream>
 #include <sstream>
-#include <stdexcept>
 
 #include "global.h"
 #include "TextureManager.h"

src/system/SoundAL.cpp

 #include <OpenAL/al.h>
 #else
 #include <AL/al.h>
-#include <fcntl.h>
-#include <unistd.h>
 #endif
 
 #include <AL/alut.h>

src/system/WindowGLFW.cpp

  * \author xythobuz
  */
 
-#include <cstring>
-
 #include "global.h"
 #include "Log.h"
 #include "RunTime.h"
 #include "UI.h"
 #include "system/Window.h"
-#include "utils/strings.h"
 #include "system/WindowGLFW.h"
 
 glm::i32vec2 WindowGLFW::size(DEFAULT_WIDTH, DEFAULT_HEIGHT);

src/system/WindowSDL.cpp

  * \author xythobuz
  */
 
-#include <iostream>
-
 #include "global.h"
 #include "Log.h"
 #include "RunTime.h"
 #include "UI.h"
 #include "system/Window.h"
-#include "utils/strings.h"
 #include "system/WindowSDL.h"
 
 #define SUBSYSTEMS_USED (SDL_INIT_VIDEO | SDL_INIT_EVENTS | SDL_INIT_JOYSTICK | SDL_INIT_GAMECONTROLLER)
 
 int WindowSDL::initialize() {
     if (SDL_Init(SUBSYSTEMS_USED) != 0) {
-        std::cout << "SDL_Init Error: " << SDL_GetError() << std::endl;
+        getLog() << "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))) {
-        std::cout << "SDL_GL_SetAttribute Error: " << SDL_GetError() << std::endl;
+        getLog() << "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) {
-        std::cout << "SDL_CreateWindow Error: " << SDL_GetError() << std::endl;
+        getLog() << "SDL_CreateWindow Error: " << SDL_GetError() << Log::endl;
         return -3;
     }
 
     context = SDL_GL_CreateContext(window);
     if (!context) {
-        std::cout << "SDL_GL_CreateContext Error: " << SDL_GetError() << std::endl;
+        getLog() << "SDL_GL_CreateContext Error: " << SDL_GetError() << Log::endl;
         return -4;
     }
 

src/utils/Folder.cpp

 
 #include <algorithm>
 #include <iostream>
-#include <sstream>
-#include <cstring>
 
 #include "global.h"
 #include <Log.h>

src/utils/binary.cpp

  * \author xythobuz
  */
 
-#include <sstream>
-
 #include "global.h"
 #include "utils/binary.h"
 

src/utils/filesystem.cpp

 #else
 
     assert(false);
-    return std::string();
+    return "";
 
 #endif
 }
 #else
 
     assert(false);
-    return std::string();
+    return "";
 
 #endif
 }

src/utils/pcx.cpp

  */
 
 #include <fstream>
-#include <iostream>
 
 #include "global.h"
+#include "Log.h"
 #include "utils/pcx.h"
 
 int pcxCheck(const char* filename) {
 
     // Basic validation
     if (!file.read((char*)(&header[0]), 128)) {
-        std::cout << "File not big enough for valid PCX header!" << std::endl;
+        getLog() << "File not big enough for valid PCX header!" << Log::endl;
         delete [] header;
         return -1;
     }
 
     if (header[0] != 0x0A) {
-        std::cout << "Magic number at file start is wrong (" << header[0] << " != 0x0A)" << std::endl;
+        getLog() << "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
-        std::cout << "Unknown PCX file format version (" << header[1] << ")" << std::endl;
+        getLog() << "Unknown PCX file format version (" << header[1] << ")" << Log::endl;
         delete [] header;
         return -3;
     }
 
     if ((header[2] != 0) && (header[2] != 1)) {
-        std::cout << "Unknown PCX file encoding (" << header[2] << ")" << std::endl;
+        getLog() << "Unknown PCX file encoding (" << header[2] << ")" << Log::endl;
         delete [] header;
         return -4;
     }
 
     if (header[3] != 8) {
-        std::cout << "Only supporting 8bit (" << header[3] << "bit)" << std::endl;
+        getLog() << "Only supporting 8bit (" << header[3] << "bit)" << Log::endl;
         delete [] header;
         return -5;
     }
 
     if (header[64] != 0) {
-        std::cout << "Reserved field is  used (" << header[64] << " != 0)" << std::endl;
+        getLog() << "Reserved field is  used (" << header[64] << " != 0)" << Log::endl;
         delete [] header;
         return -6;
     }
 
     // Basic validation
     if (!file.read((char*)(&header[0]), 128)) {
-        std::cout << "File not big enough for valid PCX header!" << std::endl;
+        getLog() << "File not big enough for valid PCX header!" << Log::endl;
         delete [] header;
         return -1;
     }
 
     if (header[0] != 0x0A) {
-        std::cout << "Magic number at file start is wrong (" << header[0] << " != 0x0A)" << std::endl;
+        getLog() << "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
-        std::cout << "Unknown PCX file format version (" << header[1] << ")" << std::endl;
+        getLog() << "Unknown PCX file format version (" << header[1] << ")" << Log::endl;
         delete [] header;
         return -3;
     }
 
     if ((header[2] != 0) && (header[2] != 1)) {
-        std::cout << "Unknown PCX file encoding (" << header[2] << ")" << std::endl;
+        getLog() << "Unknown PCX file encoding (" << header[2] << ")" << Log::endl;
         delete [] header;
         return -4;
     }
 
     if (header[3] != 8) {
-        std::cout << "Only supporting 8bit (" << header[3] << "bit)" << std::endl;
+        getLog() << "Only supporting 8bit (" << header[3] << "bit)" << Log::endl;
         delete [] header;
         return -5;
     }
 
     if (header[64] != 0) {
-        std::cout << "Reserved field is  used (" << header[64] << " != 0)" << std::endl;
+        getLog() << "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) {
-            std::cout << "Could not read data (" << i
-                      << (file.eof() ? " EOF" : "") << ")" << std::endl;
+            getLog() << "Could not read data (" << i
+                      << (file.eof() ? " EOF" : "") << ")" << Log::endl;
             delete [] buffer;
             return -7;
         }
                 n = c & 0x3F;
                 c = file.get();
                 if (!file) {
-                    std::cout << "Could not read data rle (" << i
-                              << (file.eof() ? " EOF" : "") << ")" << std::endl;
+                    getLog() << "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) {
-                    std::cout << "Could not read 256 color palette (" << i << ")" << std::endl;
+                    getLog() << "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 {
-                    std::cout << "Unsupported number of planes (" << nPlanes << ")" << std::endl;
+                    getLog() << "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 {
-                    std::cout << "Unsupported number of planes (" << nPlanes << ")" << std::endl;
+                    getLog() << "Unsupported number of planes (" << nPlanes << ")" << Log::endl;
                     delete [] buffer;
                     delete [] palette;
                     delete [] *image;