Split Log class from Console

ChangeLog.md

     * World now using smart pointers
     * Removed atexit handler, now breaking out of main loop on quit
     * Added calculate and shutdown calls to UI interface, properly shutting down imgui
+    * Created Log class holding logging infos, used by others instead of Console.
 
     [ 20140903 ]
     * Finishing imgui integration, but now as UI layer and not on top of everything

TODO.md

 * Add verbose command line flag for debug output also in release builds
 * Don’t depend on setup: no data or config files should be necessary
 * Be able to change configuration from within OpenRaider
-* Put log functionality outside of Console
 
 ## Bugs
 

include/Console.h

 #define _CONSOLE_H_
 
 #include <string>
-#include <sstream>
 #include <vector>
 
 #include "UI.h"
     Console();
     ~Console();
 
-    template<typename T>
-    Console &operator<<(const T t) {
-        printBuffer << t;
-        if (printBuffer.str().back() == '\n') {
-            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);
-    }
-
     virtual void moveToTop();
     virtual void makeInvisible();
     virtual void display();
     virtual void handleText(char *text, bool notFinished);
     virtual void handleMouseScroll(int xrel, int yrel);
 
-    const static char endl = '\n';
-
 private:
 
     void moveInHistory(bool up);
 
     std::string mInputBuffer;
     std::string mPartialInput;
-    std::vector<std::string> mHistory;
 
     size_t mHistoryPointer;
     std::vector<std::string> mCommandHistory;
     std::string mUnfinishedInput;
 
     unsigned int mLineOffset;
-
-    std::ostringstream printBuffer;
 };
 
 Console &getConsole();

include/Log.h

+/*!
+ * \file include/Log.h
+ * \brief Log
+ *
+ * \author xythobuz
+ */
+
+#ifndef _LOG_H_
+#define _LOG_H_
+
+#include <string>
+#include <sstream>
+#include <vector>
+
+class Log {
+public:
+
+    const static char endl = '\n';
+
+    ~Log();
+
+    unsigned long size();
+    std::string get(unsigned long i);
+
+    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));
+#ifdef DEBUG
+            std::cout << printBuffer.str().substr(0, printBuffer.str().length() - 1) << std::endl;
+#endif
+            printBuffer.str("");
+        }
+        return (*this);
+    }
+
+private:
+    std::vector<std::string> mHistory;
+    std::ostringstream printBuffer;
+};
+
+Log &getLog();
+
+#endif

src/CMakeLists.txt

 set (SRCS ${SRCS} "FontManager.cpp")
 set (SRCS ${SRCS} "FontTRLE.cpp")
 set (SRCS ${SRCS} "Game.cpp")
+set (SRCS ${SRCS} "Log.cpp")
 set (SRCS ${SRCS} "main.cpp")
 set (SRCS ${SRCS} "Menu.cpp")
 set (SRCS ${SRCS} "MenuFolder.cpp")

src/Console.cpp

 #include "global.h"
 #include "commands/Command.h"
 #include "Font.h"
+#include "Log.h"
 #include "utf8-cpp/utf8.h"
 #include "utils/strings.h"
 #include "utils/time.h"
     glEnable(GL_TEXTURE_2D);
 
     unsigned long scrollIndicator;
