Updated imgui, now with own TTF support.

ChangeLog.md

 ## OpenRaider (0.1.3) xythobuz <xythobuz@xythobuz.de>
 
     [ 20140118 ]
-    * Added ability to visualize font _outline_
+    * Added ability to visualize font _outline_.
+    * Updated imgui to newest version, now with its own TTF support.
+    * Fixed drawing of camera view frustum.
 
     [ 20140117 ]
     * Updated imgui, fix for Logging to Clipboard included.

include/system/Shader.h

     static int initialize();
     static void shutdown();
 
-    static void set2DState(bool on);
+    static void set2DState(bool on, bool depth = true);
 
     static void drawGL(ShaderBuffer& vertices, ShaderBuffer& uvs, glm::vec4 color, unsigned int texture,
                        TextureStorage store = TextureStorage::SYSTEM, unsigned int mode = GL_TRIANGLES,

src/Camera.cpp

 }
 
 void Camera::displayFrustum(glm::mat4 MVP) {
+    Shader::set2DState(true, false);
     Shader::drawGL(vertexBuffer, colorBuffer, indexBuffer, MVP);
     Shader::drawGL(vertexPointBuffer, colorPointBuffer, MVP, GL_POINTS);
+    Shader::set2DState(false, false);
 }
 

src/UI.cpp

  */
 
 #include "imgui/imgui.h"
-#include "stb/stb_image.h"
 
 #include "global.h"
 #include "Camera.h"
     io.SetClipboardTextFn = Window::setClipboard;
 
     // Load font texture
-    //! \todo Use our own font subsystem instead of this?
-    const void* png_data;
-    unsigned int png_size;
-    ImGui::GetDefaultFontData(nullptr, nullptr, &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);
-
-    fontTex = TextureManager::loadBufferSlot((unsigned char*)tex_data,
-              tex_x, tex_y, ColorMode::RGBA, 32,
-              TextureStorage::SYSTEM, -1, false);
-
-    stbi_image_free(tex_data);
+    //! \TODO allow loading other TTF fonts
+    unsigned char* pixels;
+    int width, height;
+    io.Fonts->GetTexDataAsRGBA32(&pixels, &width, &height);
+    fontTex = TextureManager::loadBufferSlot(pixels, width, height, ColorMode::RGBA, 32,
+                                             TextureStorage::SYSTEM, -1, false);
 
     // Set up OpenRaider style
     ImGuiStyle& style = ImGui::GetStyle();

src/deps/imgui/README.md

