Console now made with imgui

ChangeLog.md

 
 ## OpenRaider (0.1.3) xythobuz <xythobuz@xythobuz.de>
 
+    [ 20140905 ]
+    * Recreated working console using imgui
+
     [ 20140904 ]
     * Fixed imgui colors
     * 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.
+    * Removed Console, Debug
+    * Removed new fancy UI handling system
+    * Properly integrated imgui into UI system
 
     [ 20140903 ]
     * Finishing imgui integration, but now as UI layer and not on top of everything

README.md

 | Key               | Action                |
 | -----------------:|:--------------------- |
 | <Esc>       | Toggle menu           |
-| <backquote> | Console toggle on/off |
 | q                 | Toggle debug windows  |
 | w                 | Move forward          |
 | s                 | Move back             |
 
 The [clibs/commander](https://github.com/clibs/commander) dependency is Copyright (c) 2012 TJ Holowaychuk (tj@vision-media.ca) and licensed under the [MIT License](http://opensource.org/licenses/MIT).
 
-The included [utf8-cpp](http://utfcpp.sourceforge.net) headers are Copyright (c) 2006 Nemanja Trifunovic. See the files in src/deps/utf8-cpp/ for informations about the license used.
-
 The included GUI lib, [imgui](https://github.com/ocornut/imgui/) is Copyright (c) 2014 Omar Cornut. See src/deps/imgui/LICENSE for more informations about the MIT license used.
 

data/OpenRaider.ini

 set mouse_y    0.75
 
 bind menu     "escape"
-bind console  "backquote"
 bind debug    'q'
 bind forward  'w'
 bind backward 's'

include/Console.h

-/*!
- * \file include/Console.h
- * \brief Console 'overlay'
- *
- * \author xythobuz
- */
-
-#ifndef _CONSOLE_H_
-#define _CONSOLE_H_
-
-#include <string>
-#include <vector>
-
-#include "UI.h"
-
-/*!
- * \brief Console 'overlay'
- */
-class Console : public UI {
-public:
-
-    Console();
-    ~Console();
-
-    virtual void moveToTop();
-    virtual void makeInvisible();
-    virtual void display();
-    virtual void handleKeyboard(KeyboardButton key, bool pressed);
-    virtual void handleText(char *text, bool notFinished);
-    virtual void handleMouseScroll(int xrel, int yrel);
-
-private:
-
-    void moveInHistory(bool up);
-
-    std::string mInputBuffer;
-    std::string mPartialInput;
-
-    size_t mHistoryPointer;
-    std::vector<std::string> mCommandHistory;
-    std::string mUnfinishedInput;
-
-    unsigned int mLineOffset;
-};
-
-Console &getConsole();
-
-#endif

include/Debug.h

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

include/Game.h

 #include <vector>
 
 #include "Entity.h"
-#include "UI.h"
 #include "TombRaider.h"
 
-/*!
- * \brief Game abstraction
- */
-class Game : public UI {
+class Game {
 public:
 
     Game();
     ~Game();
 
-    virtual int initialize();
+    int initialize();
 
     bool isLoaded();
 
 
     void destroy();
 
-    virtual void display();
-    virtual void handleAction(ActionEvents action, bool isFinished);
-    virtual void handleMouseMotion(int xrel, int yrel, int xabs, int yabs);
-    virtual void moveToTop() { }
-    virtual void makeInvisible() { }
+    void display();
+    void handleAction(ActionEvents action, bool isFinished);
+    void handleMouseMotion(int xrel, int yrel, int xabs, int yabs);
 
     unsigned int getTextureStart();
     unsigned int getTextureOffset();

include/Menu.h

 
 #include <functional>
 
-#include "UI.h"
-
-/*!
- * \brief Menu 'overlay'
- */
-class Menu : public UI {
+class Menu {
 public:
 
     virtual ~Menu() { }
 
     virtual int initialize() = 0;
 
+    virtual void display() = 0;
+
+    virtual void handleKeyboard(KeyboardButton key, bool pressed) = 0;
+
+    virtual void handleMouseClick(unsigned int x, unsigned int y,
+            KeyboardButton button, bool released) = 0;
+
+    virtual void handleMouseScroll(int xrel, int yrel) = 0;
+
+    bool isVisible() { return visible; }
+
+    void setVisible(bool v) { visible = v; }
+
 protected:
 
     virtual void showDialog(std::string msg, std::string btn1, std::string btn2,
     std::string dialogButton1;
     std::string dialogButton2;
     std::function<int (bool state)> dialogFunction;
+
+    bool visible;
 };
 
 Menu &getMenu();

include/MenuFolder.h

 
     virtual void display();
     virtual void handleKeyboard(KeyboardButton key, bool pressed);
-    virtual void handleMouseClick(unsigned int x, unsigned int y, KeyboardButton button, bool released);
+    virtual void handleMouseClick(unsigned int x, unsigned int y,
+            KeyboardButton button, bool released);
     virtual void handleMouseScroll(int xrel, int yrel);
 
 private:

include/UI.h

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

include/global.h

 // Actions that can be bound to a key and sent to the game engine
 typedef enum {
     menuAction = 0,
-    consoleAction,
     debugAction,
 
     forwardAction,

src/CMakeLists.txt

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

src/Console.cpp

-/*!
- * \file src/Console.cpp
- * \brief Console 'overlay'
- *
- * \author xythobuz
- */
-
-#include <iostream>
-
-#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"
-#include "Window.h"
-#include "Console.h"
-
-Console::Console() {
-    zPos = -1;
-    mHistoryPointer = 0;
-    mLineOffset = 0;
-
-    UI::addWindow(this);
-}
-
-Console::~Console() {
-    UI::removeWindow(this);
-}
-
-void Console::moveToTop() {
-    if (!getWindow().getTextInput())
-        getWindow().setTextInput(true);
-
-    UI::moveToTop();
-}
-
-void Console::makeInvisible() {
-    if (getWindow().getTextInput())
-        getWindow().setTextInput(false);
-
-    UI::makeInvisible();
-}
-
-void Console::display() {
-    // Calculate line drawing geometry
-    // Depends on window height, so recalculate every time
-    unsigned int firstLine = 35;
-    unsigned int lastLine = (::getWindow().getHeight() / 2) - 55;
-    unsigned int inputLine = (::getWindow().getHeight() / 2) - 30;
-    unsigned int lineSteps = 20;
-    unsigned int lineCount = (lastLine - firstLine + lineSteps) / lineSteps;
-    while (((lineCount * lineSteps) + firstLine) < inputLine) {
-        lineSteps++;
-        lineCount = (lastLine - firstLine + lineSteps) / lineSteps;
-    }
-
-    ::getWindow().glEnter2D();
-
-    // Draw half-transparent *overlay*
-    glColor4f(0.0f, 0.0f, 0.0f, 0.75f);
-    glDisable(GL_TEXTURE_2D);
-    glRecti(0, 0, ::getWindow().getWidth(), ::getWindow().getHeight() / 2);
-    glEnable(GL_TEXTURE_2D);
-
-    unsigned long scrollIndicator;
-    if (getLog().size() > lineCount) {
-        scrollIndicator = (getLog().size() - lineCount - mLineOffset) * 100 / (getLog().size() - lineCount);
-    } else {
-        scrollIndicator = 100;
-        mLineOffset = 0;
-    }
-
-    // Draw status line
-    std::ostringstream status;
-    status << VERSION << " uptime " << (systemTimerGet() / 1000) << "s scroll " << scrollIndicator << "%";
-    getFont().drawText(10, 10, 0.70f, BLUE, status.str());
-
-    // Draw output log
-    long end = lineCount;
-    long drawOffset = 0;
-    long historyOffset = 0;
-    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, getLog().get(i + historyOffset - mLineOffset));
-    }
-
-    // Draw current input
-    getFont().drawText(10, inputLine, 0.75f, BLUE, "> " + mInputBuffer + mPartialInput);
-
-    ::getWindow().glExit2D();
-}
-
-void Console::handleKeyboard(KeyboardButton key, bool pressed) {
-    if (pressed && (key == enterKey)) {
-        // Execute entered command
-        if (mInputBuffer.length() > 0) {
-            getLog() << "> " << mInputBuffer.c_str() << Log::endl;
-            mCommandHistory.push_back(mInputBuffer.c_str());
-            int error = Command::command(mInputBuffer);
-            if (error != 0) {
-                getLog() << "Error Code: " << error << Log::endl;
-            }
-        } else {
-            getLog() << "> " << Log::endl;
-        }
-
-        // Clear partial and input buffer
-        mInputBuffer = "";
-        mPartialInput = "";
-        mHistoryPointer = 0;
-    }
-
-    // Delete last character
-    if (pressed && (key == backspaceKey)) {
-        if ((mPartialInput.length() == 0)
-                && (mInputBuffer.length() > 0)) {
-            utf8::iterator<std::string::iterator> it(mInputBuffer.end(), mInputBuffer.begin(), mInputBuffer.end());
-            mInputBuffer.erase((--it).base(), mInputBuffer.end());
-        }
-    }
-
-    if (pressed && ((key == upKey) || (key == downKey))) {
-        moveInHistory(key == upKey);
-    }
-}
-
-void Console::moveInHistory(bool up) {
-    if (mCommandHistory.size() == 0)
-        return;
-
-    if (up) {
-        if (mHistoryPointer < mCommandHistory.size()) {
-            mHistoryPointer++;
-            if (mHistoryPointer == 1) {
-                mUnfinishedInput = mInputBuffer;
-            }
-        } else {
-            return;
-        }
-    } else {
-        if (mHistoryPointer > 0)
-            mHistoryPointer--;
-        else
-            return;
-    }
-
-    if ((mHistoryPointer > 0) && (mHistoryPointer <= mCommandHistory.size())) {
-        mInputBuffer = mCommandHistory[mCommandHistory.size() - mHistoryPointer];
-    } else {
-        if (mUnfinishedInput.length() > 0) {
-            mInputBuffer = mUnfinishedInput;
-            mUnfinishedInput = "";
-        } else {
-            mInputBuffer = "";
-        }
-    }
-}
-
-void Console::handleText(char *text, bool notFinished) {
-    // Always scroll to bottom when text input is received
-    mLineOffset = 0;
-
-    if (!notFinished) {
-        // Finished entering character
-        // delete previous partial character, if present
-        mPartialInput = "";
-
-        //! \fixme Temporary hack filtering the console activation key
-        if (text[0] == '`')
-            return;
-
-        // Append new input to buffer
-        mInputBuffer += text;
-    } else {
-        // Partial character received
-        mPartialInput = text;
-    }
-}
-
-void Console::handleMouseScroll(int xrel, int yrel) {
-    assert((xrel != 0) || (yrel != 0));
-
-    // Calculate line drawing geometry
-    // Depends on window height, so recalculate every time
-    unsigned int firstLine = 35;
-    unsigned int lastLine = (::getWindow().getHeight() / 2) - 55;
-    unsigned int inputLine = (::getWindow().getHeight() / 2) - 30;
-    unsigned int lineSteps = 20;
-    unsigned int lineCount = (lastLine - firstLine + lineSteps) / lineSteps;
-    while (((lineCount * lineSteps) + firstLine) < inputLine) {
-        lineSteps++;
-        lineCount = (lastLine - firstLine + lineSteps) / lineSteps;
-    }
-
-    if (getLog().size() > lineCount) {
-        if (yrel > 0) {
-            if (mLineOffset < (getLog().size() - lineCount)) {
-                mLineOffset++;
-            }
-        } else if (yrel < 0) {
-            if (mLineOffset > 0) {
-                mLineOffset--;
-            }
-        }
-    }
-}
-

src/Debug.cpp

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

src/Game.cpp

 #endif
 
 Game::Game() {
-    zPos = 0;
     mLoaded = false;
     mLara = -1;
     mTextureStart = 0;
     mTextureOffset = 0;
-
-    UI::addWindow(this);
 }
 
 Game::~Game() {
-    UI::removeWindow(this);
 }
 
 unsigned int Game::getTextureStart() {

src/MenuFolder.cpp

 #include "MenuFolder.h"
 
 MenuFolder::MenuFolder() {
-    zPos = -1;
     mCursor = 0;
     mMin = 0;
     mapFolder = nullptr;
     hiddenState = false;
     dialogState = false;
-
-    UI::addWindow(this);
+    visible = false;
 }
 
 MenuFolder::~MenuFolder() {
     delete mapFolder;
     mapFolder = nullptr;
-
-    UI::removeWindow(this);
 }
 
 int MenuFolder::initialize() {
 }
 
 void MenuFolder::display() {
+    if (!visible)
+        return;
+
     ::getWindow().glEnter2D();
 
     // Draw half-transparent overlay
         int error = getGame().loadLevel(mapFolder->getFile((unsigned long)mCursor
                     - 1 - mapFolder->folderCount()).getPath().c_str());
         if (error == 0) {
-            makeInvisible();
+            visible = false;
         } else {
             std::ostringstream err;
             err << "Error loading map: " << error << "!";

src/RunTime.cpp

 
     // Default key bindings
     keyBindings[menuAction] = escapeKey;
-    keyBindings[consoleAction] = backquoteKey;
+    keyBindings[debugAction] = qKey;
     keyBindings[forwardAction] = wKey;
     keyBindings[backwardAction] = sKey;
     keyBindings[leftAction] = aKey;

src/UI.cpp

 #include <algorithm>
 
 #include "global.h"
-#include "Console.h"
-#include "Debug.h"
+#include "Game.h"
+#include "Log.h"
 #include "Menu.h"
 #include "RunTime.h"
 #include "TextureManager.h"
 #include "Window.h"
+#include "commands/Command.h"
+#include "utils/time.h"
+#include "UI.h"
+
+#define STB_IMAGE_IMPLEMENTATION
+#include "imgui/stb_image.h"
+
+bool UI::visible = false;
+unsigned int UI::fontTex;
+std::string UI::iniFilename;
+std::string UI::logFilename;
+
+std::list<std::tuple<KeyboardButton, bool>> UI::keyboardEvents;
+std::list<std::tuple<unsigned int, unsigned int, KeyboardButton, bool>> UI::clickEvents;
+std::list<std::tuple<int, int, int, int>> UI::motionEvents;
+std::list<std::tuple<int, int>> UI::scrollEvents;
+
+int UI::initialize() {
+    iniFilename = getRunTime().getBaseDir() + "/imgui.ini";
+    logFilename = getRunTime().getBaseDir() + "/imgui_log.txt";
+
+    ImGuiIO& io = ImGui::GetIO();
+    io.DisplaySize = ImVec2((float)getWindow().getWidth(), (float)getWindow().getHeight());
+    io.DeltaTime = 1.0f / 60.0f;
+
+    io.IniFilename = iniFilename.c_str();
+    io.LogFilename = logFilename.c_str();
+
+    io.KeyMap[ImGuiKey_Tab] = tabKey;
+    io.KeyMap[ImGuiKey_LeftArrow] = leftKey;
+    io.KeyMap[ImGuiKey_RightArrow] = rightKey;
+    io.KeyMap[ImGuiKey_UpArrow] = upKey;
+    io.KeyMap[ImGuiKey_DownArrow] = downKey;
+    io.KeyMap[ImGuiKey_Home] = homeKey;
+    io.KeyMap[ImGuiKey_End] = endKey;
+    io.KeyMap[ImGuiKey_Delete] = delKey;
+    io.KeyMap[ImGuiKey_Backspace] = backspaceKey;
+    io.KeyMap[ImGuiKey_Enter] = enterKey;
+    io.KeyMap[ImGuiKey_Escape] = escapeKey;
+    io.KeyMap[ImGuiKey_A] = aKey;
+    io.KeyMap[ImGuiKey_C] = cKey;
+    io.KeyMap[ImGuiKey_V] = vKey;
+    io.KeyMap[ImGuiKey_X] = xKey;
+    io.KeyMap[ImGuiKey_Y] = yKey;
+    io.KeyMap[ImGuiKey_Z] = zKey;
+
+    io.RenderDrawListsFn = UI::renderImGui;
+
+    // Load font texture
+    //! \todo Use our own font subsystem instead of this?
+    const void* png_data;
+    unsigned int png_size;
+    ImGui::GetDefaultFontData(NULL, NULL, &png_data, &png_size);
+    int tex_x, tex_y, tex_comp;
+    void* tex_data = stbi_load_from_memory((const unsigned char*)png_data,
+            (int)png_size, &tex_x, &tex_y, &tex_comp, 0);
+
+     //! \fixme TODO use proper slot
+    fontTex = getTextureManager().loadBufferSlot((unsigned char *)tex_data,
+            tex_x, tex_y, RGBA, 32, 0, false);
+
+    stbi_image_free(tex_data);
 
-std::vector<UI*> UI::windows;
-
-UI::~UI() {
+    return 0;
 }
 
-int UI::initialize() { return 0; }
-void UI::eventsFinished() { }
-void UI::display() { }
-void UI::calculate() { }
-void UI::shutdown() { }
-void UI::handleKeyboard(KeyboardButton key, bool pressed) { }
-void UI::handleText(char *text, bool notFinished) { }
-void UI::handleAction(ActionEvents action, bool isFinished) { }
-void UI::handleMouseClick(unsigned int x, unsigned int y, KeyboardButton button, bool released) { }
-void UI::handleMouseMotion(int xrel, int yrel, int xabs, int yabs) { }
-void UI::handleMouseScroll(int xrel, int yrel) { }
-
-int UI::passInitialize() {
-    for (auto &x : windows) {
-        int error = x->initialize();
-        if (error != 0)
-            return error;
-    }
+void UI::eventsFinished() {
+    ImGuiIO& io = ImGui::GetIO();
+    io.DisplaySize = ImVec2((float)getWindow().getWidth(), (float)getWindow().getHeight());
 
-    return 0;
-}
+    static long lastTime = 0;
+    io.DeltaTime = ((float)(systemTimerGet() - lastTime)) / 1000.0f;
+    lastTime = systemTimerGet();
 
-void UI::passEvents() {
-    for (auto &x : windows) {
-        x->eventsFinished();
-    }
-}
+    ImGui::NewFrame();
+
+    bool clicked = !clickEvents.empty();
 
-void UI::passDisplay() {
-    std::sort(windows.begin(), windows.end(), compareUIs);
-    for (auto &x : windows) {
-        if (x->zPos >= 0) {
-            x->display();
+    if (!visible) {
+        while (!clickEvents.empty()) {
+            auto i = clickEvents.front();
+            if (getMenu().isVisible()) {
+                getMenu().handleMouseClick(std::get<0>(i), std::get<1>(i),
+                        std::get<2>(i), std::get<3>(i));
+            }
+            clickEvents.pop_front();
         }
-    }
-}
 
-void UI::passCalculate() {
-    for (auto &x : windows) {
-        x->calculate();
-    }
-}
+        while (!motionEvents.empty()) {
+            auto i = motionEvents.front();
+            if (!getMenu().isVisible()) {
+                getGame().handleMouseMotion(std::get<0>(i), std::get<1>(i),
+                        std::get<2>(i), std::get<3>(i));
+            }
+            motionEvents.pop_front();
+        }
 
-void UI::passShutdown() {
-    for (auto &x : windows) {
-        x->shutdown();
+        while (!scrollEvents.empty()) {
+            auto i = scrollEvents.front();
+            if (getMenu().isVisible()) {
+                getMenu().handleMouseScroll(std::get<0>(i), std::get<1>(i));
+            }
+            scrollEvents.pop_front();
+        }
     }
-}
 
-void UI::passKeyboard(KeyboardButton key, bool pressed) {
-    if (pressed) {
-        if (getRunTime().getKeyBinding(menuAction) == key) {
-            if (getMenu().isOnTop()) {
-                getMenu().makeInvisible();
-            } else {
-                getMenu().moveToTop();
-            }
-        } else if (getRunTime().getKeyBinding(consoleAction) == key) {
-            if (getConsole().isOnTop()) {
-                getConsole().makeInvisible();
+    if ((!io.WantCaptureKeyboard) || (!visible)) {
+        while (!keyboardEvents.empty()) {
+            auto i = keyboardEvents.front();
+
+            if (getMenu().isVisible()) {
+                getMenu().handleKeyboard(std::get<0>(i), std::get<1>(i));
             } else {
-                getConsole().moveToTop();
+                for (int n = forwardAction; n < ActionEventCount; n++) {
+                    if (getRunTime().getKeyBinding((ActionEvents)n) == std::get<0>(i))
+                        getGame().handleAction((ActionEvents)n, !std::get<1>(i));
+                }
             }
-        } else if (getRunTime().getKeyBinding(debugAction) == key) {
-            if (!getDebug().isOnTop()) {
-                getDebug().moveToTop();
+
+            if (std::get<1>(i)) {
+                if (getRunTime().getKeyBinding(menuAction) == std::get<0>(i)) {
+                    getMenu().setVisible(!getMenu().isVisible());
+                } else if (getRunTime().getKeyBinding(debugAction) == std::get<0>(i)) {
+                    visible = !visible;
+                }
             }
+
+            keyboardEvents.pop_front();
         }
     }
 
-    auto maxIterator = std::max_element(windows.begin(), windows.end(), compareUIs);
-    (*maxIterator)->handleKeyboard(key, pressed);
-
-    for (int i = forwardAction; i < ActionEventCount; i++) {
-        if (getRunTime().getKeyBinding((ActionEvents)i) == key) {
-            (*maxIterator)->handleAction((ActionEvents)i, !pressed);
-        }
+    if ((!io.WantCaptureKeyboard) && (!io.WantCaptureMouse) && visible && clicked) {
+        visible = false;
     }
 
-    bool mousegrab = (*maxIterator)->zPos == 0;
-    if (mousegrab != getWindow().getMousegrab())
-        getWindow().setMousegrab(mousegrab);
+    keyboardEvents.clear();
+    clickEvents.clear();
+    motionEvents.clear();
+    scrollEvents.clear();
+
+    if (getWindow().getTextInput() != visible)
+        getWindow().setTextInput(visible);
+
+    bool input = !(visible || getMenu().isVisible());
+    if (getWindow().getMousegrab() != input)
+        getWindow().setMousegrab(input);
 }
 
-void UI::passText(char *text, bool notFinished) {
-    auto maxIterator = std::max_element(windows.begin(), windows.end(), compareUIs);
-    (*maxIterator)->handleText(text, notFinished);
+void UI::display() {
+    if (visible)
+        ImGui::Render();
 }
 
-void UI::passMouseClick(unsigned int x, unsigned int y, KeyboardButton button, bool released) {
-    auto maxIterator = std::max_element(windows.begin(), windows.end(), compareUIs);
-    (*maxIterator)->handleMouseClick(x, y, button, released);
+void UI::calculate() {
+    static char buffer[256];
+    static bool scrollToBottom = false;
 
-    for (int i = forwardAction; i < ActionEventCount; i++) {
-        if (getRunTime().getKeyBinding((ActionEvents)i) == button) {
-            (*maxIterator)->handleAction((ActionEvents)i, released);
+    ImGui::Begin("Console", NULL, ImVec2(600, 400), -1.0f);
+        ImGui::BeginChild("ConsoleText", ImVec2(ImGui::GetWindowWidth(), ImGui::GetWindowSize().y - 70));
+            for (int i = 0; i < getLog().size(); i++) {
+                ImGui::Text("%s", getLog().get(i).c_str());
+            }
+            if (scrollToBottom) {
+                ImGui::SetScrollPosHere();
+                scrollToBottom = false;
+            }
+        ImGui::EndChild();
+
+        bool enter = false;
+        ImGui::InputText("Command", buffer, 256, ImGuiInputTextFlags_AutoSelectAll, &enter);
+        if (enter) {
+            getLog() << "> " << buffer << Log::endl;
+            int error = Command::command(buffer);
+            if (error != 0) {
+                getLog() << "Error code: " << error << Log::endl;
+            }
+            buffer[0] = '\0';
+            scrollToBottom = true;
         }
-    }
+    ImGui::End();
+
+    //ImGui::Begin("UI Style");
+    //    ImGui::ShowStyleEditor();
+    //ImGui::End();
+
+    //ImGui::Begin("Help");
+    //    ImGui::ShowUserGuide();
+    //ImGui::End();
+
+    //ImGui::ShowTestWindow();
 }
 
-void UI::passMouseMotion(int xrel, int yrel, int xabs, int yabs) {
-    auto maxIterator = std::max_element(windows.begin(), windows.end(), compareUIs);
-    (*maxIterator)->handleMouseMotion(xrel, yrel, xabs, yabs);
+void UI::shutdown() {
+    ImGui::Shutdown();
 }
 
-void UI::passMouseScroll(int xrel, int yrel) {
-    auto maxIterator = std::max_element(windows.begin(), windows.end(), compareUIs);
-    (*maxIterator)->handleMouseScroll(xrel, yrel);
+void UI::handleKeyboard(KeyboardButton key, bool pressed) {
+    ImGuiIO& io = ImGui::GetIO();
+    io.KeysDown[key] = pressed;
+    io.KeyCtrl = io.KeysDown[leftctrlKey] | io.KeysDown[rightctrlKey];
+    io.KeyShift = io.KeysDown[leftshiftKey] | io.KeysDown[rightshiftKey];
+
+    keyboardEvents.push_back(std::make_tuple(key, pressed));
 }
 
-void UI::addWindow(UI* window) {
-    windows.push_back(window);
+void UI::handleText(char *text, bool notFinished) {
+    ImGuiIO& io = ImGui::GetIO();
+    while (*text != '\0') {
+        io.AddInputCharacter(*text);
+        text++;
+    }
 }
 
-void UI::removeWindow(UI *window) {
-    if (windows.size() == 0) {
-        // It seems as if our list was destroyed before the UIs
-        return;
+void UI::handleMouseClick(unsigned int x, unsigned int y, KeyboardButton button, bool released) {
+    ImGuiIO& io = ImGui::GetIO();
+    io.MousePos = ImVec2((float)x, (float)y);
+    if (button == leftmouseKey) {
+        io.MouseDown[0] = !released;
+    } else if (button == rightmouseKey) {
+        io.MouseDown[1] = !released;
+    } else if (button == middlemouseKey) {
+        io.MouseDown[2] = !released;
+    } else if (button == fourthmouseKey) {
+        io.MouseDown[3] = !released;
+    } else if (button == fifthmouseKey) {
+        io.MouseDown[4] = !released;
     }
 
-    findInList(window, [](unsigned long i){
-        windows.erase(windows.begin() + i);
-    });
+    clickEvents.push_back(std::make_tuple(x, y, button, released));
 }
 
-bool UI::compareUIs(UI* a, UI* b) {
-    return a->zPos < b->zPos;
-}
+void UI::handleMouseMotion(int xrel, int yrel, int xabs, int yabs) {
+    ImGuiIO& io = ImGui::GetIO();
+    io.MousePos = ImVec2((float)xabs, (float)yabs);
 
-bool UI::isOnTop(unsigned long windowID) {
-    assert(windowID < windows.size());
-    auto maxIterator = std::max_element(windows.begin(), windows.end(), compareUIs);
-    unsigned long maxPos = (unsigned long)(maxIterator - windows.begin());
-    return (maxPos == windowID);
+    motionEvents.push_back(std::make_tuple(xrel, yrel, xabs, yabs));
 }
 
-void UI::moveToTop(unsigned long windowID) {
-    assert(windowID < windows.size());
+void UI::handleMouseScroll(int xrel, int yrel) {
+    ImGuiIO& io = ImGui::GetIO();
+    io.MouseWheel = (yrel != 0) ? yrel > 0 ? 1 : -1 : 0;
 
-    auto maxIterator = std::max_element(windows.begin(), windows.end(), compareUIs);
-    long max = (*maxIterator)->zPos;
-    unsigned long maxPos = (unsigned long)(maxIterator - windows.begin());
+    scrollEvents.push_back(std::make_tuple(xrel, yrel));
+}
 
-    if (maxPos != windowID) {
-        windows.at(windowID)->zPos = max + 1;
-    }
+void UI::setVisible(bool v) {
+    visible = v;
 }
 
-void UI::makeInvisible(unsigned long windowID) {
-    assert(windowID < windows.size());
-    windows.at(windowID)->zPos = -1;
+bool UI::isVisible() {
+    return visible;
 }
 
-void UI::findInList(UI *w, std::function<void (unsigned long i)> func) {
-    for (unsigned long i = 0; i < windows.size(); i++) {
-        auto UIptr = &(*windows.at(i));
-        if (w == UIptr) {
-            func(i);
-            return;
+void UI::renderImGui(ImDrawList** const cmd_lists, int cmd_lists_count) {
+    if (cmd_lists_count == 0)
+        return;
+
+    getWindow().glEnter2D();
+
+    glDisable(GL_DEPTH_TEST);
+    glEnable(GL_SCISSOR_TEST);
+
+    glEnableClientState(GL_VERTEX_ARRAY);
+    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+    glEnableClientState(GL_COLOR_ARRAY);
+
+    // Setup texture
+    getTextureManager().bindTextureId(fontTex);
+
+    // Render command lists
+    for (int n = 0; n < cmd_lists_count; n++) {
+        const ImDrawList* cmd_list = cmd_lists[n];
+        const unsigned char* vtx_buffer = (const unsigned char*)cmd_list->vtx_buffer.begin();
+        glVertexPointer(2, GL_FLOAT, sizeof(ImDrawVert), (void*)(vtx_buffer));
+        glTexCoordPointer(2, GL_FLOAT, sizeof(ImDrawVert), (void*)(vtx_buffer+8));
+        glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(ImDrawVert), (void*)(vtx_buffer+16));
+
+        int vtx_offset = 0;
+        const ImDrawCmd* pcmd_end = cmd_list->commands.end();
+        for (const ImDrawCmd* pcmd = cmd_list->commands.begin(); pcmd != pcmd_end; pcmd++) {
+            glScissor((int)pcmd->clip_rect.x, (int)(ImGui::GetIO().DisplaySize.y - pcmd->clip_rect.w),
+                    (int)(pcmd->clip_rect.z - pcmd->clip_rect.x),
+                    (int)(pcmd->clip_rect.w - pcmd->clip_rect.y));
+            glDrawArrays(GL_TRIANGLES, vtx_offset, pcmd->vtx_count);
+            vtx_offset += pcmd->vtx_count;
         }
     }
 
-    assert(false); // called UI was not registered
-}
+    glEnable(GL_DEPTH_TEST);
+    glDisable(GL_SCISSOR_TEST);
 
-bool UI::isOnTop() {
-    bool top = false;
-    findInList(this, [&](unsigned long i) {
-        top = UI::isOnTop(i);
-    });
-    return top;
-}
-
-void UI::moveToTop() {
-    findInList(this, [](unsigned long i) {
-        UI::moveToTop(i);
-    });
-}
+    glDisableClientState(GL_VERTEX_ARRAY);
+    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+    glDisableClientState(GL_COLOR_ARRAY);
 
-void UI::makeInvisible() {
-    findInList(this, [](unsigned long i) {
-        UI::makeInvisible(i);
-    });
+    getWindow().glExit2D();
 }
 

src/WindowSDL.cpp

     while(SDL_PollEvent(&event)) {
         switch (event.type) {
             case SDL_MOUSEMOTION:
-                UI::passMouseMotion(event.motion.xrel, event.motion.yrel, event.motion.x, event.motion.y);
+                UI::handleMouseMotion(event.motion.xrel, event.motion.yrel, event.motion.x, event.motion.y);
                 break;
 
             case SDL_MOUSEBUTTONDOWN:
                     button = fifthmouseKey;
                 else
                     button = unknownKey;
-                UI::passMouseClick(event.button.x, event.button.y, button, (event.type == SDL_MOUSEBUTTONUP));
+                UI::handleMouseClick(event.button.x, event.button.y, button, (event.type == SDL_MOUSEBUTTONUP));
                 break;
 
             case SDL_MOUSEWHEEL:
                 if ((event.wheel.x != 0) || (event.wheel.y != 0))
-                    UI::passMouseScroll(event.wheel.x, event.wheel.y);
+                    UI::handleMouseScroll(event.wheel.x, event.wheel.y);
                 break;
 
             case SDL_TEXTINPUT:
             case SDL_TEXTEDITING:
                 if (event.text.text != NULL)
-                    UI::passText(event.text.text, (event.type == SDL_TEXTEDITING));
+                    UI::handleText(event.text.text, (event.type == SDL_TEXTEDITING));
                 break;
 
             case SDL_KEYDOWN:
                         break;
 
                 }
-                UI::passKeyboard(key, (event.type == SDL_KEYDOWN));
+                UI::handleKeyboard(key, (event.type == SDL_KEYDOWN));
                 break;
 
             case SDL_WINDOWEVENT:
         }
     }
 
-    UI::passEvents();
+    UI::eventsFinished();
 }
 
 void WindowSDL::setTextInput(bool on) {

src/commands/CommandBind.cpp

     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;
 ActionEvents CommandBind::stringToActionEvent(std::string action) {
     if (action == "menu") {
         return menuAction;
-    } else if (action == "console") {
-        return consoleAction;
     } else if (action == "debug") {
         return debugAction;
     } else if (action == "forward") {

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"
+#include "UI.h"
 #include "commands/CommandEngine.h"
 
 std::string CommandLoad::name() {
 
 void CommandScreenshot::printHelp() {
     getLog() << "sshot-Command Usage:" << Log::endl;
-    getLog() << "  sshot [console|menu] [console|menu]" << Log::endl;
+    getLog() << "  sshot [debug|menu] [debug|menu]" << Log::endl;
     getLog() << "Add console/menu to capture them too" << Log::endl;
 }
 
     std::string temp, temp2;
     args >> temp >> temp2;
 
-    getConsole().makeInvisible();
-    getMenu().makeInvisible();
+    UI::setVisible(false);
+    getMenu().setVisible(false);
 
-    if (temp == "console")
-        getConsole().moveToTop();
+    if (temp == "debug")
+        UI::setVisible(true);
     else if (temp == "menu")
-        getMenu().moveToTop();
+        getMenu().setVisible(true);
 
-    if (temp2 == "console")
-        getConsole().moveToTop();
+    if (temp2 == "debug")
+        UI::setVisible(true);
     else if (temp2 == "menu")
-        getMenu().moveToTop();
+        getMenu().setVisible(true);
 
     renderFrame();
     renderFrame(); // Double buffered
     getRender().screenShot(filename.c_str());
 
-    getMenu().makeInvisible();
-    getConsole().moveToTop();
+    getMenu().setVisible(false);
+    UI::setVisible(true);
 
     getLog() << "Screenshot stored..." << Log::endl;
     return 0;

src/deps/imgui/imgui.cpp

  - input number: optional range min/max
  - input number: holding [-]/[+] buttons should increase the step non-linearly
  - input number: use mouse wheel to step up/down
+ - input text: add multi-line text edit
  - layout: clean up the InputFloatN/SliderFloatN/ColorEdit4 horrible layout code. item width should include frame padding, then we can have a generic horizontal layout helper.
  - columns: declare column set (each column: fixed size, %, fill, distribute default size among fills)
  - columns: columns header to act as button (~sort op) and allow resize/reorder
  - style editor: add a button to print C code.
  - optimisation/render: use indexed rendering
  - optimisation/render: move clip-rect to vertex data? would allow merging all commands
- - optimisation/render: merge command-list of all windows into one command-list?
+ - optimisation/render: merge command-lists with same clip-rect into one even if they aren't sequential? (as long as in-between clip rectangle don't overlap)?
  - optimisation/render: font exported by bmfont is not tight fit on vertical axis, incur unneeded pixel-shading cost.
  - optimisation: turn some the various stack vectors into statically-sized arrays
  - optimisation: better clipping for multi-component widgets
     return text_display_end;
 }
 
+// Log ImGui display into text output (tty or file or clipboard)
 static void LogText(const ImVec2& ref_pos, const char* text, const char* text_end)
 {
     ImGuiState& g = GImGui;
         if (line_end >= text_end)
             line_end = NULL;
 
-        bool is_first_line = (text == text_remaining);
+        const bool is_first_line = (text == text_remaining);
         bool is_last_line = false;
         if (line_end == NULL)
         {
     }
 }
 
+// Internal ImGui function to render text (called from ImGui::Text(), ImGui::TextUnformatted(), etc.)
 static void RenderText(ImVec2 pos, const char* text, const char* text_end, const bool hide_text_after_hash)
 {
     ImGuiState& g = GImGui;
     }
 }
 
+// Render a rectangle shaped with optional rounding and borders
 static void RenderFrame(ImVec2 p_min, ImVec2 p_max, ImU32 fill_col, bool border, float rounding)
 {
     ImGuiWindow* window = GetCurrentWindow();
     }
 }
 
+// Render a triangle to denote expanded/collapsed state
 static void RenderCollapseTriangle(ImVec2 p_min, bool open, float scale, bool shadow)
 {
     ImGuiWindow* window = GetCurrentWindow();
     window->DrawList->AddTriangleFilled(a, b, c, window->Color(ImGuiCol_Border));
 }
 
+// Calculate text size. Text can be multi-line. Optionally ignore text after a ## marker.
+// CalcTextSize("") should return ImVec2(0.0f, GImGui.FontSize)
 ImVec2 CalcTextSize(const char* text, const char* text_end, const bool hide_text_after_hash)
 {
     ImGuiWindow* window = GetCurrentWindow();
     return size;
 }
 
+// Find window given position, search front-to-back
 static ImGuiWindow* FindHoveredWindow(ImVec2 pos, bool excluding_childs)
 {
     ImGuiState& g = GImGui;
     return NULL;
 }
 
-// - Box is clipped by our current clip setting
-// - Expand to be generous on unprecise inputs systems (touch)
+// Test if mouse cursor is hovering given aabb
+// NB- Box is clipped by our current clip setting
+// NB- Expand the aabb to be generous on unprecise inputs systems (g.Style.TouchExtraPadding)
 static bool IsMouseHoveringBox(const ImGuiAabb& box)
 {
     ImGuiState& g = GImGui;
     }
 
     // Expand for touch input
-    ImGuiAabb box_for_touch(box_clipped.Min - g.Style.TouchExtraPadding, box_clipped.Max + g.Style.TouchExtraPadding);
+    const ImGuiAabb box_for_touch(box_clipped.Min - g.Style.TouchExtraPadding, box_clipped.Max + g.Style.TouchExtraPadding);
     return box_for_touch.Contains(g.IO.MousePos);
 }
 
     return window->DC.LastItemAabb.Max;
 }
 
+// Tooltip is sorted and turned into a BeginTooltip()/EndTooltip() sequence at the end of the frame. Each call override previous value.
 void SetTooltip(const char* fmt, ...)
 {
     ImGuiState& g = GImGui;
     va_end(args);
 }
 
+// Position new window if they don't have position setting in the .ini file. Rarely useful (used by the sample applications).
 void SetNewWindowDefaultPos(const ImVec2& pos)
 {
     ImGuiState& g = GImGui;
     }
     else
     {
-        // When using filling child window, we don't provide the width/height to ItemSize so that it doesn't feed back into automatic fitting
+        // When using auto-filling child window, we don't provide the width/height to ItemSize so that it doesn't feed back into automatic size-fitting.
         ImVec2 sz = ImGui::GetWindowSize();
         if (window->Flags & ImGuiWindowFlags_ChildWindowAutoFitX)
             sz.x = 0;
     }
 }
 
+// Push a new ImGui window to add widgets to. This can be called multiple times with the same window to append contents
 bool Begin(const char* name, bool* open, ImVec2 size, float fill_alpha, ImGuiWindowFlags flags)
 {
     ImGuiState& g = GImGui;
         // Create window the first time, and load settings
         if (flags & (ImGuiWindowFlags_ChildWindow | ImGuiWindowFlags_Tooltip))
         {
+			// Tooltip and child windows don't store settings
             window = (ImGuiWindow*)IM_MALLOC(sizeof(ImGuiWindow));
             new(window) ImGuiWindow(name, ImVec2(0,0), size);
         }
         else
             ImGui::PushClipRect(ImVec4(0.0f, 0.0f, g.IO.DisplaySize.x, g.IO.DisplaySize.y));
 
-        // ID stack
+        // Seed ID stack with our window pointer
         window->IDStack.resize(0);
         ImGui::PushID(window);
 
-        // Move window (at the beginning of the frame)
+        // Move window (at the beginning of the frame to avoid lag)
         const ImGuiID move_id = window->GetID("#MOVE");
         RegisterAliveId(move_id);
         if (g.ActiveId == move_id)
             const ImVec2 pad = ImVec2(window->FontSize()*2.0f, window->FontSize()*2.0f);
             window->PosFloat = ImMax(window->PosFloat + window->Size, pad) - window->Size;
             window->PosFloat = ImMin(window->PosFloat, ImVec2(g.IO.DisplaySize.x, g.IO.DisplaySize.y) - pad);
-            window->Pos = ImVec2((float)(int)window->PosFloat.x, (float)(int)window->PosFloat.y);
             window->SizeFull = ImMax(window->SizeFull, pad);
         }
-        else
-        {
-            window->Pos = ImVec2((float)(int)window->PosFloat.x, (float)(int)window->PosFloat.y);
-        }
+        window->Pos = ImVec2((float)(int)window->PosFloat.x, (float)(int)window->PosFloat.y);
 
         // Default item width
         if (window->Size.x > 0.0f && !(window->Flags & ImGuiWindowFlags_Tooltip))
         else
             window->ItemWidthDefault = 200.0f;
 
-        // Prepare for focus requests
+        // Prepare for keyboard focus requests
         if (window->FocusIdxRequestNext == IM_INT_MAX || window->FocusIdxCounter == -1)
         {
             window->FocusIdxRequestCurrent = IM_INT_MAX;
             window->ScrollY = ImMin(window->ScrollY, ImMax(0.0f, (float)window->SizeContentsFit.y - window->SizeFull.y));
         window->NextScrollY = window->ScrollY;
 
-        // NB- at this point we don't have a clipping rectangle setup yet!
+        // At this point we don't have a clipping rectangle setup yet, so we can test and draw in title bar
         // Collapse window by double-clicking on title bar
         if (!(window->Flags & ImGuiWindowFlags_NoTitleBar))
         {
 
         if (window->Collapsed)
         {
-            // Title bar only
+            // Draw title bar only
             window->Size = title_bar_aabb.GetSize();
             window->DrawList->AddRectFilled(title_bar_aabb.GetTL(), title_bar_aabb.GetBR(), window->Color(ImGuiCol_TitleBgCollapsed), g.Style.WindowRounding);
             if (window->Flags & ImGuiWindowFlags_ShowBorders)
         {
             window->Size = window->SizeFull;
 
-            // Draw resize grip and resize
             ImU32 resize_col = 0;
             if ((window->Flags & ImGuiWindowFlags_Tooltip) != 0)
             {
+                // Tooltip always resize
                 if (window->AutoFitFrames > 0)
                 {
-                    // Tooltip always resize
                     window->SizeFull = window->SizeContentsFit + g.Style.WindowPadding - ImVec2(0.0f, g.Style.ItemSpacing.y);
                 }
             }
             else if (!(window->Flags & ImGuiWindowFlags_NoResize))
             {
+				// Draw resize grip
                 const ImGuiAabb resize_aabb(window->Aabb().GetBR()-ImVec2(18,18), window->Aabb().GetBR());
                 const ImGuiID resize_id = window->GetID("#RESIZE");
                 bool hovered, held;
             if (!(window->Flags & ImGuiWindowFlags_NoTitleBar))
                 window->DrawList->AddRectFilled(title_bar_aabb.GetTL(), title_bar_aabb.GetBR(), window->Color(ImGuiCol_TitleBg), g.Style.WindowRounding, 1|2);
 
+			// Borders
             if (window->Flags & ImGuiWindowFlags_ShowBorders)
             {
                 const float rounding = (window->Flags & ImGuiWindowFlags_ComboBox) ? 0.0f : g.Style.WindowRounding;
                 const float grab_size_y_norm = ImSaturate(window->Size.y / ImMax(window->SizeContentsFit.y, window->Size.y));
                 const float grab_size_y = scrollbar_bb.GetHeight() * grab_size_y_norm;
 
-                // Handle input right away (none of the code above is relying on scrolling)
+                // Handle input right away (none of the code above is relying on scrolling position)
                 bool held = false;
                 bool hovered = false;
                 if (grab_size_y_norm < 1.0f)
         clip_rect.z -= g.Style.ScrollBarWidth;
     ImGui::PushClipRect(clip_rect);
 
+    // Clear 'accessed' flag last thing
     if (first_begin_of_the_frame)
-    {
-        // Clear 'accessed' flag last thing
         window->Accessed = false;
-    }
 
     // Child window can be out of sight and have "negative" clip windows.
     // Mark them as collapsed so commands are skipped earlier (we can't manually collapse because they have no title bar).
     ImGui::PopClipRect();   // inner window clip rectangle
     ImGui::PopClipRect();   // outer window clip rectangle
 
-    // Select window for move/focus when we're done with all our widgets
-    ImGuiAabb bb(window->Pos, window->Pos+window->Size);
+    // Select window for move/focus when we're done with all our widgets (we only consider non-childs windows here)
+    const ImGuiAabb bb(window->Pos, window->Pos+window->Size);
     if (g.ActiveId == 0 && g.HoveredId == 0 && g.HoveredWindowExcludingChilds == window && IsMouseHoveringBox(bb) && g.IO.MouseClicked[0])
         g.ActiveId = window->GetID("#MOVE");
 
     // Stop logging
-    if (!(window->Flags & ImGuiWindowFlags_ChildWindow))    // FIXME: more options for scope of logging
+    if (!(window->Flags & ImGuiWindowFlags_ChildWindow))    // FIXME: add more options for scope of logging
     {
         g.LogEnabled = false;
         if (g.LogFile != NULL)
     g.CurrentWindow = g.CurrentWindowStack.empty() ? NULL : g.CurrentWindowStack.back();
 }
 
+// Moving window to front
 static void FocusWindow(ImGuiWindow* window)
 {
     ImGuiState& g = GImGui;
     g.FocusedWindow = window;
 
-    // Move to front
     for (size_t i = 0; i < g.Windows.size(); i++)
         if (g.Windows[i] == window)
         {
 
 const char* GetStyleColorName(ImGuiCol idx)
 {
-    // Create with regexp: ImGuiCol_{.*}, --> case ImGuiCol_\1: return "\1";
+    // Create switch-case from enum with regexp: ImGuiCol_{.*}, --> case ImGuiCol_\1: return "\1";
     switch (idx)
     {
     case ImGuiCol_Text: return "Text";
     window->PosFloat = pos;
     window->Pos = ImVec2((float)(int)window->PosFloat.x, (float)(int)window->PosFloat.y);
 
-    // If we happen to move the window while it is showing (which is a bad idea) let's at least offset the cursor
+    // If we happen to move the window while it is being appended to (which is a bad idea - will smear) let's at least offset the cursor
     window->DC.CursorPos += (window->Pos - old_pos);
 }
 
         {
             ImVec2 pos = start_pos;
 
-            // lines to skip (can't skip when logging text)
+            // Lines to skip (can't skip when logging text)
             if (!g.LogEnabled)
             {
                 int lines_skippable = (int)((clip_rect.y - start_pos.y) / line_height) - 1;
                 }
             }
 
-            // lines to render?
+            // Lines to render
             if (line < text_end)
             {
                 ImGuiAabb line_box(pos, pos + ImVec2(ImGui::GetWindowWidth(), line_height));
                     pos.y += line_height;
                 }
 
-                // count remaining lines
+                // Count remaining lines
                 int lines_skipped = 0;
                 while (line < text_end)
                 {
             return;
 
         // Render
-        // We don't hide text after # in this end-user function.
+        // We don't hide text after ## in this end-user function.
         RenderText(bb.Min, text_begin, text_end, false);
     }
 }
     ImGui::SameLine(0, 0);
 }
 
+// Add a label+text combo aligned to other label+value widgets
 void LabelText(const char* label, const char* fmt, ...)
 {
     ImGuiState& g = GImGui;
     return pressed;
 }
 
-// Fits within text without additional spacing.
+// Small buttons fits within text without additional spacing.
 bool SmallButton(const char* label)
 {
     ImGuiState& g = GImGui;
     return pressed;
 }
 
+// Upper-right button to close a window.
 static bool CloseWindowButton(bool* open)
 {
     ImGuiWindow* window = GetCurrentWindow();
     return pressed;
 }
 
+// Start logging ImGui output to TTY
 void LogToTTY(int max_depth)
 {
     ImGuiState& g = GImGui;
         g.LogAutoExpandMaxDepth = max_depth;
 }
 
+// Start logging ImGui output to given file
 void LogToFile(int max_depth, const char* filename)
 {
     ImGuiState& g = GImGui;
         g.LogAutoExpandMaxDepth = max_depth;
 }
 
+// Start logging ImGui output to clipboard
 void LogToClipboard(int max_depth)
 {
     ImGuiState& g = GImGui;
         g.LogAutoExpandMaxDepth = max_depth;
 }
 
+// Helper to display logging buttons
 void LogButtons()
 {
     ImGuiState& g = GImGui;
         label = str_id;
     const ImGuiID id = window->GetID(str_id);
 
+	// We only write to the tree storage if the user clicks
     ImGuiStorage* tree = window->DC.StateStorage;
     bool opened;
     if (window->DC.OpenNextNode != -1)
         opened = tree->GetInt(id, default_open) != 0;
     }
 
+	// Framed header expand a little outside the default padding
     const ImVec2 window_padding = window->WindowPadding();
     const ImVec2 text_size = CalcTextSize(label);
     const ImVec2 pos_min = window->DC.CursorPos;
     const ImGuiAabb text_bb(bb.Min, bb.Min + ImVec2(window->FontSize() + style.FramePadding.x*2*2,0) + text_size);
     ItemSize(ImVec2(text_bb.GetSize().x, bb.GetSize().y));  // NB: we don't provide our width so that it doesn't get feed back into AutoFit
 
-    // Logging auto expand tree nodes (but not collapsing headers.. seems like sensible behaviour)
-    // NB- If we are above max depth we still allow manually opened nodes to be logged
+    // When logging is enabled, if automatically expand tree nodes (but *NOT* collapsing headers.. seems like sensible behaviour).
+    // NB- If we are above max depth we still allow manually opened nodes to be logged.
     if (!display_frame) 
         if (g.LogEnabled && window->DC.TreeDepth < g.LogAutoExpandMaxDepth)
             opened = true;
     const ImU32 col = window->Color((held && hovered) ? ImGuiCol_HeaderActive : hovered ? ImGuiCol_HeaderHovered : ImGuiCol_Header);
     if (display_frame)
     {
+		// Framed type
         RenderFrame(bb.Min, bb.Max, col, true);
         RenderCollapseTriangle(bb.Min + style.FramePadding, opened, 1.0f, true);
         RenderText(bb.Min + style.FramePadding + ImVec2(window->FontSize() + style.FramePadding.x*2,0), label);
     }
     else
     {
+		// Unframed typed for tree nodes
         if ((held && hovered) || hovered)
             RenderFrame(bb.Min, bb.Max, col, false);
         RenderCollapseTriangle(bb.Min + ImVec2(style.FramePadding.x, window->FontSize()*0.15f), opened, 0.70f, false);
     return opened;
 }
 
+// Text with a little bullet aligned to the typical tree node.
 void BulletText(const char* fmt, ...)
 {
     ImGuiState& g = GImGui;
     RenderText(bb.Min+ImVec2(window->FontSize()+g.Style.FramePadding.x*2,0), text_begin, text_end);
 }
 
+// If returning 'true' the node is open and the user is responsible for calling TreePop
 bool TreeNode(const char* str_id, const char* fmt, ...)
 {
     static char buf[1024];
     return opened;
 }
 
+// If returning 'true' the node is open and the user is responsible for calling TreePop
 bool TreeNode(const void* ptr_id, const char* fmt, ...)
 {
     static char buf[1024];
     window->IDStack.pop_back();
 }
 
+// User can input math operators (e.g. +100) to edit a numerical values.
 // NB: only call right after InputText because we are using its InitialValue storage
 static void ApplyNumericalTextInput(const char* buf, float *v)
 {
         *v = op_v;
 }
 
-// use power!=1.0 for logarithmic sliders
+// Use power!=1.0 for logarithmic sliders.
+// Adjust display_format to decorate the value with a prefix or a suffix.
 bool SliderFloat(const char* label, float* v, float v_min, float v_max, const char* display_format, float power)
 {
     ImGuiState& g = GImGui;
 
     if (IsClipped(slider_bb))
     {
-        // NB- we don't use ClipAdvance() because we don't want to submit ItemSize() because we may change into a text edit later which may submit an ItemSize itself
+        // NB- we don't use ClipAdvance() in the if() statement because we don't want to submit ItemSize() because we may change into a text edit later which may submit an ItemSize itself
         ItemSize(bb);
         return false;
     }
 
     const bool is_unbound = v_min == -FLT_MAX || v_min == FLT_MAX || v_max == -FLT_MAX || v_max == FLT_MAX;
 
-    const float grab_size_in_units = 1.0f;                                                          // In 'v' units. Probably needs to be parametrized, based on a 'v_step' value? decimal precision?
+    const float grab_size_in_units = 1.0f;                                                              // In 'v' units. Probably needs to be parametrized, based on a 'v_step' value? decimal precision?
     float grab_size_in_pixels;
     if (decimal_precision > 0 || is_unbound)
         grab_size_in_pixels = 10.0f;
     const float slider_effective_x1 = slider_bb.Min.x + grab_size_in_pixels*0.5f;
     const float slider_effective_x2 = slider_bb.Max.x - grab_size_in_pixels*0.5f;
 
-    // For logarithmic sliders that cross over sign boundary we want the exponential increase to be symetric around 0.0
+    // For logarithmic sliders that cross over sign boundary we want the exponential increase to be symetric around 0.0f
     float linear_zero_pos = 0.0f;   // 0.0->1.0f
     if (!is_unbound)
     {
         }
     }
 
-    // Tabbing thru or CTRL-clicking through slider turns into an input box
+    // Tabbing or CTRL-clicking through slider turns into an input box
     bool value_changed = false;
     if (start_text_input || (g.ActiveId == id && id == g.SliderAsInputTextId))
     {
 
         g.ActiveId = g.SliderAsInputTextId;
         g.HoveredId = 0;
-        window->FocusItemUnregister();  // Our replacement slider will override the focus ID (that we needed to declare previously to allow for a TAB focus to happen before we got selected)
+        window->FocusItemUnregister();      // Our replacement slider will override the focus ID (that we needed to declare previously to allow for a TAB focus to happen before we got selected)
         value_changed = ImGui::InputText(label, text_buf, IM_ARRAYSIZE(text_buf), ImGuiInputTextFlags_CharsDecimal | ImGuiInputTextFlags_AutoSelectAll | ImGuiInputTextFlags_AlignCenter);
         if (g.SliderAsInputTextId == 0)
         {
             // First frame
-            IM_ASSERT(g.ActiveId == id);    // InputText ID should match the Slider ID (else we'd need to store them both)
+            IM_ASSERT(g.ActiveId == id);    // InputText ID should match the Slider ID (else we'd need to store them both which is also possible)
             g.SliderAsInputTextId = g.ActiveId;
             g.ActiveId = id;
             g.HoveredId = id;
         float v_clamped = ImClamp(*v, v_min, v_max);
         if (v_clamped < 0.0f)
         {
-            float f = 1.0f - (v_clamped - v_min) / (ImMin(0.0f,v_max) - v_min);
+            const float f = 1.0f - (v_clamped - v_min) / (ImMin(0.0f,v_max) - v_min);
             grab_t = (1.0f - powf(f, 1.0f/power)) * linear_zero_pos;
         }
         else
         {
-            float f = (v_clamped - ImMax(0.0f,v_min)) / (v_max - ImMax(0.0f,v_min));
+            const float f = (v_clamped - ImMax(0.0f,v_min)) / (v_max - ImMax(0.0f,v_min));
             grab_t = linear_zero_pos + powf(f, 1.0f/power) * (1.0f - linear_zero_pos);
         }
 
         window->DrawList->AddRectFilled(grab_bb.Min, grab_bb.Max, window->Color(g.ActiveId == id ? ImGuiCol_SliderGrabActive : ImGuiCol_SliderGrab));
     }
 
+	// Draw value using user-provided display format so user can add prefix/suffix/decorations to the value.
     char value_buf[64];
     ImFormatString(value_buf, IM_ARRAYSIZE(value_buf), display_format, *v);
     RenderText(ImVec2(slider_bb.GetCenter().x-CalcTextSize(value_buf).x*0.5f, frame_bb.Min.y + style.FramePadding.y), value_buf);
         const float v1 = PlotGetValue(values, stride, (v_idx + values_offset + 1) % values_count);
         const ImVec2 p1 = ImVec2( t1, 1.0f - ImSaturate((v1 - scale_min) / (scale_max - scale_min)) );
 
-        // NB: draw calls are merged into ones
+        // NB- Draw calls are merged together by the DrawList system.
         if (plot_type == ImGuiPlotType_Lines)
             window->DrawList->AddLine(ImLerp(graph_bb.Min, graph_bb.Max, p0), ImLerp(graph_bb.Min, graph_bb.Max, p1), v_hovered == v_idx ? col_hovered : col_base);
         else if (plot_type == ImGuiPlotType_Histogram)
         p0 = p1;
     }
 
-    // Overlay last value
+    // Text overlay
     if (overlay_text)
         RenderText(ImVec2(graph_bb.GetCenter().x-CalcTextSize(overlay_text).x*0.5f, frame_bb.Min.y + style.FramePadding.y), overlay_text);
 
         window->DrawList->AddCircle(center, radius, window->Color(ImGuiCol_Border), 16);
     }
 
+    if (g.LogEnabled)
+        LogText(text_bb.GetTL(), active ? "(x)" : "( )");
     RenderText(text_bb.GetTL(), label);
 
     return pressed;
         value_changed = true;
     }
 
+	// Step buttons
     if (step > 0.0f)
     {
         ImGui::PopItemWidth();
     return value_changed;
 }
 
-bool InputText(const char* label, char* buf, size_t buf_size, ImGuiInputTextFlags flags)
+bool InputText(const char* label, char* buf, size_t buf_size, ImGuiInputTextFlags flags, bool *enter)
 {
+    if (enter != NULL)
+        *enter = false;
+
     ImGuiState& g = GImGui;
     ImGuiWindow* window = GetCurrentWindow();
     if (window->SkipItems)
     if (ClipAdvance(frame_bb))
         return false;
 
-    // NB: we can only read/write if we are the active widget!
+    // NB: we can only read/write to 'edit_state' if we are the active widget!
     ImGuiTextEditState& edit_state = g.InputTextState;
 
     const bool is_ctrl_down = io.KeyCtrl;
     bool cancel_edit = false;
     if (g.ActiveId == id)
     {
+		// Edit in progress
         edit_state.BufSize = buf_size < IM_ARRAYSIZE(edit_state.Text) ? buf_size : IM_ARRAYSIZE(edit_state.Text);
         edit_state.Font = window->Font();
         edit_state.FontSize = window->FontSize();
         else if (IsKeyPressedMap(ImGuiKey_End))                 edit_state.OnKeyboardPressed(is_ctrl_down ? STB_TEXTEDIT_K_TEXTEND | k_mask : STB_TEXTEDIT_K_LINEEND | k_mask);
         else if (IsKeyPressedMap(ImGuiKey_Delete))              edit_state.OnKeyboardPressed(STB_TEXTEDIT_K_DELETE | k_mask);
         else if (IsKeyPressedMap(ImGuiKey_Backspace))           edit_state.OnKeyboardPressed(STB_TEXTEDIT_K_BACKSPACE | k_mask);
-        else if (IsKeyPressedMap(ImGuiKey_Enter))               { g.ActiveId = 0; }
+        else if (IsKeyPressedMap(ImGuiKey_Enter))               { g.ActiveId = 0; if (enter != NULL) *enter = true; }
         else if (IsKeyPressedMap(ImGuiKey_Escape))              { g.ActiveId = 0; cancel_edit = true; }
         else if (is_ctrl_down && IsKeyPressedMap(ImGuiKey_Z))   edit_state.OnKeyboardPressed(STB_TEXTEDIT_K_UNDO);      // I don't want to use shortcuts but we should probably have an Input-catch stack
         else if (is_ctrl_down && IsKeyPressedMap(ImGuiKey_Y))   edit_state.OnKeyboardPressed(STB_TEXTEDIT_K_REDO);
     return true;
 }
 
+// Combo box helper allowing to pass an array of strings.
 bool Combo(const char* label, int* current_item, const char** items, int items_count, int popup_height_items)
 {
     const bool value_changed = Combo(label, current_item, Combo_ArrayGetter, (void*)items, items_count, popup_height_items);
     return true;
 }
 
+// Combo box helper allowing to pass all items in a single string.
 bool Combo(const char* label, int* current_item, const char* items_separated_by_zeros, int popup_height_items)
 {
     int items_count = 0;
     return value_changed;
 }
 
+// Combo box function.
 bool Combo(const char* label, int* current_item, bool (*items_getter)(void*, int, const char**), void* data, int items_count, int popup_height_items)
 {
     ImGuiState& g = GImGui;
         const ImGuiAabb popup_aabb(ImVec2(frame_bb.Min.x+popup_off_x, frame_bb.Max.y), ImVec2(frame_bb.Max.x+popup_off_x, frame_bb.Max.y + popup_height));
         ImGui::SetCursorPos(popup_aabb.Min - window->Pos);
 
-        ImGuiWindowFlags flags = ImGuiWindowFlags_ComboBox | ((window->Flags & ImGuiWindowFlags_ShowBorders) ? ImGuiWindowFlags_ShowBorders : 0);
+        const ImGuiWindowFlags flags = ImGuiWindowFlags_ComboBox | ((window->Flags & ImGuiWindowFlags_ShowBorders) ? ImGuiWindowFlags_ShowBorders : 0);
         ImGui::BeginChild("#ComboBox", popup_aabb.GetSize(), false, flags);
         ImGuiWindow* child_window = GetCurrentWindow();
         ImGui::Spacing();
     col4[1] = col[1];
     col4[2] = col[2];
     col4[3] = 1.0f;
-    bool value_changed = ImGui::ColorEdit4(label, col4, false);
+    const bool value_changed = ImGui::ColorEdit4(label, col4, false);
     col[0] = col4[0];
     col[1] = col4[1];
     col[2] = col4[2];
     window->DC.ColorEditMode = mode;
 }
 
+// Horizontal separator.
 void Separator()
 {
     ImGuiWindow* window = GetCurrentWindow();
         ImGui::PushColumnClipRect();
 }
 
+// A little vertical spacing.
 void Spacing()
 {
     ImGuiWindow* window = GetCurrentWindow();
             bool hovered, held;
             ButtonBehaviour(column_aabb, column_id, &hovered, &held, true);
 
-            // Draw before resize so our items positioning are in sync with the line
+            // Draw before resize so our items positioning are in sync with the line being drawn
             const ImU32 col = window->Color(held ? ImGuiCol_ColumnActive : hovered ? ImGuiCol_ColumnHovered : ImGuiCol_Column);
             const float xi = (float)(int)x;
             window->DrawList->AddLine(ImVec2(xi, y1), ImVec2(xi, y2), col);

src/deps/imgui/imgui.h

     void        BeginChild(const char* str_id, ImVec2 size = ImVec2(0,0), bool border = false, ImGuiWindowFlags extra_flags = 0);
     void        EndChild();
     bool        GetWindowIsFocused();
-    float       GetWindowWidth();
-    ImVec2      GetWindowPos();                                                     // you should rarely need/care about the window position, but it can be useful if you want to use your own drawing
-    void        SetWindowPos(const ImVec2& pos);                                    // set current window pos
     ImVec2      GetWindowSize();
+    float       GetWindowWidth();
+    ImVec2      GetWindowPos();                                                     // you should rarely need/care about the window position, but it can be useful if you want to use your own drawing.
+    void        SetWindowPos(const ImVec2& pos);                                    // set current window pos.
     ImVec2      GetWindowContentRegionMin();
     ImVec2      GetWindowContentRegionMax();
-    ImDrawList* GetWindowDrawList();
+    ImDrawList* GetWindowDrawList();                                                // get rendering command-list if you want to append your own draw primitives.
     void        SetFontScale(float scale);
-    void        SetScrollPosHere();
-    void        SetTreeStateStorage(ImGuiStorage* tree);
+    void        SetScrollPosHere();                                                 // adjust scrolling position to center into the current cursor position.
+    void        SetTreeStateStorage(ImGuiStorage* tree);                            // replace tree state storage with our own (if you want to manipulate it yourself, typically clear subsection of it).
     ImGuiStorage* GetTreeStateStorage();
     void        PushItemWidth(float item_width);
     void        PopItemWidth();
 
     // Tooltip
     void        SetTooltip(const char* fmt, ...);                                   // set tooltip under mouse-cursor, typically use with ImGui::IsHovered(). last call wins.
-    void        BeginTooltip();                                                     // use to create full-featured tooltip windows that aren't just text. 
+    void        BeginTooltip();                                                     // use to create full-featured tooltip windows that aren't just text.
     void        EndTooltip();
 
     // Layout
     void        SetCursorPosX(float x);                                             // "
     void        SetCursorPosY(float y);                                             // "
     ImVec2      GetCursorScreenPos();												// cursor position in screen space
-    void        AlignFirstTextHeightToWidgets();                                    // call once if the first item on the line is a Text() item and you want to vertically lower it to match higher widgets.
+    void        AlignFirstTextHeightToWidgets();                                    // call once if the first item on the line is a Text() item and you want to vertically lower it to match subsequent (bigger) widgets.
     float       GetTextLineSpacing();
     float       GetTextLineHeight();
 
     bool        Button(const char* label, ImVec2 size = ImVec2(0,0), bool repeat_when_held = false);
     bool        SmallButton(const char* label);
     bool        CollapsingHeader(const char* label, const char* str_id = NULL, const bool display_frame = true, const bool default_open = false);
-    bool        SliderFloat(const char* label, float* v, float v_min, float v_max, const char* display_format = "%.3f", float power = 1.0f);
+    bool        SliderFloat(const char* label, float* v, float v_min, float v_max, const char* display_format = "%.3f", float power = 1.0f);     // adjust display_format to decorate the value with a prefix or a suffix. Use power!=1.0 for logarithmic sliders.
     bool        SliderFloat2(const char* label, float v[2], float v_min, float v_max, const char* display_format = "%.3f", float power = 1.0f);
     bool        SliderFloat3(const char* label, float v[3], float v_min, float v_max, const char* display_format = "%.3f", float power = 1.0f);
     bool        SliderFloat4(const char* label, float v[3], float v_min, float v_max, const char* display_format = "%.3f", float power = 1.0f);
     bool        InputFloat3(const char* label, float v[3], int decimal_precision = -1);
     bool        InputFloat4(const char* label, float v[4], int decimal_precision = -1);
     bool        InputInt(const char* label, int* v, int step = 1, int step_fast = 100);
-    bool        InputText(const char* label, char* buf, size_t buf_size, ImGuiInputTextFlags flags = 0);
+    bool        InputText(const char* label, char* buf, size_t buf_size, ImGuiInputTextFlags flags = 0, bool* enter = NULL);
     bool        Combo(const char* label, int* current_item, const char** items, int items_count, int popup_height_items = 7);
     bool        Combo(const char* label, int* current_item, const char* items_separated_by_zeros, int popup_height_items = 7);      // Separate items with \0, end item-list with \0\0
     bool        Combo(const char* label, int* current_item, bool (*items_getter)(void* data, int idx, const char** out_text), void* data, int items_count, int popup_height_items = 7);
     bool        ColorEdit3(const char* label, float col[3]);
     bool        ColorEdit4(const char* label, float col[4], bool show_alpha = true);
     void        ColorEditMode(ImGuiColorEditMode mode);
-    bool        TreeNode(const char* str_label_id);                                 // if returning 'true' the user is responsible for calling TreePop
+    bool        TreeNode(const char* str_label_id);                                 // if returning 'true' the node is open and the user is responsible for calling TreePop
     bool        TreeNode(const char* str_id, const char* fmt, ...);                 // "
     bool        TreeNode(const void* ptr_id, const char* fmt, ...);                 // "
-    void        TreePush(const char* str_id = NULL);                                // already called by TreeNode(), but you can call Push/Pop yourself for layout purpose
+    void        TreePush(const char* str_id = NULL);                                // already called by TreeNode(), but you can call Push/Pop yourself for layouting purpose
     void        TreePush(const void* ptr_id = NULL);                                // "
     void        TreePop();
     void        OpenNextNode(bool open);                                            // force open/close the next TreeNode or CollapsingHeader
 enum ImGuiInputTextFlags_
 {
     // Default: 0
-    ImGuiInputTextFlags_CharsDecimal        = 1 << 0,
-    ImGuiInputTextFlags_CharsHexadecimal    = 1 << 1,
+    ImGuiInputTextFlags_CharsDecimal        = 1 << 0,   // Allow 0123456789.+-*/
+    ImGuiInputTextFlags_CharsHexadecimal    = 1 << 1,   // Allow 0123456789ABCDEFabcdef
     ImGuiInputTextFlags_AutoSelectAll       = 1 << 2,
     ImGuiInputTextFlags_AlignCenter         = 1 << 3,
 };

src/deps/utf8-cpp/utf8.h

-// Copyright 2006 Nemanja Trifunovic
-
-/*
-Permission is hereby granted, free of charge, to any person or organization
-obtaining a copy of the software and accompanying documentation covered by
-this license (the "Software") to use, reproduce, display, distribute,
-execute, and transmit the Software, and to prepare derivative works of the
-Software, and to permit third-parties to whom the Software is furnished to
-do so, all subject to the following:
-
-The copyright notices in the Software and this entire statement, including
-the above license grant, this restriction and the following disclaimer,
-must be included in all copies of the Software, in whole or in part, and
-all derivative works of the Software, unless such copies or derivative
-works are solely in the form of machine-executable object code generated by
-a source language processor.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
-SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
-FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
-ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
-*/
-
-
-#ifndef UTF8_FOR_CPP_2675DCD0_9480_4c0c_B92A_CC14C027B731
-#define UTF8_FOR_CPP_2675DCD0_9480_4c0c_B92A_CC14C027B731
-
-#include "utf8/checked.h"
-#include "utf8/unchecked.h"
-
-#endif // header guard

src/deps/utf8-cpp/utf8/checked.h

-// Copyright 2006 Nemanja Trifunovic
-
-/*
-Permission is hereby granted, free of charge, to any person or organization
-obtaining a copy of the software and accompanying documentation covered by
-this license (the "Software") to use, reproduce, display, distribute,
-execute, and transmit the Software, and to prepare derivative works of the
-Software, and to permit third-parties to whom the Software is furnished to
-do so, all subject to the following:
-
-The copyright notices in the Software and this entire statement, including
-the above license grant, this restriction and the following disclaimer,
-must be included in all copies of the Software, in whole or in part, and
-all derivative works of the Software, unless such copies or derivative
-works are solely in the form of machine-executable object code generated by
-a source language processor.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
-SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
-FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
-ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
-*/
-
-
-#ifndef UTF8_FOR_CPP_CHECKED_H_2675DCD0_9480_4c0c_B92A_CC14C027B731
-#define UTF8_FOR_CPP_CHECKED_H_2675DCD0_9480_4c0c_B92A_CC14C027B731
-
-#include "core.h"
-#include <stdexcept>
-
-namespace utf8
-{
-    // Exceptions that may be thrown from the library functions.
-    class invalid_code_point : public ::std::exception {
-        uint32_t cp;
-    public:
-        invalid_code_point(uint32_t _cp) : cp(_cp) {}
-        virtual const char* what() const noexcept { return "Invalid code point"; }
-        uint32_t code_point() const {return cp;}
-    };
-
-    class invalid_utf8 : public ::std::exception {
-        uint8_t u8;
-    public:
-        invalid_utf8 (uint8_t u) : u8(u) {}
-        virtual const char* what() const noexcept { return "Invalid UTF-8"; }
-        uint8_t utf8_octet() const {return u8;}
-    };
-
-    class invalid_utf16 : public ::std::exception {
-        uint16_t u16;
-    public:
-        invalid_utf16 (uint16_t u) : u16(u) {}
-        virtual const char* what() const noexcept { return "Invalid UTF-16"; }
-        uint16_t utf16_word() const {return u16;}
-    };
-
-    class not_enough_room : public ::std::exception {
-    public:
-        virtual const char* what() const noexcept { return "Not enough space"; }
-    };
-
-    /// The library API - functions intended to be called by the users
-
-    template <typename octet_iterator>
-    octet_iterator append(uint32_t cp, octet_iterator result)
-    {
-        if (!utf8::internal::is_code_point_valid(cp))
-            throw invalid_code_point(cp);
-
-        if (cp < 0x80)                        // one octet
-            *(result++) = static_cast<uint8_t>(cp);
-        else if (cp < 0x800) {                // two octets
-            *(result++) = static_cast<uint8_t>((cp >> 6)            | 0xc0);
-            *(result++) = static_cast<uint8_t>((cp & 0x3f)          | 0x80);
-        }
-        else if (cp < 0x10000) {              // three octets
-            *(result++) = static_cast<uint8_t>((cp >> 12)           | 0xe0);
-            *(result++) = static_cast<uint8_t>(((cp >> 6) & 0x3f)   | 0x80);
-            *(result++) = static_cast<uint8_t>((cp & 0x3f)          | 0x80);
-        }
-        else {                                // four octets
-            *(result++) = static_cast<uint8_t>((cp >> 18)           | 0xf0);
-            *(result++) = static_cast<uint8_t>(((cp >> 12) & 0x3f)  | 0x80);
-            *(result++) = static_cast<uint8_t>(((cp >> 6) & 0x3f)   | 0x80);
-            *(result++) = static_cast<uint8_t>((cp & 0x3f)          | 0x80);
-        }
-        return result;
-    }
-
-    template <typename octet_iterator, typename output_iterator>
-    output_iterator replace_invalid(octet_iterator start, octet_iterator end, output_iterator out, uint32_t replacement)
-    {
-        while (start != end) {
-            octet_iterator sequence_start = start;
-            internal::utf_error err_code = utf8::internal::validate_next(start, end);
-            switch (err_code) {
-                case internal::UTF8_OK :
-                    for (octet_iterator it = sequence_start; it != start; ++it)
-                        *out++ = *it;
-                    break;
-                case internal::NOT_ENOUGH_ROOM:
-                    throw not_enough_room();
-                case internal::INVALID_LEAD:
-                    out = utf8::append (replacement, out);
-                    ++start;
-                    break;
-                case internal::INCOMPLETE_SEQUENCE:
-                case internal::OVERLONG_SEQUENCE:
-                case internal::INVALID_CODE_POINT:
-                    out = utf8::append (replacement, out);
-                    ++start;
-                    // just one replacement mark for the sequence
-                    while (start != end && utf8::internal::is_trail(*start))
-                        ++start;
-                    break;
-            }
-        }
-        return out;
-    }
-
-    template <typename octet_iterator, typename output_iterator>
-    inline output_iterator replace_invalid(octet_iterator start, octet_iterator end, output_iterator out)
-    {
-        static const uint32_t replacement_marker = utf8::internal::mask16(0xfffd);
-        return utf8::replace_invalid(start, end, out, replacement_marker);
-    }
-
-    template <typename octet_iterator>
-    uint32_t next(octet_iterator& it, octet_iterator end)
-    {
-        uint32_t cp = 0;
-        internal::utf_error err_code = utf8::internal::validate_next(it, end, cp);
-        switch (err_code) {
-            case internal::UTF8_OK :
-                break;
-            case internal::NOT_ENOUGH_ROOM :
-                throw not_enough_room();
-            case internal::INVALID_LEAD :
-            case internal::INCOMPLETE_SEQUENCE :
-            case internal::OVERLONG_SEQUENCE :
-                throw invalid_utf8(*it);
-            case internal::INVALID_CODE_POINT :
-                throw invalid_code_point(cp);
-        }
-        return cp;
-    }
-
-    template <typename octet_iterator>
-    uint32_t peek_next(octet_iterator it, octet_iterator end)
-    {
-        return utf8::next(it, end);
-    }
-
-    template <typename octet_iterator>
-    uint32_t prior(octet_iterator& it, octet_iterator start)
-    {
-        // can't do much if it == start
-        if (it == start)
-            throw not_enough_room();
-
-        octet_iterator end = it;
-        // Go back until we hit either a lead octet or start
-        while (utf8::internal::is_trail(*(--it)))
-            if (it == start)
-                throw invalid_utf8(*it); // error - no lead byte in the sequence
-        return utf8::peek_next(it, end);
-    }
-
-    /// Deprecated in versions that include "prior"
-    template <typename octet_iterator>
-    uint32_t previous(octet_iterator& it, octet_iterator pass_start)
-    {
-        octet_iterator end = it;
-        while (utf8::internal::is_trail(*(--it)))
-            if (it == pass_start)
-                throw invalid_utf8(*it); // error - no lead byte in the sequence
-        octet_iterator temp = it;
-        return utf8::next(temp, end);
-    }
-
-    template <typename octet_iterator, typename distance_type>
-    void advance (octet_iterator& it, distance_type n, octet_iterator end)
-    {
-        for (distance_type i = 0; i < n; ++i)
-            utf8::next(it, end);
-    }
-
-    template <typename octet_iterator>
-    typename std::iterator_traits<octet_iterator>::difference_type
-    distance (octet_iterator first, octet_iterator last)
-    {
-        typename std::iterator_traits<octet_iterator>::difference_type dist;
-        for (dist = 0; first < last; ++dist)
-            utf8::next(first, last);
-        return dist;
-    }
-
-    template <typename u16bit_iterator, typename octet_iterator>
-    octet_iterator utf16to8 (u16bit_iterator start, u16bit_iterator end, octet_iterator result)
-    {
-        while (start != end) {
-            uint32_t cp = utf8::internal::mask16(*start++);
-            // Take care of surrogate pairs first
-            if (utf8::internal::is_lead_surrogate(cp)) {
-                if (start != end) {
-                    uint32_t trail_surrogate = utf8::internal::mask16(*start++);
-                    if (utf8::internal::is_trail_surrogate(trail_surrogate))
-                        cp = (cp << 10) + trail_surrogate + internal::SURROGATE_OFFSET;
-                    else
-                        throw invalid_utf16(static_cast<uint16_t>(trail_surrogate));
-                }
-                else
-                    throw invalid_utf16(static_cast<uint16_t>(cp));
-
-            }
-            // Lone trail surrogate
-            else if (utf8::internal::is_trail_surrogate(cp))
-                throw invalid_utf16(static_cast<uint16_t>(cp));
-
-            result = utf8::append(cp, result);
-        }
-        return result;
-    }
-
-    template <typename u16bit_iterator, typename octet_iterator>
-    u16bit_iterator utf8to16 (octet_iterator start, octet_iterator end, u16bit_iterator result)
-    {
-        while (start != end) {
-            uint32_t cp = utf8::next(start, end);
-            if (cp > 0xffff) { //make a surrogate pair
-                *result++ = static_cast<uint16_t>((cp >> 10)   + internal::LEAD_OFFSET);
-                *result++ = static_cast<uint16_t>((cp & 0x3ff) + internal::TRAIL_SURROGATE_MIN);
-            }
-            else
-                *result++ = static_cast<uint16_t>(cp);
-        }
-        return result;
-    }
-
-    template <typename octet_iterator, typename u32bit_iterator>
-    octet_iterator utf32to8 (u32bit_iterator start, u32bit_iterator end, octet_iterator result)
-    {
-        while (start != end)
-            result = utf8::append(*(start++), result);
-
-        return result;
-    }
-
-    template <typename octet_iterator, typename u32bit_iterator>
-    u32bit_iterator utf8to32 (octet_iterator start, octet_iterator end, u32bit_iterator result)
-    {
-        while (start != end)
-            (*result++) = utf8::next(start, end);
-
-        return result;
-    }
-
-    // The iterator class
-    template <typename octet_iterator>
-    class iterator : public std::iterator <std::bidirectional_iterator_tag, uint32_t> {
-      octet_iterator it;
-      octet_iterator range_start;
-      octet_iterator range_end;
-      public:
-      iterator () {}
-      explicit iterator (const octet_iterator& octet_it,
-                         const octet_iterator& _range_start,
-                         const octet_iterator& _range_end) :
-               it(octet_it), range_start(_range_start), range_end(_range_end)
-      {
-          if (it < range_start || it > range_end)
-              throw std::out_of_range("Invalid utf-8 iterator position");
-      }
-      // the default "big three" are OK
-      octet_iterator base () const { return it; }
-      uint32_t operator * () const
-      {
-          octet_iterator temp = it;
-          return utf8::next(temp, range_end);
-      }
-      bool operator == (const iterator& rhs) const
-      {
-          if (range_start != rhs.range_start || range_end != rhs.range_end)
-              throw std::logic_error("Comparing utf-8 iterators defined with different ranges");
-          return (it == rhs.it);
-      }
-      bool operator != (const iterator& rhs) const
-      {
-          return !(operator == (rhs));
-      }
-      iterator& operator ++ ()
-      {
-          utf8::next(it, range_end);
-          return *this;
-      }
-      iterator operator ++ (int)
-      {
-          iterator temp = *this;
-          utf8::next(it, range_end);
-          return temp;
-      }
-      iterator& operator -- ()
-      {
-          utf8::prior(it, range_start);
-          return *this;
-      }
-      iterator operator -- (int)
-      {
-          iterator temp = *this;
-          utf8::prior(it, range_start);
-          return temp;
-      }
-    }; // class iterator
-
-} // namespace utf8
-
-#endif //header guard
-
-

src/deps/utf8-cpp/utf8/core.h

-// Copyright 2006 Nemanja Trifunovic
-
-/*
-Permission is hereby granted, free of charge, to any person or organization
-obtaining a copy of the software and accompanying documentation covered by
-this license (the "Software") to use, reproduce, display, distribute,
-execute, and transmit the Software, and to prepare derivative works of the
-Software, and to permit third-parties to whom the Software is furnished to
-do so, all subject to the following:
-
-The copyright notices in the Software and this entire statement, including
-the above license grant, this restriction and the following disclaimer,
-must be included in all copies of the Software, in whole or in part, and
-all derivative works of the Software, unless such copies or derivative
-works are solely in the form of machine-executable object code generated by
-a source language processor.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
-SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
-FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
-ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
-*/
-
-
-#ifndef UTF8_FOR_CPP_CORE_H_2675DCD0_9480_4c0c_B92A_CC14C027B731
-#define UTF8_FOR_CPP_CORE_H_2675DCD0_9480_4c0c_B92A_CC14C027B731
-
-#include <iterator>
-
-namespace utf8
-{
-    // The typedefs for 8-bit, 16-bit and 32-bit unsigned integers
-    // You may need to change them to match your system.
-    // These typedefs have the same names as ones from cstdint, or boost/cstdint
-    typedef unsigned char   uint8_t;
-    typedef unsigned short  uint16_t;
-    typedef unsigned int    uint32_t;
-
-// Helper code - not intended to be directly called by the library users. May be changed at any time
-namespace internal
-{
-    // Unicode constants
-    // Leading (high) surrogates: 0xd800 - 0xdbff
-    // Trailing (low) surrogates: 0xdc00 - 0xdfff
-    const uint16_t LEAD_SURROGATE_MIN  = 0xd800u;
-    const uint16_t LEAD_SURROGATE_MAX  = 0xdbffu;
-    const uint16_t TRAIL_SURROGATE_MIN = 0xdc00u;
-    const uint16_t TRAIL_SURROGATE_MAX = 0xdfffu;
-    const uint16_t LEAD_OFFSET         = LEAD_SURROGATE_MIN - (0x10000 >> 10);
-    const uint32_t SURROGATE_OFFSET    = 0x10000u - (LEAD_SURROGATE_MIN << 10) - TRAIL_SURROGATE_MIN;
-
-    // Maximum valid value for a Unicode code point
-    const uint32_t CODE_POINT_MAX      = 0x0010ffffu;
-
-    template<typename octet_type>
-    inline uint8_t mask8(octet_type oc)
-    {
-        return static_cast<uint8_t>(0xff & oc);
-    }
-    template<typename u16_type>
-    inline uint16_t mask16(u16_type oc)
-    {
-        return static_cast<uint16_t>(0xffff & oc);
-    }
-    template<typename octet_type>
-    inline bool is_trail(octet_type oc)
-    {
-        return ((utf8::internal::mask8(oc) >> 6) == 0x2);
-    }
-
-    template <typename u16>
-    inline bool is_lead_surrogate(u16 cp)
-    {
-        return (cp >= LEAD_SURROGATE_MIN && cp <= LEAD_SURROGATE_MAX);
-    }
-
-    template <typename u16>
-    inline bool is_trail_surrogate(u16 cp)
-    {
-        return (cp >= TRAIL_SURROGATE_MIN && cp <= TRAIL_SURROGATE_MAX);
-    }
-
-    template <typename u16>
-    inline bool is_surrogate(u16 cp)
-    {
-        return (cp >= LEAD_SURROGATE_MIN && cp <= TRAIL_SURROGATE_MAX);
-    }
-
-    template <typename u32>
-    inline bool is_code_point_valid(u32 cp)
-    {
-        return (cp <= CODE_POINT_MAX && !utf8::internal::is_surrogate(cp));
-    }
-
-    template <typename octet_iterator>
-    inline typename std::iterator_traits<octet_iterator>::difference_type
-    sequence_length(octet_iterator lead_it)
-    {
-        uint8_t lead = utf8::internal::mask8(*lead_it);
-        if (lead < 0x80)
-            return 1;
-        else if ((lead >> 5) == 0x6)
-            return 2;
-        else if ((lead >> 4) == 0xe)
-            return 3;
-        else if ((lead >> 3) == 0x1e)
-            return 4;
-        else
-            return 0;
-    }
-
-    template <typename octet_difference_type>
-    inline bool is_overlong_sequence(uint32_t cp, octet_difference_type length)
-    {
-        if (cp < 0x80) {
-            if (length != 1) 
-                return true;
-        }
-        else if (cp < 0x800) {
-            if (length != 2) 
-                return true;
-        }
-        else if (cp < 0x10000) {
-            if (length != 3) 
-                return true;
-        }
-
-        return false;
-    }
-
-    enum utf_error {UTF8_OK, NOT_ENOUGH_ROOM, INVALID_LEAD, INCOMPLETE_SEQUENCE, OVERLONG_SEQUENCE, INVALID_CODE_POINT};
-
-    /// Helper for get_sequence_x
-    template <typename octet_iterator>
-    utf_error increase_safely(octet_iterator& it, octet_iterator end)
-    {
-        if (++it == end)
-            return NOT_ENOUGH_ROOM;
-
-        if (!utf8::internal::is_trail(*it))
-            return INCOMPLETE_SEQUENCE;
-        
-        return UTF8_OK;
-    }
-
-    #define UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(IT, END) {utf_error ret = increase_safely(IT, END); if (ret != UTF8_OK) return ret;}    
-
-    /// get_sequence_x functions decode utf-8 sequences of the length x
-    template <typename octet_iterator>
-    utf_error get_sequence_1(octet_iterator& it, octet_iterator end, uint32_t& code_point)
-    {
-        if (it == end)
-            return NOT_ENOUGH_ROOM;
-
-        code_point = utf8::internal::mask8(*it);
-
-        return UTF8_OK;
-    }
-
-    template <typename octet_iterator>
-    utf_error get_sequence_2(octet_iterator& it, octet_iterator end, uint32_t& code_point)
-    {
-        if (it == end) 
-            return NOT_ENOUGH_ROOM;
-        
-        code_point = utf8::internal::mask8(*it);
-
-        UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)
-
-        code_point = ((code_point << 6) & 0x7ff) + ((*it) & 0x3f);
-
-        return UTF8_OK;
-    }
-
-    template <typename octet_iterator>
-    utf_error get_sequence_3(octet_iterator& it, octet_iterator end, uint32_t& code_point)
-    {
-        if (it == end)
-            return NOT_ENOUGH_ROOM;
-            
-        code_point = utf8::internal::mask8(*it);
-
-        UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)
-
-        code_point = ((code_point << 12) & 0xffff) + ((utf8::internal::mask8(*it) << 6) & 0xfff);
-
-        UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)
-
-        code_point += (*it) & 0x3f;
-
-        return UTF8_OK;
-    }
-
-    template <typename octet_iterator>
-    utf_error get_sequence_4(octet_iterator& it, octet_iterator end, uint32_t& code_point)
-    {
-        if (it == end)
-           return NOT_ENOUGH_ROOM;
-
-        code_point = utf8::internal::mask8(*it);
-
-        UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)
-
-        code_point = ((code_point << 18) & 0x1fffff) + ((utf8::internal::mask8(*it) << 12) & 0x3ffff);
-
-        UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)
-
-        code_point += (utf8::internal::mask8(*it) << 6) & 0xfff;
-
-        UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)
-
-        code_point += (*it) & 0x3f;
-
-        return UTF8_OK;
-    }
-
-    #undef UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR
-
-    template <typename octet_iterator>
-    utf_error validate_next(octet_iterator& it, octet_iterator end, uint32_t& code_point)
-    {
-        // Save the original value of it so we can go back in case of failure
-        // Of course, it does not make much sense with i.e. stream iterators
-        octet_iterator original_it = it;
-
-        uint32_t cp = 0;
-        // Determine the sequence length based on the lead octet
-        typedef typename std::iterator_traits<octet_iterator>::difference_type octet_difference_type;
-        const octet_difference_type length = utf8::internal::sequence_length(it);
-
-        // Get trail octets and calculate the code point
-        utf_error err = UTF8_OK;
-        switch (length) {
-            case 0: 
-                return INVALID_LEAD;
-            case 1:
-                err = utf8::internal::get_sequence_1(it, end, cp);
-                break;
-            case 2:
-                err = utf8::internal::get_sequence_2(it, end, cp);
-            break;
-            case 3:
-                err = utf8::internal::get_sequence_3(it, end, cp);
-            break;
-            case 4:
-                err = utf8::internal::get_sequence_4(it, end, cp);
-            break;
-        }
-
-        if (err == UTF8_OK) {
-            // Decoding succeeded. Now, security checks...
-            if (utf8::internal::is_code_point_valid(cp)) {
-                if (!utf8::internal::is_overlong_sequence(cp, length)){
-                    // Passed! Return here.
-                    code_point = cp;
-                    ++it;
-                    return UTF8_OK;
-                }
-                else
-                    err = OVERLONG_SEQUENCE;
-            }
-            else 
-                err = INVALID_CODE_POINT;
-        }
-
-        // Failure branch - restore the original value of the iterator
-        it = original_it;
-        return err;
-    }
-
-    template <typename octet_iterator>
-    inline utf_error validate_next(octet_iterator& it, octet_iterator end) {
-        uint32_t ignored;
-        return utf8::internal::validate_next(it, end, ignored);
-    }
-
-} // namespace internal
-
-    /// The library API - functions intended to be called by the users
-
-    // Byte order mark
-    const uint8_t bom[] = {0xef, 0xbb, 0xbf};
-
-    template <typename octet_iterator>
-    octet_iterator find_invalid(octet_iterator start, octet_iterator end)
-    {
-        octet_iterator result = start;
-        while (result != end) {
-            utf8::internal::utf_error err_code = utf8::internal::validate_next(result, end);
-            if (err_code != internal::UTF8_OK)
-                return result;
-        }
-        return result;
-    }
-
-    template <typename octet_iterator>
-    inline bool is_valid(octet_iterator start, octet_iterator end)
-    {
-        return (utf8::find_invalid(start, end) == end);
-    }
-
-    template <typename octet_iterator>
-    inline bool starts_with_bom (octet_iterator it, octet_iterator end)
-    {
-        return (
-            ((it != end) && (utf8::internal::mask8(*it++)) == bom[0]) &&
-            ((it != end) && (utf8::internal::mask8(*it++)) == bom[1]) &&
-            ((it != end) && (utf8::internal::mask8(*it))   == bom[2])
-           );
-    }
-	
-    //Deprecated in release 2.3 
-    template <typename octet_iterator>
-    inline bool is_bom (octet_iterator it)
-    {
-        return (
-            (utf8::internal::mask8(*it++)) == bom[0] &&
-            (utf8::internal::mask8(*it++)) == bom[1] &&
-            (utf8::internal::mask8(*it))   == bom[2]
-           );
-    }
-} // namespace utf8
-
-#endif // header guard
-
-

src/deps/utf8-cpp/utf8/unchecked.h

-// Copyright 2006 Nemanja Trifunovic
-
-/*
-Permission is hereby granted, free of charge, to any person or organization
-obtaining a copy of the software and accompanying documentation covered by
-this license (the "Software") to use, reproduce, display, distribute,
-execute, and transmit the Software, and to prepare derivative works of the
-Software, and to permit third-parties to whom the Software is furnished to
-do so, all subject to the following:
-
-The copyright notices in the Software and this entire statement, including
-the above license grant, this restriction and the following disclaimer,
-must be included in all copies of the Software, in whole or in part, and
-all derivative works of the Software, unless such copies or derivative
-works are solely in the form of machine-executable object code generated by
-a source language processor.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
-SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
-FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
-ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
-*/
-
-
-#ifndef UTF8_FOR_CPP_UNCHECKED_H_2675DCD0_9480_4c0c_B92A_CC14C027B731
-#define UTF8_FOR_CPP_UNCHECKED_H_2675DCD0_9480_4c0c_B92A_CC14C027B731
-
-#include "core.h"
-
-namespace utf8
-{
-    namespace unchecked 
-    {
-        template <typename octet_iterator>
-        octet_iterator append(uint32_t cp, octet_iterator result)
-        {
-            if (cp < 0x80)                        // one octet
-                *(result++) = static_cast<uint8_t>(cp);  
-            else if (cp < 0x800) {                // two octets
-                *(result++) = static_cast<uint8_t>((cp >> 6)          | 0xc0);
-                *(result++) = static_cast<uint8_t>((cp & 0x3f)        | 0x80);
-            }
-            else if (cp < 0x10000) {              // three octets
-                *(result++) = static_cast<uint8_t>((cp >> 12)         | 0xe0);
-                *(result++) = static_cast<uint8_t>(((cp >> 6) & 0x3f) | 0x80);
-                *(result++) = static_cast<uint8_t>((cp & 0x3f)        | 0x80);
-            }
-            else {                                // four octets
-                *(result++) = static_cast<uint8_t>((cp >> 18)         | 0xf0);
-                *(result++) = static_cast<uint8_t>(((cp >> 12) & 0x3f)| 0x80);
-                *(result++) = static_cast<uint8_t>(((cp >> 6) & 0x3f) | 0x80);
-                *(result++) = static_cast<uint8_t>((cp & 0x3f)        | 0x80);
-            }
-            return result;
-        }
-
-        template <typename octet_iterator>
-        uint32_t next(octet_iterator& it)
-        {
-            uint32_t cp = utf8::internal::mask8(*it);
-            typename std::iterator_traits<octet_iterator>::difference_type length = utf8::internal::sequence_length(it);
-            switch (length) {
-                case 1:
-                    break;
-                case 2:
-                    it++;
-                    cp = ((cp << 6) & 0x7ff) + ((*it) & 0x3f);
-                    break;
-                case 3:
-                    ++it; 
-                    cp = ((cp << 12) & 0xffff) + ((utf8::internal::mask8(*it) << 6) & 0xfff);
-                    ++it;
-                    cp += (*it) & 0x3f;
-                    break;
-                case 4:
-                    ++it;
-                    cp = ((cp << 18) & 0x1fffff) + ((utf8::internal::mask8(*it) << 12) & 0x3ffff);                
-                    ++it;
-                    cp += (utf8::internal::mask8(*it) << 6) & 0xfff;
-                    ++it;
-                    cp += (*it) & 0x3f; 
-                    break;
-            }
-            ++it;
-            return cp;        
-        }
-
-        template <typename octet_iterator>
-        uint32_t peek_next(octet_iterator it)
-        {
-            return utf8::unchecked::next(it);    
-        }
-
-        template <typename octet_iterator>
-        uint32_t prior(octet_iterator& it)
-        {
-            while (utf8::internal::is_trail(*(--it))) ;
-            octet_iterator temp = it;
-            return utf8::unchecked::next(temp);
-        }
-
-        // Deprecated in versions that include prior, but only for the sake of consistency (see utf8::previous)
-        template <typename octet_iterator>
-        inline uint32_t previous(octet_iterator& it)
-        {
-            return utf8::unchecked::prior(it);
-        }
-
-        template <typename octet_iterator, typename distance_type>
-        void advance (octet_iterator& it, distance_type n)
-        {
-            for (distance_type i = 0; i < n; ++i)
-                utf8::unchecked::next(it);
-        }
-
-        template <typename octet_iterator>
-        typename std::iterator_traits<octet_iterator>::difference_type
-        distance (octet_iterator first, octet_iterator last)
-        {
-            typename std::iterator_traits<octet_iterator>::difference_type dist;
-            for (dist = 0; first < last; ++dist) 
-                utf8::unchecked::next(first);
-            return dist;
-        }
-
-        template <typename u16bit_iterator, typename octet_iterator>
-        octet_iterator utf16to8 (u16bit_iterator start, u16bit_iterator end, octet_iterator result)
-        {       
-            while (start != end) {
-                uint32_t cp = utf8::internal::mask16(*start++);
-            // Take care of surrogate pairs first
-                if (utf8::internal::is_lead_surrogate(cp)) {
-                    uint32_t trail_surrogate = utf8::internal::mask16(*start++);
-                    cp = (cp << 10) + trail_surrogate + internal::SURROGATE_OFFSET;
-                }
-                result = utf8::unchecked::append(cp, result);
-            }
-            return result;         
-        }
-
-        template <typename u16bit_iterator, typename octet_iterator>
-        u16bit_iterator utf8to16 (octet_iterator start, octet_iterator end, u16bit_iterator result)
-        {
-            while (start < end) {
-                uint32_t cp = utf8::unchecked::next(start);
-                if (cp > 0xffff) { //make a surrogate pair
-                    *result++ = static_cast<uint16_t>((cp >> 10)   + internal::LEAD_OFFSET);
-                    *result++ = static_cast<uint16_t>((cp & 0x3ff) + internal::TRAIL_SURROGATE_MIN);
-                }
-                else
-                    *result++ = static_cast<uint16_t>(cp);
-            }
-            return result;
-        }
-
-        template <typename octet_iterator, typename u32bit_iterator>
-        octet_iterator utf32to8 (u32bit_iterator start, u32bit_iterator end, octet_iterator result)
-        {
-            while (start != end)
-                result = utf8::unchecked::append(*(start++), result);
-
-            return result;
-        }
-
-        template <typename octet_iterator, typename u32bit_iterator>
-        u32bit_iterator utf8to32 (octet_iterator start, octet_iterator end, u32bit_iterator result)
-        {
-            while (start < end)
-                (*result++) = utf8::unchecked::next(start);
-
-            return result;
-        }
-
-        // The iterator class
-        template <typename octet_iterator>
-          class iterator : public std::iterator <std::bidirectional_iterator_tag, uint32_t> { 
-            octet_iterator it;
-            public:
-            iterator () {}
-            explicit iterator (const octet_iterator& octet_it): it(octet_it) {}
-            // the default "big three" are OK
-            octet_iterator base () const { return it; }
-            uint32_t operator * () const
-            {
-                octet_iterator temp = it;
-                return utf8::unchecked::next(temp);
-            }
-            bool operator == (const iterator& rhs) const 
-            { 
-                return (it == rhs.it);
-            }
-            bool operator != (const iterator& rhs) const
-            {
-                return !(operator == (rhs));
-            }
-            iterator& operator ++ () 
-            {
-                ::std::advance(it, utf8::internal::sequence_length(it));
-                return *this;
-            }
-            iterator operator ++ (int)
-            {
-                iterator temp = *this;
-                ::std::advance(it, utf8::internal::sequence_length(it));
-                return temp;
-            }  
-            iterator& operator -- ()
-            {
-                utf8::unchecked::prior(it);
-                return *this;
-            }
-            iterator operator -- (int)
-            {
-                iterator temp = *this;
-                utf8::unchecked::prior(it);
-                return temp;
-            }
-          }; // class iterator
-
-    } // namespace utf8::unchecked
-} // namespace utf8 
-
-
-#endif // header guard
-

src/main.cpp

 #include <memory>
 
 #include "global.h"
-#include "Console.h"
 #include "Exception.h"
 #include "commander/commander.h"
 #include "commands/Command.h"
 #ifndef UNIT_TEST
 
 #include "Camera.h"
-#include "Debug.h"
 #include "FontManager.h"
 #include "Game.h"
 #include "Log.h"
 static std::string configFileToUse;
 
 static std::shared_ptr<Camera> gCamera;
-static std::shared_ptr<Console> gConsole;
-static std::shared_ptr<Debug> gDebug;
 static std::shared_ptr<FontManager> gFont;
 static std::shared_ptr<Game> gGame;
 static std::shared_ptr<Log> gLog;
     return *gCamera;
 }
 
-Console &getConsole() {
-    return *gConsole;
-}
-
-Debug& getDebug() {
-    return *gDebug;
-}
-
 Font &getFont() {
     return *gFont;
 }
     command_free(&cmd);
 
     gCamera.reset(new Camera());
-    gConsole.reset(new Console());
-    gDebug.reset(new Debug());
     gFont.reset(new FontManager());
     gGame.reset(new Game());
     gLog.reset(new Log());
         return -5;
     }
 
-    // Initialize UIs
-    error = UI::passInitialize();
+    // Initialize Menu
+    error = getMenu().initialize();
     if (error != 0) {
-        std::cout << "Could not initialize UIs (" << error << ")!" << std::endl;
+        std::cout << "Could not initialize Menu (" << error << ")!" << std::endl;
         return -6;
     }
 
+    // Initialize Debug UI
+    error = UI::initialize();
+    if (error != 0) {
+        std::cout << "Could not initialize Debug UI (" << error << ")!" << std::endl;
+        return -7;
+    }
+
+    // Initialize Game Engine
+    error = getGame().initialize();
+    if (error != 0) {
+        std::cout << "Could not initialize Game (" << error << ")!" << std::endl;
+        return -8;
+    }
+
     getLog() << "Starting " << VERSION << Log::endl;
-    getMenu().moveToTop();
+    getMenu().setVisible(true);
     systemTimerReset();
     getRunTime().setRunning(true);
 
     while (getRunTime().isRunning()) {
         getWindow().eventHandling();
-        UI::passCalculate();
+        UI::calculate();
         renderFrame();
     }
 
-    UI::passShutdown();
+    UI::shutdown();
 
 #ifdef DEBUG
     std::cout << std::endl;
 }
 
 void renderFrame() {
-    UI::passDisplay();
+    getGame().display();
+    getMenu().display();
+    UI::display();
     getWindow().swapBuffersGL();
 }