-    if (mHistory.size() > lineCount) {
-        scrollIndicator = (mHistory.size() - lineCount - mLineOffset) * 100 / (mHistory.size() - lineCount);
+    if (getLog().size() > lineCount) {
+        scrollIndicator = (getLog().size() - lineCount - mLineOffset) * 100 / (getLog().size() - lineCount);
     } else {
         scrollIndicator = 100;
         mLineOffset = 0;
     long end = lineCount;
     long drawOffset = 0;
     long historyOffset = 0;
-    if (mHistory.size() < lineCount) {
-        end = mHistory.size();
-        drawOffset = lineCount - mHistory.size();
-    } else if (lineCount < mHistory.size()) {
-        historyOffset = mHistory.size() - lineCount;
+    if (getLog().size() < lineCount) {
+        end = getLog().size();
+        drawOffset = lineCount - getLog().size();
+    } else if (lineCount < getLog().size()) {
+        historyOffset = getLog().size() - lineCount;
     }
 
     for (int i = 0; i < end; i++) {
         getFont().drawText(10, (unsigned int)((i + drawOffset) * lineSteps) + firstLine,
-                0.75f, BLUE, mHistory.at(i + historyOffset - mLineOffset));
+                0.75f, BLUE, getLog().get(i + historyOffset - mLineOffset));
     }
 
     // Draw current input
     if (pressed && (key == enterKey)) {
         // Execute entered command
         if (mInputBuffer.length() > 0) {
-            (*this) << "> " << mInputBuffer.c_str() << endl;
+            getLog() << "> " << mInputBuffer.c_str() << Log::endl;
             mCommandHistory.push_back(mInputBuffer.c_str());
             int error = Command::command(mInputBuffer);
             if (error != 0) {
-                (*this) << "Error Code: " << error << endl;
+                getLog() << "Error Code: " << error << Log::endl;
             }
         } else {
-            (*this) << "> " << endl;
+            getLog() << "> " << Log::endl;
         }
 
         // Clear partial and input buffer
         lineCount = (lastLine - firstLine + lineSteps) / lineSteps;
     }
 
-    if (mHistory.size() > lineCount) {
+    if (getLog().size() > lineCount) {
         if (yrel > 0) {
-            if (mLineOffset < (mHistory.size() - lineCount)) {
+            if (mLineOffset < (getLog().size() - lineCount)) {
                 mLineOffset++;
             }
         } else if (yrel < 0) {

src/Entity.cpp

 #include <cmath>
 
 #include "global.h"
-#include "Console.h"
-#include "Entity.h"
+#include "Log.h"
 #include "Render.h"
 #include "World.h"
+#include "Entity.h"
 
 #include "games/TombRaider1.h"
 
                 x, y, z);
 
         if (roomNew > -1)
-            getConsole() << "Crossing from room " << room << " to " << roomNew << Console::endl;
+            getLog() << "Crossing from room " << room << " to " << roomNew << Log::endl;
         else
             //! \fixme mRooms, sectors, ... are now std::vector, but often upper bound checks are missing
             return;
 }
 
 void Entity::print() {
-    getConsole() << "Entity " << objectId << ":" << Console::endl
+    getLog() << "Entity " << objectId << ":" << Log::endl
         << "  Room " << room << " (" << getWorld().getRoom(room).getFlags()
-        << ")" << Console::endl
+        << ")" << Log::endl
         << "  " << pos[0] << "x " << pos[1] << "y " << pos[2] << "z"
-        << Console::endl
-        << "  " << OR_RAD_TO_DEG(angles[1]) << " Yaw" << Console::endl;
+        << Log::endl
+        << "  " << OR_RAD_TO_DEG(angles[1]) << " Yaw" << Log::endl;
 }
 
 SkeletalModel &Entity::getModel() {

src/Game.cpp

 
 #include "global.h"
 #include "Camera.h"
-#include "Console.h"
 #include "Game.h"
 #include "loader/Loader.h"
+#include "Log.h"
 #include "Render.h"
 #include "Sound.h"
 #include "StaticMesh.h"
 
     levelName = level;
 
-    getConsole() << "Loading " << levelName << Console::endl;
+    getLog() << "Loading " << levelName << Log::endl;
 
     int error = 0;
     auto loader = Loader::createLoader(level);
 
         // And now...?
 
-        getConsole() << "Tried Loader..." << Console::endl;
+        getLog() << "Tried Loader..." << Log::endl;
     }
 
     if ((!loader) || (error == 0)) {
             tmp += "MAIN.SFX";
             error = mTombRaider.loadSFX(tmp.c_str());
             if (error != 0)
-                getConsole() << "Could not load " << tmp << Console::endl;
+                getLog() << "Could not load " << tmp << Log::endl;
         }
 
         // Process data
 
         if (mLara == -1) {
             //! \todo Cutscene support
-            getConsole() << "Can't find Lara entity in level pak!" << Console::endl;
+            getLog() << "Can't find Lara entity in level pak!" << Log::endl;
             destroy();
             return -1;
         } else {
         }
     }
 
-    getConsole() << "Found " << mTombRaider.NumSpriteSequences() << " sprites." << Console::endl;
+    getLog() << "Found " << mTombRaider.NumSpriteSequences() << " sprites." << Log::endl;
 }
 
 void Game::processRooms() {
     for (int index = 0; index < mTombRaider.NumRooms(); index++)
         getWorld().addRoom(*new Room(mTombRaider, index));
 
-    getConsole() << "Found " << mTombRaider.NumRooms() << " rooms." << Console::endl;
+    getLog() << "Found " << mTombRaider.NumRooms() << " rooms." << Log::endl;
 }
 
 void Game::processModels() {
     for (int index = 0; index < mTombRaider.getMeshCount(); index++)
         getWorld().addStaticMesh(*new StaticMesh(mTombRaider, index));
 
-    getConsole() << "Found " << mTombRaider.getMeshCount() << " meshes." << Console::endl;
+    getLog() << "Found " << mTombRaider.getMeshCount() << " meshes." << Log::endl;
 }
 
 void Game::processPakSounds()
         //getSound().SourceAt(id, pos);
     }
 
-    getConsole() << "Found " << mTombRaider.getSoundSamplesCount() << " sound samples." << Console::endl;
+    getLog() << "Found " << mTombRaider.getSoundSamplesCount() << " sound samples." << Log::endl;
 }
 
 void Game::processTextures()
 
     mTextureOffset = (mTextureStart - 1) + mTombRaider.NumTextures();
 
-    getConsole() << "Found " << mTombRaider.NumTextures() << " textures." << Console::endl;
+    getLog() << "Found " << mTombRaider.NumTextures() << " textures." << Log::endl;
 }
 
 void Game::processMoveables()
     }
     */
 
-    getConsole() << "Found " << mTombRaider.NumMoveables() + statCount << " moveables." << Console::endl;
+    getLog() << "Found " << mTombRaider.NumMoveables() + statCount << " moveables." << Log::endl;
 }
 
 // index moveable, i item, sometimes both moveable