-ImGui
-=====
-
-ImGui is a bloat-free graphical user interface library for C++. It outputs vertex buffers that you can render in your 3D-pipeline enabled application. It is portable, renderer agnostic and carries minimal amount of dependencies (only 3 files are needed). It is based on an "immediate" graphical user interface paradigm which allows you to build simple user interfaces with ease.
-
-ImGui is designed to enable fast iteration and allow programmers to create "content creation" or "debug" tools (as opposed to tools for the average end-user). It favors simplicity and thus lacks certain features normally found in more high-level libraries, such as string localisation.
-
-ImGui is particularly suited to integration in 3D applications, fullscreen applications, embedded applications, games, or any applications on consoles platforms where operating system features are non-standard. 
-
-After ImGui is setup in your engine, you can use it like in this example:
-
-![screenshot of sample code alongside its output with ImGui](/web/code_sample_01.png?raw=true)
-
-ImGui outputs vertex buffers and simple command-lists that you can render in your application. Because it doesn't know or touch graphics state directly, you can call ImGui commands anywhere in your code (e.g. in the middle of a running algorithm, or in the middle of your own rendering process). Refer to the sample applications in the examples/ folder for instructions on how to integrate ImGui with your existing codebase. 
-
-Gallery
--------
-
-![screenshot 1](/web/test_window_01.png?raw=true)
-![screenshot 2](/web/test_window_02.png?raw=true)
-![screenshot 3](/web/test_window_03.png?raw=true)
-![screenshot 4](/web/test_window_04.png?raw=true)
-
-References
-----------
-
-The Immediate Mode GUI paradigm may at first appear unusual to some users. This is mainly because "Retained Mode" GUIs have been so widespread and predominant. The following links can give you a better understanding about how Immediate Mode GUIs works. 
-- [Johannes 'johno' Norneby's article](http://www.johno.se/book/imgui.html).
-- [A presentation by Rickard Gustafsson and Johannes Algelind](http://www.cse.chalmers.se/edu/year/2011/course/TDA361/Advanced%20Computer%20Graphics/IMGUI.pdf).
-- [Jari Komppa's tutorial on building an ImGui library](http://iki.fi/sol/imgui/).
-- [Casey Muratori's original video that popularized the concept](https://mollyrocket.com/861).
-
-Frequently Asked Question
--------------------------
-<b>How do you use ImGui on a platform that may not have a mouse and keyboard?</b>
-
-I recommend using [Synergy](http://synergy-project.org) and the uSynergy.c micro client to share your mouse and keyboard. This way you can seemingly use your PC input devices on a video game console or a tablet. ImGui was also designed to function with touch inputs if you increase the padding of widgets to compensate for the lack of precision of touch devices, but it is recommended you use a mouse to allow optimising for screen real-estate.
-
-<b>I integrated ImGui in my engine and the text or lines are blurry..</b>
-
-- Try adjusting ImGui::GetIO().PixelCenterOffset to 0.0f or 0.5f.
-- In your Render function, try translating your projection matrix by (0.5f,0.5f) or (0.375f,0.375f).
-
-<b>Can you create elaborate/serious tools with ImGui?</b>
-
-Yes. I have written data browsers, debuggers, profilers and all sort of non-trivial tools with the library. There's no reason you cannot, and in my experience the simplicity of the API is very empowering. However note that ImGui is programmer centric and the immediate-mode GUI paradigm might requires a bit of adaptation before you can realize its full potential. 
-
-<b>Can you reskin the look of ImGui?</b>
-
-Yes, you can alter the look of the interface to some degree: changing colors, sizes and padding, font. However, as ImGui is designed and optimised to create debug tools, the amount of skinning you can apply is limited. There is only so much you can stray away from the default look and feel of the interface. The example below uses modified settings to create a more compact UI with different colors:
-
-![skinning screenshot 1](/web/skinning_sample_01.png?raw=true)
-
-
-Credits
--------
-
-Developed by [Omar Cornut](http://www.miracleworld.net). The library was developed with the support of [Media Molecule](http://www.mediamolecule.com) and first used internally on the game [Tearaway](http://tearaway.mediamolecule.com). 
-
-Embeds [proggy_clean](http://upperbounds.net) font by Tristan Grimmer (also MIT license).
-
-Inspiration, feedback, and testing: Casey Muratori, Atman Binstock, Mikko Mononen, Emmanuel Briney, Stefan Kamoda, Anton Mikhailov, Matt Willis. Thanks!
-
-License
--------
-
-ImGui is licensed under the MIT License, see LICENSE for more information.

src/deps/imgui/imgui.h

-// ImGui library v1.21 wip
+// ImGui library v1.30 wip
 // See .cpp file for commentary.
 // See ImGui::ShowTestWindow() for sample code.
 // Read 'Programmer guide' in .cpp for notes on how to setup ImGui in your codebase.
 
 struct ImDrawList;
 struct ImFont;
+struct ImFontAtlas;
 struct ImGuiAabb;
 struct ImGuiIO;
 struct ImGuiStorage;
 #endif
 
 typedef unsigned int ImU32;
-typedef unsigned short ImWchar;     // hold a character for display
-typedef ImU32 ImGuiID;              // hold widget unique ID
+typedef unsigned short ImWchar;     // character for display
+typedef void* ImTextureID;          // user data to refer to a texture (e.g. store your texture handle/id)
+typedef ImU32 ImGuiID;              // unique ID used by widgets (typically hashed from a stack of string)
 typedef int ImGuiCol;               // enum ImGuiCol_
 typedef int ImGuiStyleVar;          // enum ImGuiStyleVar_
 typedef int ImGuiKey;               // enum ImGuiKey_
 typedef int ImGuiWindowFlags;       // enum ImGuiWindowFlags_
 typedef int ImGuiSetCondition;      // enum ImGuiSetCondition_
 typedef int ImGuiInputTextFlags;    // enum ImGuiInputTextFlags_
-struct ImGuiTextEditCallbackData;
+struct ImGuiTextEditCallbackData;   // for advanced uses of InputText() 
 
 struct ImVec2
 {
     inline const_iterator       begin() const                   { return Data; }
     inline iterator             end()                           { return Data + Size; }
     inline const_iterator       end() const                     { return Data + Size; }
-    inline value_type&          front()                         { return at(0); }
-    inline const value_type&    front() const                   { return at(0); }
-    inline value_type&          back()                          { IM_ASSERT(Size > 0); return at(Size-1); }
-    inline const value_type&    back() const                    { IM_ASSERT(Size > 0); return at(Size-1); }
+    inline value_type&          front()                         { IM_ASSERT(Size > 0); return Data[0]; }
+    inline const value_type&    front() const                   { IM_ASSERT(Size > 0); return Data[0]; }
+    inline value_type&          back()                          { IM_ASSERT(Size > 0); return Data[Size-1]; }
+    inline const value_type&    back() const                    { IM_ASSERT(Size > 0); return Data[Size-1]; }
     inline void                 swap(ImVector<T>& rhs)          { const size_t rhs_size = rhs.Size; rhs.Size = Size; Size = rhs_size; const size_t rhs_cap = rhs.Capacity; rhs.Capacity = Capacity; Capacity = rhs_cap; value_type* rhs_data = rhs.Data; rhs.Data = Data; Data = rhs_data; }
 
     inline void                 reserve(size_t new_capacity)    { Data = (value_type*)ImGui::MemRealloc(Data, new_capacity * sizeof(value_type)); Capacity = new_capacity; }
 // - struct ImGuiTextBuffer             // Text buffer for logging/accumulating text
 // - struct ImGuiStorage                // Custom key value storage (if you need to alter open/close states manually)
 // - struct ImDrawList                  // Draw command list
-// - struct ImFont                      // Bitmap font loader
+// - struct ImFont                      // TTF font loader, bake glyphs into bitmap
 
 // ImGui End-user API
 // In a namespace so that user can add extra functions (e.g. Value() helpers for your vector or common types)
     IMGUI_API void          SetStateStorage(ImGuiStorage* tree);                                // replace tree state storage with our own (if you want to manipulate it yourself, typically clear subsection of it).
     IMGUI_API ImGuiStorage* GetStateStorage();
 
-    IMGUI_API void          PushItemWidth(float item_width);                                    // width of items for the common item+label case. default to ~2/3 of windows width.
-    IMGUI_API void          PopItemWidth();
-    IMGUI_API float         GetItemWidth();
-    IMGUI_API void          PushAllowKeyboardFocus(bool v);                                     // allow focusing using TAB/Shift-TAB, enabled by default but you can disable it for certain widgets.
-    IMGUI_API void          PopAllowKeyboardFocus();
+    // Parameters stacks (shared)
+    IMGUI_API void          PushFont(ImFont* font);                                             // use NULL as a shortcut to push default font
+    IMGUI_API void          PopFont();
     IMGUI_API void          PushStyleColor(ImGuiCol idx, const ImVec4& col);
     IMGUI_API void          PopStyleColor(int count = 1);
     IMGUI_API void          PushStyleVar(ImGuiStyleVar idx, float val);
     IMGUI_API void          PushStyleVar(ImGuiStyleVar idx, const ImVec2& val);
     IMGUI_API void          PopStyleVar(int count = 1);
+
+    // Parameters stacks (current window)
+    IMGUI_API void          PushItemWidth(float item_width);                                    // width of items for the common item+label case. default to ~2/3 of windows width.
+    IMGUI_API void          PopItemWidth();
+    IMGUI_API float         GetItemWidth();
+    IMGUI_API void          PushAllowKeyboardFocus(bool v);                                     // allow focusing using TAB/Shift-TAB, enabled by default but you can disable it for certain widgets.
+    IMGUI_API void          PopAllowKeyboardFocus();
     IMGUI_API void          PushTextWrapPos(float wrap_pos_x = 0.0f);                           // word-wrapping for Text*() commands. < 0.0f: no wrapping; 0.0f: wrap to end of window (or column); > 0.0f: wrap at 'wrap_pos_x' position in window local space.
     IMGUI_API void          PopTextWrapPos();
 
     IMGUI_API void          LabelTextV(const char* label, const char* fmt, va_list args);
     IMGUI_API void          BulletText(const char* fmt, ...);
     IMGUI_API void          BulletTextV(const char* fmt, va_list args);
-    IMGUI_API bool          Button(const char* label, ImVec2 size = ImVec2(0,0), bool repeat_when_held = false);
+    IMGUI_API bool          Button(const char* label, const ImVec2& size = ImVec2(0,0), bool repeat_when_held = false);
     IMGUI_API bool          SmallButton(const char* label);
+    IMGUI_API void          Image(ImTextureID user_texture_id, const ImVec2& size, const ImVec2& uv0 = ImVec2(0,0), const ImVec2& uv1 = ImVec2(1,1), ImU32 tint_col = 0xFFFFFFFF, ImU32 border_col = 0x00000000);
     IMGUI_API bool          CollapsingHeader(const char* label, const char* str_id = NULL, const bool display_frame = true, const bool default_open = false);
     IMGUI_API 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.
     IMGUI_API bool          SliderFloat2(const char* label, float v[2], float v_min, float v_max, const char* display_format = "%.3f", float power = 1.0f);
     IMGUI_API float         GetTime();
     IMGUI_API int           GetFrameCount();
     IMGUI_API const char*   GetStyleColName(ImGuiCol idx);
-    IMGUI_API void          GetDefaultFontData(const void** fnt_data, unsigned int* fnt_size, const void** png_data, unsigned int* png_size);
     IMGUI_API ImVec2        CalcTextSize(const char* text, const char* text_end = NULL, bool hide_text_after_double_hash = false, float wrap_width = -1.0f);
 
 } // namespace ImGui
     ImGuiStyleVar_FrameRounding,     // float
     ImGuiStyleVar_ItemSpacing,       // ImVec2
     ImGuiStyleVar_ItemInnerSpacing,  // ImVec2
-    ImGuiStyleVar_TreeNodeSpacing,   // float
+    ImGuiStyleVar_TreeNodeSpacing    // float
 };
 
 // Enumeration for ColorEditMode()
 {
     ImGuiSetCondition_Always              = 1 << 0, // Set the variable
     ImGuiSetCondition_FirstUseThisSession = 1 << 1, // Only set the variable on the first call for this window (once per session)
-    ImGuiSetCondition_FirstUseEver        = 1 << 2, // Only set the variable if the window doesn't exist in the .ini file
+    ImGuiSetCondition_FirstUseEver        = 1 << 2  // Only set the variable if the window doesn't exist in the .ini file
 };
 
 struct ImGuiStyle
     // Settings (fill once)                 // Default value:
     //------------------------------------------------------------------
 
-    ImVec2      DisplaySize;                // <unset>                  // Display size, in pixels. For clamping windows positions.
-    float       DeltaTime;                  // = 1.0f/60.0f             // Time elapsed since last frame, in seconds.
-    float       IniSavingRate;              // = 5.0f                   // Maximum time between saving .ini file, in seconds.
-    const char* IniFilename;                // = "imgui.ini"            // Path to .ini file. NULL to disable .ini saving.
-    const char* LogFilename;                // = "imgui_log.txt"        // Path to .log file (default parameter to ImGui::LogToFile when no file is specified).
-    float       MouseDoubleClickTime;       // = 0.30f                  // Time for a double-click, in seconds.
-    float       MouseDoubleClickMaxDist;    // = 6.0f                   // Distance threshold to stay in to validate a double-click, in pixels.
-    int         KeyMap[ImGuiKey_COUNT];     // <unset>                  // Map of indices into the KeysDown[512] entries array
-    ImFont*     Font;                       // <auto>                   // Font (also see 'Settings' fields inside ImFont structure for details)
-    float       FontGlobalScale;            // = 1.0f                   // Global scale all fonts
-    bool        FontAllowUserScaling;       // = false                  // Allow user scaling text of individual window with CTRL+Wheel.
-    float       PixelCenterOffset;          // = 0.0f                   // Try to set to 0.5f or 0.375f if rendering is blurry
-
-    void*       UserData;                   // = NULL                   // Store your own data for retrieval by callbacks.
+    ImVec2        DisplaySize;              // <unset>              // Display size, in pixels. For clamping windows positions.
+    float         DeltaTime;                // = 1.0f/60.0f         // Time elapsed since last frame, in seconds.
+    float         IniSavingRate;            // = 5.0f               // Maximum time between saving .ini file, in seconds.
+    const char*   IniFilename;              // = "imgui.ini"        // Path to .ini file. NULL to disable .ini saving.
+    const char*   LogFilename;              // = "imgui_log.txt"    // Path to .log file (default parameter to ImGui::LogToFile when no file is specified).
+    float         MouseDoubleClickTime;     // = 0.30f              // Time for a double-click, in seconds.
+    float         MouseDoubleClickMaxDist;  // = 6.0f               // Distance threshold to stay in to validate a double-click, in pixels.
+    int           KeyMap[ImGuiKey_COUNT];   // <unset>              // Map of indices into the KeysDown[512] entries array
+    void*         UserData;                 // = NULL               // Store your own data for retrieval by callbacks.
+
+    ImFontAtlas*  Fonts;                    // <auto>               // Load and assemble one or more fonts into a single tightly packed texture. Output to Fonts array.
+    float         FontGlobalScale;          // = 1.0f               // Global scale all fonts
+    bool          FontAllowUserScaling;     // = false              // Allow user scaling text of individual window with CTRL+Wheel.
 
     //------------------------------------------------------------------
     // User Functions
     float       MouseDownTime[5];
     float       KeysDownTime[512];
 
-    IMGUI_API ImGuiIO();
+    IMGUI_API   ImGuiIO();
 };
 
 //-----------------------------------------------------------------------------
 
 //-----------------------------------------------------------------------------
 // Draw List
-// Hold a series of drawing commands. The user provide a renderer for ImDrawList
+// Hold a series of drawing commands. The user provides a renderer for ImDrawList
 //-----------------------------------------------------------------------------
 
 struct ImDrawCmd
 {
     unsigned int    vtx_count;
     ImVec4          clip_rect;
+    ImTextureID     texture_id;     // Copy of user-provided 'TexID' from ImFont or passed to Image*() functions. Ignore if not using images or multiple fonts.
 };
 
 #ifndef IMGUI_OVERRIDE_DRAWVERT_STRUCT_LAYOUT
     ImVector<ImDrawVert>    vtx_buffer;         // each command consume ImDrawCmd::vtx_count of those
 
     // [Internal to ImGui]
-    ImVector<ImVec4>        clip_rect_stack;    // [internal] clip rect stack while building the command-list (so text command can perform clipping early on)
+    ImVector<ImVec4>        clip_rect_stack;    // [internal]
+    ImVector<ImTextureID>   texture_id_stack;   // [internal] 
     ImDrawVert*             vtx_write;          // [internal] point within vtx_buffer after each add command (to avoid using the ImVector<> operators too much)
 
     ImDrawList() { Clear(); }
 
     IMGUI_API void  Clear();
+    IMGUI_API void  SetClipRect(const ImVec4& clip_rect);
     IMGUI_API void  PushClipRect(const ImVec4& clip_rect);
     IMGUI_API void  PopClipRect();
+    IMGUI_API void  SetTextureID(const ImTextureID& texture_id);
+    IMGUI_API void  PushTextureID(const ImTextureID& texture_id);
+    IMGUI_API void  PopTextureID();
     IMGUI_API void  ReserveVertices(unsigned int vtx_count);
     IMGUI_API void  AddVtx(const ImVec2& pos, ImU32 col);
+    IMGUI_API void  AddVtxUV(const ImVec2& pos, ImU32 col, const ImVec2& uv);
     IMGUI_API void  AddVtxLine(const ImVec2& a, const ImVec2& b, ImU32 col);
 
     // Primitives   
     IMGUI_API void  AddCircleFilled(const ImVec2& centre, float radius, ImU32 col, int num_segments = 12);
     IMGUI_API void  AddArc(const ImVec2& center, float rad, ImU32 col, int a_min, int a_max, bool tris = false, const ImVec2& third_point_offset = ImVec2(0,0));
     IMGUI_API void  AddText(ImFont* font, float font_size, const ImVec2& pos, ImU32 col, const char* text_begin, const char* text_end = NULL, float wrap_width = 0.0f);
+    IMGUI_API void  AddImage(ImTextureID user_texture_id, const ImVec2& a, const ImVec2& b, const ImVec2& uv0, const ImVec2& uv1, ImU32 col);
 };
 
-// Bitmap font data loader & renderer into vertices
-// Using the .fnt format exported by BMFont
-//  - tool: http://www.angelcode.com/products/bmfont
-//  - file-format: http://www.angelcode.com/products/bmfont/doc/file_format.html
-// Assume valid file data (won't handle invalid/malicious data)
-// Handle a subset of the options, namely:
-//  - kerning pair are not supported (because some ImGui code does per-character CalcTextSize calls, need to turn it into something more state-ful to allow for kerning)
-struct ImFont
+// Load and rasterize multiple TTF fonts into a same texture.
+// Sharing a texture for multiple fonts allows us to reduce the number of draw calls during rendering.
+// We also add custom graphic data into the texture that serves for ImGui.
+//  1. (Optional) Call AddFont*** functions. If you don't call any, the default font will be loaded for you.
+//  2. Call GetTexDataAsAlpha8() or GetTexDataAsRGBA32() to build and retrieve pixels data.
+//  3. Upload the pixels data into a texture within your graphics system.
+//  4. Call SetTexID(my_tex_id); and pass the pointer/identifier to your texture. This value will be passed back to you during rendering to identify the texture.
+//  5. Call ClearPixelsData() to free textures memory on the heap.
+struct ImFontAtlas
 {
-    struct FntInfo;
-    struct FntCommon;
-    struct FntGlyph;
-    struct FntKerning;
-
-    // Settings
-    float                       Scale;              // = 1.0f          // Base font scale, multiplied by the per-window font scale which you can adjust with SetFontScale()
-    ImVec2                      DisplayOffset;      // = (0.0f,0.0f)   // Offset font rendering by xx pixels
-    ImVec2                      TexUvForWhite;      // = (0.0f,0.0f)   // Font texture must have a white pixel at this UV coordinate. Adjust if you are using custom texture.
-    ImWchar                     FallbackChar;       // = '?'           // Replacement glyph is one isn't found.
-
-    // Data
-    unsigned char*              Data;               // Raw data, content of .fnt file
-    size_t                      DataSize;           //
-    bool                        DataOwned;          // 
-    const FntInfo*              Info;               // (point into raw data)
-    const FntCommon*            Common;             // (point into raw data)
-    const FntGlyph*             Glyphs;             // (point into raw data)
-    size_t                      GlyphsCount;        //
-    const FntKerning*           Kerning;            // (point into raw data) - NB: kerning is unsupported
-    size_t                      KerningCount;       //
-    ImVector<const char*>       Filenames;          // (point into raw data)
-    ImVector<int>               IndexLookup;        // (built)
-    const FntGlyph*             FallbackGlyph;      // == FindGlyph(FontFallbackChar)
-
-    IMGUI_API ImFont();
-    IMGUI_API ~ImFont()         { Clear(); }
-
-    IMGUI_API bool              LoadFromMemory(const void* data, size_t data_size);
-    IMGUI_API bool              LoadFromFile(const char* filename);
+    IMGUI_API ImFontAtlas();
+    IMGUI_API ~ImFontAtlas();
+    IMGUI_API ImFont*           AddFontDefault();
+    IMGUI_API ImFont*           AddFontFromFileTTF(const char* filename, float size_pixels, const ImWchar* glyph_ranges = NULL, int font_no = 0);
+    IMGUI_API ImFont*           AddFontFromMemoryTTF(void* in_ttf_data, size_t in_ttf_data_size, float size_pixels, const ImWchar* glyph_ranges = NULL, int font_no = 0); // Pass ownership of 'in_ttf_data' memory.
+    IMGUI_API void              ClearTexData();             // Saves RAM once the texture has been copied to graphics memory.
     IMGUI_API void              Clear();
-    IMGUI_API void              BuildLookupTable();
-    IMGUI_API const FntGlyph*   FindGlyph(unsigned short c) const;
-    IMGUI_API bool              IsLoaded() const { return Info != NULL && Common != NULL && Glyphs != NULL; }
-
-    // 'max_width' stops rendering after a certain width (could be turned into a 2d size). FLT_MAX to disable.
-    // 'wrap_width' enable automatic word-wrapping across multiple lines to fit into given width. 0.0f to disable.
-    IMGUI_API ImVec2            CalcTextSizeA(float size, float max_width, float wrap_width, const char* text_begin, const char* text_end = NULL, const char** remaining = NULL) const; // utf8
-    IMGUI_API ImVec2            CalcTextSizeW(float size, float max_width, const ImWchar* text_begin, const ImWchar* text_end, const ImWchar** remaining = NULL) const;                 // wchar
-    IMGUI_API void              RenderText(float size, ImVec2 pos, ImU32 col, const ImVec4& clip_rect, const char* text_begin, const char* text_end, ImDrawVert*& out_vertices, float wrap_width = 0.0f) const;
-
-    IMGUI_API const char*       CalcWordWrapPositionA(float scale, const char* text, const char* text_end, float wrap_width) const;
-
-#pragma pack(push, 1)
-    struct FntInfo
-    {
-        signed short    FontSize;
-        unsigned char   BitField;       // bit 0: smooth, bit 1: unicode, bit 2: italic, bit 3: bold, bit 4: fixedHeight, bits 5-7: reserved
-        unsigned char   CharSet;
-        unsigned short  StretchH;
-        unsigned char   AA;
-        unsigned char   PaddingUp, PaddingRight, PaddingDown, PaddingLeft;
-        unsigned char   SpacingHoriz, SpacingVert, Outline;
-        //char          FontName[];
-    };
 
-    struct FntCommon
-    {
-        unsigned short  LineHeight, Base;
-        unsigned short  ScaleW, ScaleH;
-        unsigned short  Pages;
-        unsigned char   BitField;
-        unsigned char   Channels[4];
-    };
+    // Retrieve texture data
+    // User is in charge of copying the pixels into graphics memory, then call SetTextureUserID()
+    // After loading the texture into your graphic system, store your texture handle in 'TexID' (ignore if you aren't using multiple fonts nor images)
+    // RGBA32 format is provided for convenience and high compatibility, but note that all RGB pixels are white, so 75% of the memory is wasted.
+    IMGUI_API void              GetTexDataAsAlpha8(unsigned char** out_pixels, int* out_width, int* out_height, int* out_bytes_per_pixel = NULL);  // 1 byte per-pixel
+    IMGUI_API void              GetTexDataAsRGBA32(unsigned char** out_pixels, int* out_width, int* out_height, int* out_bytes_per_pixel = NULL);  // 4 bytes-per-pixel
+    IMGUI_API void              SetTexID(void* id)  { TexID = id; }
+
+    // Helpers to retrieve list of common Unicode ranges (2 value per range, values are inclusive, zero-terminated list)
+    // (Those functions could be static, aren't so simple use case doesn't have to refer to the ImFontAtlas:: type ever if in their code)
+    IMGUI_API const ImWchar*    GetGlyphRangesDefault();    // Basic Latin, Extended Latin
+    IMGUI_API const ImWchar*    GetGlyphRangesJapanese();   // Default + Hiragana, Katakana, Half-Width, Selection of 1946 Ideographs
+    IMGUI_API const ImWchar*    GetGlyphRangesChinese();    // Japanese + full set of about 21000 CJK Unified Ideographs
+
+    // Members
+    // (Access texture data via GetTexData*() calls which will setup a default font for you.)
+    void*                       TexID;              // User data to refer to the texture once it has been uploaded to user's graphic systems. It ia passed back to you during rendering.
+    unsigned char*              TexPixelsAlpha8;    // 1 component per pixel, each component is unsigned 8-bit. Total size = TexWidth * TexHeight
+    unsigned int*               TexPixelsRGBA32;    // 4 component per pixel, each component is unsigned 8-bit. Total size = TexWidth * TexHeight * 4
+    int                         TexWidth;
+    int                         TexHeight;
+    ImVec2                      TexExtraDataPos;    // Position of our rectangle where we draw non-font graphics
+    ImVec2                      TexUvWhitePixel;    // Texture coordinates to a white pixel (part of the TexExtraData block)
+    ImVector<ImFont*>           Fonts;
+
+    // Private
+    struct ImFontAtlasData;
+    ImVector<ImFontAtlasData*>  InputData;          // Internal data
+    IMGUI_API bool              Build();            // Build pixels data. This is automatically for you by the GetTexData*** functions.
+    IMGUI_API void              ClearInputData();   // Clear the input TTF data.
+};
 
-    struct FntGlyph
+// TTF font loading and rendering
+// ImFontAtlas automatically loads a default embedded font for you when you call GetTexDataAsAlpha8() or GetTexDataAsRGBA32().
+// Kerning isn't supported. At the moment some ImGui code does per-character CalcTextSize calls, need something more state-ful.
+struct ImFont
+{
+    // Members: Settings
+    float               FontSize;           // <user set>      // Height of characters, set during loading (don't change after loading)
+    float               Scale;              // = 1.0f          // Base font scale, multiplied by the per-window font scale which you can adjust with SetFontScale()
+    ImVec2              DisplayOffset;      // = (0.0f,0.0f)   // Offset font rendering by xx pixels
+    ImWchar             FallbackChar;       // = '?'           // Replacement glyph if one isn't found.
+
+    // Members: Runtime data
+    struct Glyph
     {
-        unsigned int    Id;
-        unsigned short  X, Y, Width, Height;
-        signed short    XOffset, YOffset;
+        ImWchar         Codepoint;
         signed short    XAdvance;
-        unsigned char   Page;
-        unsigned char   Channel;
+        signed short    Width, Height;
+        signed short    XOffset, YOffset;
+        float           U0, V0, U1, V1;     // Texture coordinates
     };
+    ImFontAtlas*        ContainerAtlas;     // What we has been loaded into
+    ImVector<Glyph>     Glyphs;
+    ImVector<int>       IndexLookup;        // Index glyphs by Unicode code-point
+    const Glyph*        FallbackGlyph;      // == FindGlyph(FontFallbackChar)
 
-    struct FntKerning
-    {
-        unsigned int    IdFirst;
-        unsigned int    IdSecond;
-        signed short    Amount;
-    };
-#pragma pack(pop)
+    // Methods
+    IMGUI_API ImFont();
+    IMGUI_API ~ImFont() { Clear(); }
+    IMGUI_API void                  Clear();
+    IMGUI_API void                  BuildLookupTable();
+    IMGUI_API const Glyph*          FindGlyph(unsigned short c) const;
+    IMGUI_API bool                  IsLoaded() const        { return ContainerAtlas != NULL; }
+
+    // 'max_width' stops rendering after a certain width (could be turned into a 2d size). FLT_MAX to disable.
+    // 'wrap_width' enable automatic word-wrapping across multiple lines to fit into given width. 0.0f to disable.
+    IMGUI_API ImVec2                CalcTextSizeA(float size, float max_width, float wrap_width, const char* text_begin, const char* text_end = NULL, const char** remaining = NULL) const; // utf8
+    IMGUI_API ImVec2                CalcTextSizeW(float size, float max_width, const ImWchar* text_begin, const ImWchar* text_end, const ImWchar** remaining = NULL) const;                 // wchar
+    IMGUI_API void                  RenderText(float size, ImVec2 pos, ImU32 col, const ImVec4& clip_rect, const char* text_begin, const char* text_end, ImDrawVert*& out_vertices, float wrap_width = 0.0f) const;
+    IMGUI_API const char*           CalcWordWrapPositionA(float scale, const char* text, const char* text_end, float wrap_width) const;
 };
 
 //---- Include imgui_user.h at the end of imgui.h

src/deps/stb/stb.cpp

 #define STBRP_ASSERT assert
 #include "stb/stb_rect_pack.h"
 
-#define STB_TRUETYPE_IMPLEMENTATION
-#define STBTT_assert(x) assert(x)
-#include "stb/stb_truetype.h"
+//! \TODO bring back when imgui allows it
+//#define STB_TRUETYPE_IMPLEMENTATION
+//#define STBTT_assert(x) assert(x)
+//#include "stb/stb_truetype.h"
 

src/system/FontImGui.cpp

 
 unsigned int FontImGui::widthText(float scale, std::string s) {
     ImGuiIO& io = ImGui::GetIO();
-    ImVec2 size = io.Font->CalcTextSizeA(scale * SCALE_CALC, FLT_MAX, io.DisplaySize.y, s.c_str(),
-                                         s.c_str() + s.length());
+    ImFont* font = io.Fonts->Fonts.at(0);
+    ImVec2 size = font->CalcTextSizeA(scale * SCALE_CALC, FLT_MAX, io.DisplaySize.y, s.c_str(),
+                                                    s.c_str() + s.length());
     return size.x;
 }
 
 void FontImGui::drawText(unsigned int x, unsigned int y, float scale,
                          const unsigned char color[4], std::string s) {
     ImGuiIO& io = ImGui::GetIO();
+    ImFont* font = io.Fonts->Fonts.at(0);
     ImVec2 pos = ImVec2(x, y);
     ImU32 col = color[0] | (color[1] << 8) | (color[2] << 16) | (color[3] << 24);
 
     ImDrawList dl;
+    dl.PushTextureID(font->ContainerAtlas->TexID);
     dl.PushClipRect(ImVec4(0.0f, 0.0f, io.DisplaySize.x, io.DisplaySize.y));
-    dl.AddText(io.Font, scale * SCALE_DRAW, pos, col, s.c_str(), s.c_str() + s.length());
+    dl.AddText(font, scale * SCALE_DRAW, pos, col, s.c_str(), s.c_str() + s.length());
 
     ImDrawList* dlp = &dl;
     UI::renderImGui(&dlp, 1);
 
 unsigned int FontImGui::heightText(float scale, unsigned int maxWidth, std::string s) {
     ImGuiIO& io = ImGui::GetIO();
-    ImVec2 size = io.Font->CalcTextSizeA(scale * SCALE_CALC, FLT_MAX, maxWidth, s.c_str(),
-                                         s.c_str() + s.length());
+    ImFont* font = io.Fonts->Fonts.at(0);
+    ImVec2 size = font->CalcTextSizeA(scale * SCALE_CALC, FLT_MAX, maxWidth, s.c_str(),
+                                                    s.c_str() + s.length());
     return size.y;
 }
 
 void FontImGui::drawTextWrapped(unsigned int x, unsigned int y, float scale,
                                 const unsigned char color[4], unsigned int maxWidth, std::string s) {
     ImGuiIO& io = ImGui::GetIO();
+    ImFont* font = io.Fonts->Fonts.at(0);
     ImVec2 pos = ImVec2(x, y);
     ImU32 col = color[0] | (color[1] << 8) | (color[2] << 16) | (color[3] << 24);
 
     ImDrawList dl;
+    dl.PushTextureID(font->ContainerAtlas->TexID);
     dl.PushClipRect(ImVec4(0.0f, 0.0f, io.DisplaySize.x, io.DisplaySize.y));
-    dl.AddText(io.Font, scale * SCALE_DRAW, pos, col, s.c_str(), s.c_str() + s.length(), maxWidth);
+    dl.AddText(font, scale * SCALE_DRAW, pos, col, s.c_str(), s.c_str() + s.length(), maxWidth);
 
     ImDrawList* dlp = &dl;
     UI::renderImGui(&dlp, 1);

src/system/Shader.cpp

     glDeleteVertexArrays(1, &vertexArrayID);
 }
 
-void Shader::set2DState(bool on) {
+void Shader::set2DState(bool on, bool depth) {
     if (on) {
         glDisable(GL_CULL_FACE);
-        glDisable(GL_DEPTH_TEST);
+        if (depth)
+            glDisable(GL_DEPTH_TEST);
     } else {
-        glEnable(GL_DEPTH_TEST);
         glEnable(GL_CULL_FACE);
+        if (depth)
+            glEnable(GL_DEPTH_TEST);
     }
 }