src/Log.cpp

+/*!
+ * \file src/Log.cpp
+ * \brief Log
+ *
+ * \author xythobuz
+ */
+
+#include "global.h"
+#include "Log.h"
+
+Log::~Log() {
+}
+
+unsigned long Log::size() {
+    return mHistory.size();
+}
+
+std::string Log::get(unsigned long i) {
+    assert(i < mHistory.size());
+    return mHistory.at(i);
+}
+

src/Menu.cpp

  */
 
 #include "global.h"
-#include "Console.h"
 #include "Font.h"
+#include "Log.h"
 #include "Window.h"
 #include "Menu.h"
 #include "MenuFolder.h"
     dialogState = false;
     dialogFunction = callback;
 
-    getConsole() << dialogText << Console::endl;
+    getLog() << dialogText << Log::endl;
 }
 
 void Menu::ackDialog() {

src/MenuFolder.cpp

  */
 
 #include "global.h"
-#include "Console.h"
 #include "Font.h"
 #include "Game.h"
 #include "loader/Loader.h"
+#include "Log.h"
 #include "RunTime.h"
 #include "Window.h"
 #include "MenuFolder.h"
             // Check maps for validity
             Loader::LoaderVersion version = Loader::checkFile(f.getPath());
             if (version == Loader::TR_UNKNOWN) {
-                getConsole() << "Error: pak file '" << f.getName().c_str()
-                    << "' invalid" << Console::endl;
+                getLog() << "Error: pak file '" << f.getName().c_str()
+                    << "' invalid" << Log::endl;
                 return true; // delete file from list
             }
 

src/Room.cpp

 #include <algorithm>
 
 #include "global.h"
-#include "Console.h"
 #include "Game.h"
+#include "Log.h"
 #include "Render.h"
 #include "Room.h"
 #include "TextureManager.h"
     Matrix transform;
 
     if (!tr.isRoomValid(index)) {
-        getConsole() << "WARNING: Handling invalid vertex array in room" << Console::endl;
+        getLog() << "WARNING: Handling invalid vertex array in room" << Log::endl;
         return;
     }
 
 
         if (texture > (int)TextureLimit)
         {
-            getConsole() << "Handling bad room[" << index << "].tris["
-                << t << "].texture = " << texture << Console::endl;
+            getLog() << "Handling bad room[" << index << "].tris["
+                << t << "].texture = " << texture << Log::endl;
             texture = TextureLimit - 1;
         }
 
 
         if (texture > (int)TextureLimit)
         {
-            getConsole() << "Handling bad room[" << index << "].quad["
-                << r << "].texture = " << texture << Console::endl;
+            getLog() << "Handling bad room[" << index << "].quad["
+                << r << "].texture = " << texture << Log::endl;
             texture = TextureLimit - 1;
         }
 

src/SkeletalModel.cpp

  */
 
 #include "global.h"
-#include "Console.h"
+#include "Log.h"
 #include "Render.h"
 #include "SkeletalModel.h"
 #include "World.h"
         }
 
         if (*frame_offset > tr.NumFrames()) {
-            getConsole() << "WARNING: Bad animation frame " << *frame_offset
+            getLog() << "WARNING: Bad animation frame " << *frame_offset
                 << " > " << tr.NumFrames() << " (" << index << "." << a << ")"
-                << Console::endl;
+                << Log::endl;
             return;
         }
 
                 }
 
                 getRender().setFlags(Render::fRenderPonytail);
-                getConsole() << "Found known ponytail" << Console::endl;
+                getLog() << "Found known ponytail" << Log::endl;
             }
             break;
 
                 ponyOff2 = 0;
 
                 getRender().setFlags(Render::fRenderPonytail);
-                getConsole() << "Found ponytail?" << Console::endl;
+                getLog() << "Found ponytail?" << Log::endl;
             }
             break;
     }
         frame_offset += frame_step * (frame_cycle % a);
 
     if (a < 0) {
-        getConsole() << "Invalid animation data for model " << index << ". Skip!" << Console::endl;
+        getLog() << "Invalid animation data for model " << index << ". Skip!" << Log::endl;
         return;
     } else {
         for (; a < tr.getNumAnimsForMoveable(index); a++) {

src/TextureManager.cpp

 #include <stdarg.h>
 
 #include "global.h"
-#include "Console.h"
+#include "Log.h"
 #include "RunTime.h"
 #include "utils/pcx.h"
 #include "utils/pixel.h"
     } else if (stringEndsWith(filename, ".tga") || stringEndsWith(filename, ".TGA")) {
         return loadTGA(filename);
     } else {
-        getConsole() << "No known image file type? (" << filename << ")" << Console::endl;
+        getLog() << "No known image file type? (" << filename << ")" << Log::endl;
     }
 
     return -1;
 
     return id;
 #else
-    getConsole() << "No PNG support available (" << filename << ")" << Console::endl;
+    getLog() << "No PNG support available (" << filename << ")" << Log::endl;
     return -1;
 #endif
 }

src/UI.cpp

                 getConsole().moveToTop();
             }
         } else if (getRunTime().getKeyBinding(debugAction) == key) {
-            if (getDebug().isOnTop()) {
-                getDebug().makeInvisible();
-            } else {
+            if (!getDebug().isOnTop()) {
                 getDebug().moveToTop();
             }
         }

src/commands/Command.cpp

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

src/commands/CommandAnimate.cpp

  */
 
 #include "global.h"
-#include "Console.h"
+#include "Log.h"
 #include "Game.h"
 #include "Render.h"
 #include "World.h"
 }
 
 void CommandAnimate::printHelp() {
-    getConsole() << "animate-Command Usage:" << Console::endl;
-    getConsole() << "  animate [n|p|BOOL]" << Console::endl;
-    getConsole() << "Where the commands have the following meaning:" << Console::endl;
-    getConsole() << "  BOOL to (de)activate animating all models" << Console::endl;
-    getConsole() << "  n to step all models to their next animation" << Console::endl;
-    getConsole() << "  p to step all models to their previous animation" << Console::endl;
+    getLog() << "animate-Command Usage:" << Log::endl;
+    getLog() << "  animate [n|p|BOOL]" << Log::endl;
+    getLog() << "Where the commands have the following meaning:" << Log::endl;
+    getLog() << "  BOOL to (de)activate animating all models" << Log::endl;
+    getLog() << "  n to step all models to their next animation" << Log::endl;
+    getLog() << "  p to step all models to their previous animation" << Log::endl;
 }
 
 int CommandAnimate::execute(std::istream& args) {
     if (!getGame().isLoaded()) {
-        getConsole() << "Use animate command interactively!" << Console::endl;
+        getLog() << "Use animate command interactively!" << Log::endl;
         return -1;
     }
 
                     e.setAnimation(0);
             }
         } else {
-            getConsole() << "Animations need to be enabled!" << Console::endl;
+            getLog() << "Animations need to be enabled!" << Log::endl;
         }
     } else if (args.peek() == 'p') {
         // Step all skeletal models to their previous animation
                         e.setAnimation(m.size() - 1);
             }
         } else {
-            getConsole() << "Animations need to be enabled!" << Console::endl;
+            getLog() << "Animations need to be enabled!" << Log::endl;
         }
     } else {
         // Enable or disable animating all skeletal models
         bool b = false;
         if (!(args >> b)) {
-            getConsole() << "Pass BOOL to animate command!" << Console::endl;
+            getLog() << "Pass BOOL to animate command!" << Log::endl;
             return -2;
         }
         if (b)
             getRender().setFlags(Render::fAnimateAllModels);
         else
             getRender().clearFlags(Render::fAnimateAllModels);
-        getConsole() << (b ? "Animating all models" : "No longer animating all models") << Console::endl;
+        getLog() << (b ? "Animating all models" : "No longer animating all models") << Log::endl;
     }
 
     return 0;

src/commands/CommandBind.cpp

  */
 
 #include "global.h"
-#include "Console.h"
+#include "Log.h"
 #include "RunTime.h"
 #include "commands/CommandBind.h"
 
 }
 
 void CommandBind::printHelp() {
-    getConsole() << "bind-Command Usage:" << Console::endl;
-    getConsole() << "  bind ACTION KEY" << Console::endl;
-    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;
-    getConsole() << "  right" << Console::endl;
-    getConsole() << "  jump" << Console::endl;
-    getConsole() << "  crouch" << Console::endl;
-    getConsole() << "  use" << Console::endl;
-    getConsole() << "  holster" << Console::endl;
-    getConsole() << "  walk" << Console::endl;
-    getConsole() << "Key-Format:" << Console::endl;
-    getConsole() << "  'a' or '1'    for character/number keys" << Console::endl;
-    getConsole() << "  \"leftctrl\"  for symbols and special keys" << Console::endl;
+    getLog() << "bind-Command Usage:" << Log::endl;
+    getLog() << "  bind ACTION KEY" << Log::endl;
+    getLog() << "Available Actions:" << Log::endl;
+    getLog() << "  menu" << Log::endl;
+    getLog() << "  console" << 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;
 }
 
 int CommandBind::execute(std::istream& args) {
     std::string a, b;
     if (!(args >> a >> b)) {
-        getConsole() << "Invalid use of bind-command" << Console::endl;
+        getLog() << "Invalid use of bind-command" << Log::endl;
         return -1;
     } else {
         ActionEvents e = stringToActionEvent(a);
         if (e == ActionEventCount) {
-            getConsole() << "bind-Error: Unknown action (" << a << ")" << Console::endl;
+            getLog() << "bind-Error: Unknown action (" << a << ")" << Log::endl;
             return -2;
         }
 
         KeyboardButton c = stringToKeyboardButton(b);
         if (c == unknownKey) {
-            getConsole() << "bind-Error: Unknown key (" << b << ")" << Console::endl;
+            getLog() << "bind-Error: Unknown key (" << b << ")" << Log::endl;
             return -3;
         }
 

src/commands/CommandEngine.cpp

 #include "global.h"
 #include "Console.h"
 #include "Game.h"
+#include "Log.h"
 #include "Menu.h"
 #include "RunTime.h"
 #include "Render.h"
 }
 
 void CommandLoad::printHelp() {
-    getConsole() << "load-Command Usage:" << Console::endl;
-    getConsole() << "  load /path/to/level" << Console::endl;
+    getLog() << "load-Command Usage:" << Log::endl;
+    getLog() << "  load /path/to/level" << Log::endl;
 }
 
 int CommandLoad::execute(std::istream& args) {
     if (!getRunTime().isRunning()) {
-        getConsole() << "Use load command interactively!" << Console::endl;
+        getLog() << "Use load command interactively!" << Log::endl;
         return -1;
     }
 
 }
 
 void CommandScreenshot::printHelp() {
-    getConsole() << "sshot-Command Usage:" << Console::endl;
-    getConsole() << "  sshot [console|menu] [console|menu]" << Console::endl;
-    getConsole() << "Add console/menu to capture them too" << Console::endl;
+    getLog() << "sshot-Command Usage:" << Log::endl;
+    getLog() << "  sshot [console|menu] [console|menu]" << Log::endl;
+    getLog() << "Add console/menu to capture them too" << Log::endl;
 }
 
 int CommandScreenshot::execute(std::istream& args) {
     if (!getRunTime().isRunning()) {
-        getConsole() << "Use sshot command interactively!" << Console::endl;
+        getLog() << "Use sshot command interactively!" << Log::endl;
         return -1;
     }
 
     filename += "/sshots/";
     filename += VERSION_SHORT;
 
-    bool console = false, menu = false;
     std::string temp, temp2;
     args >> temp >> temp2;
 
     getMenu().makeInvisible();
     getConsole().moveToTop();
 
-    getConsole() << "Screenshot stored..." << Console::endl;
+    getLog() << "Screenshot stored..." << Log::endl;
     return 0;
 }
 

src/commands/CommandGame.cpp

  */
 
 #include "global.h"
-#include "Console.h"
 #include "Game.h"
+#include "Log.h"
 #include "RunTime.h"
 #include "World.h"
 #include "commands/CommandGame.h"
 
 int CommandPos::execute(std::istream& args) {
     if ((!getRunTime().isRunning()) || (!getGame().isLoaded())) {
-        getConsole() << "Use pos command interactively!" << Console::endl;
+        getLog() << "Use pos command interactively!" << Log::endl;
         return -1;
     }
 
 
 int CommandViewmodel::execute(std::istream& args) {
     if ((!getRunTime().isRunning()) || (!getGame().isLoaded())) {
-        getConsole() << "Use viewmodel command interactively!" << Console::endl;
+        getLog() << "Use viewmodel command interactively!" << Log::endl;
         return -1;
     }
 
         getGame().getLara().setSkeletalModel(n);
         return 0;
     } else {
-        getConsole() << "Invalid SkeletalModel index!" << Console::endl;
+        getLog() << "Invalid SkeletalModel index!" << Log::endl;
         return -2;
     }
 }
 
 int CommandPigtail::execute(std::istream& args) {
     if ((!getRunTime().isRunning()) || (!getGame().isLoaded())) {
-        getConsole() << "Use pigtail command interactively!" << Console::endl;
+        getLog() << "Use pigtail command interactively!" << Log::endl;
         return -1;
     }
 
     bool b;
     args >> b;
     if (!args) {
-        getConsole() << "Pass BOOL to pigtail command!" << Console::endl;
+        getLog() << "Pass BOOL to pigtail command!" << Log::endl;
         return -2;
     }
 
     getGame().getLara().getModel().setPigTail(b);
-    getConsole() << "Pigtail is now " << (b ? "on" : "off") << Console::endl;
+    getLog() << "Pigtail is now " << (b ? "on" : "off") << Log::endl;
     return 0;
 }
 
 
 int CommandPonypos::execute(std::istream& args) {
     if ((!getRunTime().isRunning()) || (!getGame().isLoaded())) {
-        getConsole() << "Use ponypos command interactively!" << Console::endl;
+        getLog() << "Use ponypos command interactively!" << Log::endl;
         return -1;
     }
 
     float a, b, c, d;
     args >> a >> b >> c >> d;
     if (!args) {
-        getConsole() << "Pass four FLOATs to ponypos command!" << Console::endl;
+        getLog() << "Pass four FLOATs to ponypos command!" << Log::endl;
         return -2;
     }
 

src/commands/CommandMove.cpp

  */
 
 #include "global.h"
-#include "Console.h"
 #include "Game.h"
+#include "Log.h"
 #include "RunTime.h"
 #include "commands/CommandMove.h"
 
 }
 
 void CommandMove::printHelp() {
-    getConsole() << "move-Command Usage:" << Console::endl;
-    getConsole() << "  move COMMAND" << Console::endl;
-    getConsole() << "Where COMMAND is one of the following:" << Console::endl;
-    getConsole() << "  walk" << Console::endl;
-    getConsole() << "  fly" << Console::endl;
-    getConsole() << "  noclip" << Console::endl;
+    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;
 }
 
 int CommandMove::execute(std::istream& args) {
     if ((!getRunTime().isRunning()) || (!getGame().isLoaded())) {
-        getConsole() << "Use move command interactively!" << Console::endl;
+        getLog() << "Use move command interactively!" << Log::endl;
         return -1;
     }
 
     } else if (s.compare("noclip") == 0) {
         getGame().getLara().setMoveType(Entity::MoveTypeNoClipping);
     } else {
-        getConsole() << "Invalid use of move command (" << s << ")!" << Console::endl;
+        getLog() << "Invalid use of move command (" << s << ")!" << Log::endl;
         return -2;
     }
 
-    getConsole() << s  << "ing" << Console::endl;
+    getLog() << s  << "ing" << Log::endl;
     return 0;
 }
 

src/commands/CommandRender.cpp

  */
 
 #include "global.h"
-#include "Console.h"
 #include "Game.h"
+#include "Log.h"
 #include "RunTime.h"
 #include "Render.h"
 #include "commands/CommandRender.h"
 }
 
 void CommandMode::printHelp() {
-    getConsole() << "mode-Command Usage:" << Console::endl;
-    getConsole() << "  mode MODE" << Console::endl;
-    getConsole() << "Where MODE is one of the following:" << Console::endl;
-    getConsole() << "  wireframe" << Console::endl;
-    getConsole() << "  solid" << Console::endl;
-    getConsole() << "  texture" << Console::endl;
-    getConsole() << "  vertexlight" << Console::endl;
-    getConsole() << "  titlescreen" << Console::endl;
+    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() << "  vertexlight" << Log::endl;
+    getLog() << "  titlescreen" << Log::endl;
 
 }
 
 int CommandMode::execute(std::istream& args) {
     if (!getGame().isLoaded()) {
-        getConsole() << "Load a level to set the mode!" << Console::endl;
+        getLog() << "Load a level to set the mode!" << Log::endl;
         return -1;
     }
 
 
     if (s.compare("wireframe") == 0) {
         getRender().setMode(Render::modeWireframe);
-        getConsole() << "Wireframe mode" << Console::endl;
+        getLog() << "Wireframe mode" << Log::endl;
     } else if (s.compare("solid") == 0) {
         getRender().setMode(Render::modeSolid);
-        getConsole() << "Solid mode" << Console::endl;
+        getLog() << "Solid mode" << Log::endl;
     } else if (s.compare("texture") == 0) {
         getRender().setMode(Render::modeTexture);
-        getConsole() << "Texture mode" << Console::endl;
+        getLog() << "Texture mode" << Log::endl;
     } else if (s.compare("vertexlight") == 0) {
         getRender().setMode(Render::modeVertexLight);
-        getConsole() << "Vertexlight mode" << Console::endl;
+        getLog() << "Vertexlight mode" << Log::endl;
     } else if (s.compare("titlescreen") == 0) {
         getRender().setMode(Render::modeLoadScreen);
-        getConsole() << "Titlescreen mode" << Console::endl;
+        getLog() << "Titlescreen mode" << Log::endl;
     } else {
-        getConsole() << "Invalid use of mode command (" << s << ")!" << Console::endl;
+        getLog() << "Invalid use of mode command (" << s << ")!" << Log::endl;
         return -2;
     }
 
 }
 
 void CommandRenderflag::printHelp() {
-    getConsole() << "renderflag-Command Usage:" << Console::endl;
-    getConsole() << "  renderflag STRING BOOL" << Console::endl;
-    getConsole() << "Where STRING is one of the following:" << Console::endl;
-    getConsole() << "  ralpha" << Console::endl;
-    getConsole() << "  entmodel" << Console::endl;
-    getConsole() << "  fog" << Console::endl;
-    getConsole() << "  light" << Console::endl;
-    getConsole() << "  ponytail" << Console::endl;
+    getLog() << "renderflag-Command Usage:" << Log::endl;
+    getLog() << "  renderflag STRING BOOL" << Log::endl;
+    getLog() << "Where STRING is one of the following:" << Log::endl;
+    getLog() << "  ralpha" << Log::endl;
+    getLog() << "  entmodel" << Log::endl;
+    getLog() << "  fog" << Log::endl;
+    getLog() << "  light" << Log::endl;
+    getLog() << "  ponytail" << Log::endl;
 }
 
 int CommandRenderflag::execute(std::istream& args) {
     if (!getRunTime().isRunning()) {
-        getConsole() << "Use renderflag-Command interactively!" << Console::endl;
+        getLog() << "Use renderflag-Command interactively!" << Log::endl;
         return -1;
     }
 
     bool b;
     args >> flag >> b;
     if (!args) {
-        getConsole() << "Pass STRING and BOOL to renderflag command!" << Console::endl;
+        getLog() << "Pass STRING and BOOL to renderflag command!" << Log::endl;
         return -2;
     }
 
     int f = stringToFlag(flag);
     if (f == -1) {
-        getConsole() << "Unknown flag \"" << flag << "\"!" << Console::endl;
+        getLog() << "Unknown flag \"" << flag << "\"!" << Log::endl;
         return -3;
     }
 

src/commands/CommandSet.cpp

 
 #include "global.h"
 #include "Camera.h"
-#include "Console.h"
 #include "Font.h"
+#include "Log.h"
 #include "RunTime.h"
 #include "Sound.h"
 #include "Window.h"
 }
 
 void CommandSet::printHelp() {
-    getConsole() << "set-Command Usage:" << Console::endl;
-    getConsole() << "  set VAR VAL" << Console::endl;
-    getConsole() << "Available Variables:" << Console::endl;
-    getConsole() << "  basedir    STRING" << Console::endl;
-    getConsole() << "  pakdir     STRING" << Console::endl;
-    getConsole() << "  audiodir   STRING" << Console::endl;
-    getConsole() << "  datadir    STRING" << Console::endl;
-    getConsole() << "  font       STRING" << Console::endl;
-    getConsole() << "  size       INT INT" << Console::endl;
-    getConsole() << "  fullscreen BOOL" << Console::endl;
-    getConsole() << "  audio      BOOL" << Console::endl;
-    getConsole() << "  volume     BOOL" << Console::endl;
-    getConsole() << "  mouse_x    FLOAT" << Console::endl;
-    getConsole() << "  mouse_y    FLOAT" << Console::endl;
-    getConsole() << "  fps        BOOL" << Console::endl;
-    getConsole() << "Enclose STRINGs with \"\"!" << Console::endl;
+    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;
 }
 
 namespace {
     if (var.compare("size") == 0) {
         unsigned int w = DEFAULT_WIDTH, h = DEFAULT_HEIGHT;
         if (!(args >> w >> h)) {
-            getConsole() << "set-size-Error: Invalid value(s)" << Console::endl;
+            getLog() << "set-size-Error: Invalid value(s)" << Log::endl;
             return -2;
         }
         getWindow().setSize(w, h);
     } else if (var.compare("fullscreen") == 0) {
         bool fullscreen = false;
         if (!(args >> fullscreen)) {
-            getConsole() << "set-fullscreen-Error: Invalid value" << Console::endl;
+            getLog() << "set-fullscreen-Error: Invalid value" << Log::endl;
             return -3;
         }
         getWindow().setFullscreen(fullscreen);
     } else if (var.compare("audio") == 0) {
         bool audio = false;
         if (!(args >> audio)) {
-            getConsole() << "set-audio-Error: Invalid value" << Console::endl;
+            getLog() << "set-audio-Error: Invalid value" << Log::endl;
             return -4;
         }
         getSound().setEnabled(audio);
     } else if (var.compare("volume") == 0) {
         float vol = 1.0f;
         if (!(args >> vol)) {
-            getConsole() << "set-volume-Error: Invalid value" << Console::endl;
+            getLog() << "set-volume-Error: Invalid value" << Log::endl;
             return -5;
         }
         getSound().setVolume(vol);
     } else if (var.compare("mouse_x") == 0) {
         float sense = 1.0f;
         if (!(args >> sense)) {
-            getConsole() << "set-mouse_x-Error: Invalid value" << Console::endl;
+            getLog() << "set-mouse_x-Error: Invalid value" << Log::endl;
             return -6;
         }
         getCamera().setSensitivityX(OR_DEG_TO_RAD(sense));
     } else if (var.compare("mouse_y") == 0) {
         float sense = 1.0f;
         if (!(args >> sense)) {
-            getConsole() << "set-mouse_y-Error: Invalid value" << Console::endl;
+            getLog() << "set-mouse_y-Error: Invalid value" << Log::endl;
             return -7;
         }
         getCamera().setSensitivityY(OR_DEG_TO_RAD(sense));
     } else if (var.compare("fps") == 0) {
         bool fps = false;
         if (!(args >> fps)) {
-            getConsole() << "set-fps-Error: Invalid value" << Console::endl;
+            getLog() << "set-fps-Error: Invalid value" << Log::endl;
             return -8;
         }
         getRunTime().setFPS(fps);
         args >> temp;
         getFont().setFont(expandNames(temp).c_str());
     } else {
-        getConsole() << "set-Error: Unknown variable (" << var.c_str() << ")" << Console::endl;
+        getLog() << "set-Error: Unknown variable (" << var.c_str() << ")" << Log::endl;
         return -1;
     }
 

src/commands/CommandSound.cpp

  */
 
 #include "global.h"
-#include "Console.h"
 #include "Game.h"
+#include "Log.h"
 #include "RunTime.h"
 #include "Sound.h"
 #include "commands/CommandSound.h"
 }
 
 void CommandSound::printHelp() {
-    getConsole() << "sound-Command Usage:" << Console::endl;
-    getConsole() << "sound-Command Usage:" << Console::endl;
-    getConsole() << "  sound INT" << Console::endl;
-    getConsole() << "Where INT is a valid sound ID integer" << Console::endl;
+    getLog() << "sound-Command Usage:" << Log::endl;
+    getLog() << "sound-Command Usage:" << Log::endl;
+    getLog() << "  sound INT" << Log::endl;
+    getLog() << "Where INT is a valid sound ID integer" << Log::endl;
 }
 
 int CommandSound::execute(std::istream& args) {
     if (!getGame().isLoaded()) {
-        getConsole() << "Use sound command interactively!" << Console::endl;
+        getLog() << "Use sound command interactively!" << Log::endl;
         return -1;
     }
 

src/loader/LoaderTR2.cpp

 #include <vector>
 
 #include "global.h"
-#include "Console.h"
+#include "Log.h"
 #include "loader/LoaderTR2.h"
 
 LoaderTR2::LoaderTR2() {
     }
 
     loadPaletteTextiles();
-    getConsole() << "->loaded palette" << Console::endl;
+    getLog() << "->loaded palette" << Log::endl;
 
     file.seek(file.tell() + 4); // Unused value?
 
     loadRooms();
-    getConsole() << "->loaded rooms" << Console::endl;
+    getLog() << "->loaded rooms" << Log::endl;
 
     loadFloorData();
-    getConsole() << "->loaded floor data" << Console::endl;
+    getLog() << "->loaded floor data" << Log::endl;
 
     loadMeshes();
-    getConsole() << "->loaded meshes" << Console::endl;
+    getLog() << "->loaded meshes" << Log::endl;
 
     loadMoveables();
-    getConsole() << "->loaded moveables" << Console::endl;
+    getLog() << "->loaded moveables" << Log::endl;
 
     loadStaticMeshes();
-    getConsole() << "->loaded static meshes" << Console::endl;
+    getLog() << "->loaded static meshes" << Log::endl;
 
     loadTextures();
-    getConsole() << "->loaded textures" << Console::endl;
+    getLog() << "->loaded textures" << Log::endl;
 
     loadSprites();
-    getConsole() << "->loaded sprites" << Console::endl;
+    getLog() << "->loaded sprites" << Log::endl;
 
     loadCameras();
-    getConsole() << "->loaded cameras" << Console::endl;
+    getLog() << "->loaded cameras" << Log::endl;
 
     loadSoundSources();
-    getConsole() << "->loaded sound sources" << Console::endl;
+    getLog() << "->loaded sound sources" << Log::endl;
 
     loadBoxesOverlapsZones();
-    getConsole() << "->loaded boxes overlaps zones" << Console::endl;
+    getLog() << "->loaded boxes overlaps zones" << Log::endl;
 
     loadAnimatedTextures();
-    getConsole() << "->loaded animated textures" << Console::endl;
+    getLog() << "->loaded animated textures" << Log::endl;
 
     loadItems();
-    getConsole() << "->loaded items" << Console::endl;
+    getLog() << "->loaded items" << Log::endl;
 
     file.seek(file.tell() + 8192); // Skip Light map, only for 8bit coloring
 
     loadCinematicFrames();
-    getConsole() << "->loaded cinematic frames" << Console::endl;
+    getLog() << "->loaded cinematic frames" << Log::endl;
 
     loadDemoData();
-    getConsole() << "->loaded demo data" << Console::endl;
+    getLog() << "->loaded demo data" << Log::endl;
 
     loadSoundMap();
-    getConsole() << "->loaded sound map" << Console::endl;
+    getLog() << "->loaded sound map" << Log::endl;
 
     loadSoundDetails();
-    getConsole() << "->loaded sound details" << Console::endl;
+    getLog() << "->loaded sound details" << Log::endl;
 
     loadSampleIndices();
-    getConsole() << "->loaded sample indices" << Console::endl;
+    getLog() << "->loaded sample indices" << Log::endl;
 
     return 0;
 }

src/main.cpp

 #include "Debug.h"
 #include "FontManager.h"
 #include "Game.h"
+#include "Log.h"
 #include "MenuFolder.h"
 #include "Render.h"
 #include "RunTime.h"
 static std::shared_ptr<Debug> gDebug;
 static std::shared_ptr<FontManager> gFont;
 static std::shared_ptr<Game> gGame;
+static std::shared_ptr<Log> gLog;
 static std::shared_ptr<MenuFolder> gMenu;
 static std::shared_ptr<Render> gRender;
 static std::shared_ptr<RunTime> gRunTime;
     return *gGame;
 }
 
+Log &getLog() {
+    return *gLog;
+}
+
 Menu &getMenu() {
     return *gMenu;
 }
     gDebug.reset(new Debug());
     gFont.reset(new FontManager());
     gGame.reset(new Game());
+    gLog.reset(new Log());
     gMenu.reset(new MenuFolder());
     gRender.reset(new Render());
     gRunTime.reset(new RunTime());
         Command::executeFile(configFileToUse);
     }
 
-    getConsole() << "Initializing " << VERSION << Console::endl;
+    getLog() << "Initializing " << VERSION << Log::endl;
 
     // Initialize Windowing
     int error = getWindow().initialize();
         return -6;
     }
 
-    getConsole() << "Starting " << VERSION << Console::endl;
+    getLog() << "Starting " << VERSION << Log::endl;
     getMenu().moveToTop();
     systemTimerReset();
     getRunTime().setRunning(true);