Initial release

LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Omar Cornut
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+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 AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

imconfig.h

@@ -0,0 +1,34 @@
+//-----------------------------------------------------------------------------
+// USER IMPLEMENTATION
+//-----------------------------------------------------------------------------
+
+#pragma once
+
+//----- Define your own ImVector<> type if you don't want to use the provided implementation defined in imgui.h
+//#include <vector>
+//#define ImVector	std::vector
+//#define ImVector	MyVector
+
+//----- Define assertion handler. Default to calling assert().
+// #define IM_ASSERT(_EXPR)	MyAssert(_EXPR)
+
+//----- Define implicit cast operators to convert back<>forth from your math types and ImVec2/ImVec4.
+/*
+#define IM_VEC2_CLASS_EXTRA													\
+		ImVec2(const MyVec2& f) { x = f.x; y = f.y; }						\
+		operator MyVec2() const { return MyVec2(x,y); }
+
+#define IM_VEC4_CLASS_EXTRA													\
+		ImVec4(const MyVec4& f) { x = f.x; y = f.y; z = f.z; w = f.w; }		\
+		operator MyVec4() const { return MyVec4(x,y,z,w); }
+*/
+
+//----- Freely implement extra functions within the ImGui:: namespace.
+//----- e.g. you can create variants of the ImGui::Value() helper for your low-level math types.
+/*
+namespace ImGui
+{
+	void	Value(const char* prefix, cosnt MyVec2& v, const char* float_format = NULL);
+	void	Value(const char* prefix, cosnt MyVec4& v, const char* float_format = NULL);
+};
+*/

imgui.h

@@ -0,0 +1,629 @@
+// ImGui library
+// 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.
+// Get latest version at https://github.com/ocornut/imgui
+
+#pragma once
+
+struct ImDrawList;
+struct ImBitmapFont;
+struct ImGuiAabb;
+struct ImGuiIO;
+struct ImGuiStorage;
+struct ImGuiStyle;
+struct ImGuiWindow;
+
+#include "imconfig.h"
+#include <float.h>			// FLT_MAX
+#include <stdarg.h>			// va_list
+#include <stdlib.h>			// NULL
+
+#ifndef IM_ASSERT
+#include <assert.h>
+#define IM_ASSERT(_EXPR)	assert(_EXPR)
+#endif
+
+typedef unsigned int ImU32;
+typedef ImU32 ImGuiID;
+typedef int ImGuiCol;				// enum ImGuiCol_
+typedef int ImGuiKey;				// enum ImGuiKey_
+typedef int ImGuiColorEditMode;		// enum ImGuiColorEditMode_
+typedef ImU32 ImGuiWindowFlags;		// enum ImGuiWindowFlags_
+typedef ImU32 ImGuiInputTextFlags;	// enum ImGuiInputTextFlags_
+typedef ImBitmapFont* ImFont;
+
+struct ImVec2
+{
+	float x, y;
+	ImVec2() {}
+	ImVec2(float _x, float _y) { x = _x; y = _y; }
+
+#ifdef IM_VEC2_CLASS_EXTRA
+	IM_VEC2_CLASS_EXTRA
+#endif
+};
+
+struct ImVec4
+{
+	float x, y, z, w;
+	ImVec4() {}
+	ImVec4(float _x, float _y, float _z, float _w) { x = _x; y = _y; z = _z; w = _w; }
+
+#ifdef IM_VEC4_CLASS_EXTRA
+	IM_VEC4_CLASS_EXTRA
+#endif
+};
+
+// std::vector<> like class to avoid dragging dependencies (also: windows implementation of STL with debug enabled is absurdly slow, so let's bypass it so our code runs fast in debug). 
+// this implementation does NOT call c++ constructors! we don't need them! also only provide the minimum functionalities we need.
+#ifndef ImVector
+template<typename T>
+class ImVector
+{
+private:
+	size_t						_size;
+	size_t						_capacity;
+	T*							_data;
+
+public:
+	typedef T					value_type;
+	typedef value_type*			iterator;
+	typedef const value_type*	const_iterator;
+
+	ImVector()					{ _size = _capacity = 0; _data = NULL; }
+	~ImVector()					{ if (_data) free(_data); }
+
+	inline bool					empty() const					{ return _size == 0; }
+	inline size_t				size() const					{ return _size; }
+	inline size_t				capacity() const				{ return _capacity; }
+
+    inline value_type&			at(size_t i)					{ IM_ASSERT(i < _size); return _data[i]; }
+    inline const value_type&	at(size_t i) const				{ IM_ASSERT(i < _size); return _data[i]; }
+    inline value_type&			operator[](size_t i)			{ IM_ASSERT(i < _size); return _data[i]; }
+    inline const value_type&	operator[](size_t i) const		{ IM_ASSERT(i < _size); return _data[i]; }
+
+	inline void					clear()							{ if (_data) { _size = _capacity = 0; free(_data); _data = NULL; } }
+	inline iterator				begin()							{ return _data; }
+	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 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*)realloc(_data, new_capacity * sizeof(value_type)); _capacity = new_capacity; }
+	inline void					resize(size_t new_size)			{ if (new_size > _capacity) reserve(new_size); _size = new_size; }
+
+	inline void					push_back(const value_type& v)	{ if (_size == _capacity) reserve(_capacity ? _capacity * 2 : 4); _data[_size++] = v; }
+	inline void					pop_back()						{ IM_ASSERT(_size > 0); _size--; }
+
+	inline iterator				erase(const_iterator it)		{ IM_ASSERT(it >= begin() && it < end()); const int off = it - begin(); memmove(_data + off, _data + off + 1, (_size - off - 1) * sizeof(value_type)); _size--; return _data + off; }
+	inline void					insert(const_iterator it, const value_type& v)	{ IM_ASSERT(it >= begin() && it <= end()); const int off = it - begin(); if (_size == _capacity) reserve(_capacity ? _capacity * 2 : 4); if (off < (int)_size) memmove(_data + off + 1, _data + off, (_size - off) * sizeof(value_type)); _data[off] = v; _size++; }
+};
+#endif // #ifndef ImVector
+
+// Helpers at bottom of the file:
+// - if (IMGUI_ONCE_UPON_A_FRAME)		// Execute a block of code once per frame only
+// - struct ImGuiTextFilter				// Parse and apply text filter. In format "aaaaa[,bbbb][,ccccc]"
+// - 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 ImBitmapFont				// Bitmap font loader
+
+// ImGui End-user API
+// In a namespace so that user can add extra functions (e.g. Value() helpers for your vector or common types)
+namespace ImGui
+{
+	// Main
+	ImGuiIO&	GetIO();
+	ImGuiStyle&	GetStyle();
+	void		NewFrame();
+	void		Render();
+	void		Shutdown();
+	void		ShowUserGuide();
+	void		ShowStyleEditor(ImGuiStyle* ref = NULL);
+	void		ShowTestWindow(bool* open = NULL);
+
+	// Window
+	bool		Begin(const char* name = "Debug", bool* open = NULL, ImVec2 size = ImVec2(0,0), float fill_alpha = -1.0f, ImGuiWindowFlags flags = 0);
+	void		End();
+	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(ImVec2 pos);											// unchecked
+	ImVec2		GetWindowSize();
+	ImVec2		GetWindowContentRegionMin();
+	ImVec2		GetWindowContentRegionMax();
+	ImDrawList*	GetWindowDrawList();
+	void		SetFontScale(float scale);
+	void		SetScrollPosHere();
+	void		SetTreeStateStorage(ImGuiStorage* tree);
+	void		PushItemWidth(float item_width);
+	void		PopItemWidth();
+	void		PushAllowKeyboardFocus(bool v);
+	void		PopAllowKeyboardFocus();
+	void		PushStyleColor(ImGuiCol idx, ImVec4 col);
+	void		PopStyleColor();
+
+	// Layout
+	void		Separator();														// horizontal line
+	void		SameLine(int column_x = 0, int spacing_w = -1);						// call between widgets to layout them horizontally
+	void		Spacing();
+	void		Columns(int count = 1, const char* id = NULL, bool border=true);	// setup number of columns
+	void		NextColumn();														// next column
+	float		GetColumnOffset(int column_index = -1);
+	void		SetColumnOffset(int column_index, float offset);
+	float		GetColumnWidth(int column_index = -1);
+	ImVec2		GetCursorPos();														// cursor position relative to window position
+	void		SetCursorPos(ImVec2 p);
+	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.
+	float		GetTextLineSpacing();
+	float		GetTextLineHeight();
+
+	// ID scopes
+	void		PushID(const char* str_id);
+	void		PushID(const void* ptr_id);
+	void		PushID(const int int_id);
+	void		PopID();
+
+	// Widgets
+	void		Text(const char* fmt, ...);
+	void		TextV(const char* fmt, va_list args);
+	void		TextUnformatted(const char* text, const char* text_end = NULL);		// doesn't require null terminated string if 'text_end' is specified. no copy done to any bounded stack buffer, better for long chunks of text.
+	void		LabelText(const char* label, const char* fmt, ...);
+	void		BulletText(const char* fmt, ...);
+	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		SliderFloat3(const char* label, float v[3], float v_min, float v_max, const char* display_format = "%.3f", float power = 1.0f);
+	bool		SliderAngle(const char* label, float* v, float v_degrees_min = -360.0f, float v_degrees_max = +360.0f);		// *v in radians
+	bool		SliderInt(const char* label, int* v, int v_min, int v_max, const char* display_format = "%.0f");
+	void		PlotLines(const char* label, const float* values, int values_count, int values_offset = 0, const char* overlay_text = NULL, float scale_min = FLT_MAX, float scale_max = FLT_MAX, ImVec2 graph_size = ImVec2(0,0));
+	void		PlotHistogram(const char* label, const float* values, int values_count, int values_offset = 0, const char* overlay_text = NULL, float scale_min = FLT_MAX, float scale_max = FLT_MAX, ImVec2 graph_size = ImVec2(0,0));
+	void		Checkbox(const char* label, bool* v);
+	void		CheckboxFlags(const char* label, unsigned int* flags, unsigned int flags_value);
+	bool		RadioButton(const char* label, bool active);
+	bool		RadioButton(const char* label, int* v, int v_button);
+	bool		InputFloat(const char* label, float* v, float step = 0.0f, float step_fast = 0.0f, int decimal_precision = -1);
+	bool		InputFloat3(const char* label, float v[3], 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		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		ColorButton(const ImVec4& col, bool small_height = false, bool outline_border = true);
+	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_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 void* ptr_id = NULL);								// "
+	void		TreePop();
+	void		OpenNextNode(bool open);											// force open/close the next TreeNode or CollapsingHeader
+
+	// Value helper output "name: value"
+	// Freely declare your own in the ImGui namespace.
+	void		Value(const char* prefix, bool b);
+	void		Value(const char* prefix, int v);
+	void		Value(const char* prefix, unsigned int v);
+	void		Value(const char* prefix, float v, const char* float_format = NULL);
+	void		Color(const char* prefix, const ImVec4& v);
+	void		Color(const char* prefix, unsigned int v);
+
+	// Logging
+	void		LogButtons();
+	void		LogToTTY(int max_depth);
+	void		LogToFile(int max_depth, const char* filename);
+	void		LogToClipboard(int max_depth);
+
+	// Utilities
+	void		SetTooltip(const char* fmt, ...);									// set tooltip under mouse-cursor, typically use with ImGui::IsHovered(). (currently no contention handling, last call win)
+	void		SetNewWindowDefaultPos(ImVec2 pos);									// set position of window that do
+	bool		IsHovered();														// was the last item active area hovered by mouse?
+	bool		IsClipped(ImVec2 item_size);										// to perform coarse clipping on user's side (as an optimisation)
+	bool		IsKeyPressed(int key_index, bool repeat = true);					// key_index into the keys_down[512] array, imgui doesn't know the semantic of each entry
+	bool		IsMouseClicked(int button, bool repeat = false);
+	ImVec2		GetMousePos();
+	float		GetTime();
+	int			GetFrameCount();
+	const char*	GetStyleColorName(ImGuiCol idx);
+	void		GetDefaultFontData(const void** fnt_data, unsigned int* fnt_size, const void** png_data, unsigned int* png_size);
+
+}; // namespace ImGui
+
+// Flags for ImGui::Begin()
+enum ImGuiWindowFlags_
+{
+	// Default: 0
+	ImGuiWindowFlags_ShowBorders			= 1 << 0,
+	ImGuiWindowFlags_NoTitleBar				= 1 << 1,
+	ImGuiWindowFlags_NoResize				= 1 << 2,
+	ImGuiWindowFlags_NoMove					= 1 << 3,
+	ImGuiWindowFlags_NoScrollbar			= 1 << 4,
+	ImGuiWindowFlags_ChildWindow			= 1 << 5,	// For internal use by BeginChild()
+	ImGuiWindowFlags_ChildWindowAutoFitX	= 1 << 6,	// For internal use by BeginChild()
+	ImGuiWindowFlags_ChildWindowAutoFitY	= 1 << 7,	// For internal use by BeginChild()
+	ImGuiWindowFlags_ComboBox				= 1 << 8,	// For internal use by ComboBox()
+	ImGuiWindowFlags_Tooltip				= 1 << 9,	// For internal use by Render() when using Tooltip
+};
+
+// Flags for ImGui::InputText()
+enum ImGuiInputTextFlags_
+{
+	// Default: 0
+	ImGuiInputTextFlags_CharsDecimal		= 1 << 0,
+	ImGuiInputTextFlags_CharsHexadecimal	= 1 << 1,
+	ImGuiInputTextFlags_AutoSelectAll		= 1 << 2,
+	ImGuiInputTextFlags_AlignCenter			= 1 << 3,
+};
+
+// User fill ImGuiIO.KeyMap[] array with indices into the ImGuiIO.KeysDown[512] array
+enum ImGuiKey_
+{
+	ImGuiKey_Tab,
+	ImGuiKey_LeftArrow,
+	ImGuiKey_RightArrow,
+	ImGuiKey_UpArrow,
+	ImGuiKey_DownArrow,
+	ImGuiKey_Home,
+	ImGuiKey_End,
+	ImGuiKey_Delete,
+	ImGuiKey_Backspace,
+	ImGuiKey_Enter,
+	ImGuiKey_Escape,
+	ImGuiKey_A,			// for CTRL+A: select all
+	ImGuiKey_C,			// for CTRL+C: copy
+	ImGuiKey_V,			// for CTRL+V: paste
+	ImGuiKey_X,			// for CTRL+X: cut
+	ImGuiKey_Y,			// for CTRL+Y: redo
+	ImGuiKey_Z,			// for CTRL+Z: undo
+	ImGuiKey_COUNT,
+};
+
+enum ImGuiCol_
+{
+	ImGuiCol_Text,
+	ImGuiCol_WindowBg,
+	ImGuiCol_Border,
+	ImGuiCol_BorderShadow,
+	ImGuiCol_FrameBg,				// Background of checkbox, radio button, plot, slider, text input
+	ImGuiCol_TitleBg,
+	ImGuiCol_TitleBgCollapsed,
+	ImGuiCol_ScrollbarBg,
+	ImGuiCol_ScrollbarGrab,
+	ImGuiCol_ScrollbarGrabHovered,
+	ImGuiCol_ScrollbarGrabActive,
+	ImGuiCol_ComboBg,
+	ImGuiCol_CheckActive,
+	ImGuiCol_SliderGrab,
+	ImGuiCol_SliderGrabActive,
+	ImGuiCol_Button,
+	ImGuiCol_ButtonHovered,
+	ImGuiCol_ButtonActive,
+	ImGuiCol_Header,
+	ImGuiCol_HeaderHovered,
+	ImGuiCol_HeaderActive,
+	ImGuiCol_Column,
+	ImGuiCol_ColumnHovered,
+	ImGuiCol_ColumnActive,
+	ImGuiCol_ResizeGrip,
+	ImGuiCol_ResizeGripHovered,
+	ImGuiCol_ResizeGripActive,
+	ImGuiCol_CloseButton,
+	ImGuiCol_CloseButtonHovered,
+	ImGuiCol_CloseButtonActive,
+	ImGuiCol_PlotLines,
+	ImGuiCol_PlotLinesHovered,
+	ImGuiCol_PlotHistogram,
+	ImGuiCol_PlotHistogramHovered,
+	ImGuiCol_TextSelectedBg,
+	ImGuiCol_TooltipBg,
+	ImGuiCol_COUNT,
+};
+
+enum ImGuiColorEditMode_
+{
+	ImGuiColorEditMode_UserSelect = -1,
+	ImGuiColorEditMode_RGB = 0,
+	ImGuiColorEditMode_HSV = 1,
+	ImGuiColorEditMode_HEX = 2,
+};
+
+// See constructor for comments of individual fields.
+struct ImGuiStyle
+{
+	ImVec2		WindowPadding;
+	ImVec2		WindowMinSize;
+	ImVec2		FramePadding;
+	ImVec2		ItemSpacing;
+	ImVec2		ItemInnerSpacing;
+	ImVec2		TouchExtraPadding;
+	ImVec2		AutoFitPadding;
+	float		WindowFillAlphaDefault;
+	float		WindowRounding;
+	float		TreeNodeSpacing;
+	float		ColumnsMinSpacing;
+	float		ScrollBarWidth;
+	ImVec4		Colors[ImGuiCol_COUNT];
+
+	ImGuiStyle();
+};
+
+// This is where your app communicate with ImGui. Call ImGui::GetIO() to access.
+// Read 'Programmer guide' section in .cpp file for general usage.
+struct ImGuiIO
+{
+	// 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. Set to a negative value to disable .ini saving.
+	const char* IniFilename;				// = "imgui.ini"			// Absolute path to .ini file.
+	const char*	LogFilename;				// = "imgui_log.txt"		// Absolute path to .log file.
+	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>					// Gets passed to text functions. Typedef ImFont to the type you want (ImBitmapFont* or your own font).
+	float		FontHeight;					// <auto>					// Default font height, must be the vertical distance between two lines of text, aka == CalcTextSize(" ").y
+	bool		FontAllowScaling;			// = false					// Set to allow scaling text with CTRL+Wheel.
+
+	// Settings - Functions (fill once)
+	void		(*RenderDrawListsFn)(ImDrawList** const draw_lists, int count);	// Required
+	const char*	(*GetClipboardTextFn)();										// Required for clipboard support
+	void		(*SetClipboardTextFn)(const char* text, const char* text_end);	// Required for clipboard support (nb- the string is *NOT* zero-terminated at 'text_end')
+
+	// Input - Fill before calling NewFrame()
+	ImVec2		MousePos;					// Mouse position (set to -1,-1 if no mouse / on another screen, etc.)
+	bool		MouseDown[2];				// Mouse buttons
+	int			MouseWheel;					// Mouse wheel: -1,0,+1
+	bool		KeyCtrl;					// Keyboard modifier pressed: Control
+	bool		KeyShift;					// Keyboard modifier pressed: Shift
+	bool		KeysDown[512];				// Keyboard keys that are pressed (in whatever order user naturally has access to keyboard data)
+	char		InputCharacters[16];		// List of characters input (translated by user from keypress+keyboard state). Fill using AddInputCharacter() helper.
+
+	// Output - Retrieve after calling NewFrame(), you can use them to discard inputs for the rest of your application
+	bool		WantCaptureMouse;			// ImGui is using your mouse input (= window is being hovered or widget is active).
+	bool		WantCaptureKeyboard;		// imGui is using your keyboard input (= widget is active).
+
+	// [Internal] ImGui will maintain those fields for you
+	ImVec2		MousePosPrev;
+	ImVec2		MouseDelta;
+	bool		MouseClicked[2];
+	ImVec2		MouseClickedPos[2];
+	float		MouseClickedTime[2];
+	bool		MouseDoubleClicked[2];
+	float		MouseDownTime[2];
+	float		KeysDownTime[512];
+
+	ImGuiIO();
+	void		AddInputCharacter(char c);	// Helper to add a new character into InputCharacters[]
+};
+
+//-----------------------------------------------------------------------------
+// Helpers
+//-----------------------------------------------------------------------------
+
+// Helper: execute a block of code once a frame only
+// Usage: if (IMGUI_ONCE_UPON_A_FRAME) {/*do something once a frame*/)
+#define IMGUI_ONCE_UPON_A_FRAME			static ImGuiOncePerFrame im = ImGuiOncePerFrame()
+struct ImGuiOncePerFrame
+{
+	ImGuiOncePerFrame() : LastFrame(-1) {}
+	operator bool() const { return TryIsNewFrame(); }
+private:
+	mutable int LastFrame;
+	bool		TryIsNewFrame() const	{ const int current_frame = ImGui::GetFrameCount(); if (LastFrame == current_frame) return false; LastFrame = current_frame; return true; }
+};
+
+// Helper: Parse and apply text filter. In format "aaaaa[,bbbb][,ccccc]"
+struct ImGuiTextFilter
+{
+	struct TextRange 
+	{ 
+		const char* b; 
+		const char* e;
+
+		TextRange() { b = e = NULL; }
+		TextRange(const char* _b, const char* _e) { b = _b; e = _e; }
+		const char* begin() const { return b; }
+		const char* end() const { return e; }
+		bool empty() const { return b == e; }
+		char front() const { return *b; }
+		static bool isblank(char c) { return c == ' ' && c == '\t'; } 
+		void trim_blanks() { while (b < e && isblank(*b)) b++; while (e > b && isblank(*(e-1))) e--; }
+		void split(char separator, ImVector<TextRange>& out);
+	};
+
+	char				InputBuf[256];
+	ImVector<TextRange>	Filters;
+	int					CountGrep;
+
+	ImGuiTextFilter();
+	void Clear() { InputBuf[0] = 0; Build(); }
+	void Draw(const char* label = "Filter (inc,-exc)", float width = -1.0f);	// Helper calling InputText+Build
+	bool PassFilter(const char* val) const;
+	bool IsActive() const { return !Filters.empty(); }
+	void Build();
+};
+
+// Helper: Text buffer for logging/accumulating text
+struct ImGuiTextBuffer
+{
+	ImVector<char>		Buf;
+
+	ImGuiTextBuffer()	{ Buf.push_back(0); }
+	const char*			begin() const { return Buf.begin(); }
+	const char*			end() const { return Buf.end()-1; }
+	size_t				size() const { return Buf.size()-1; }
+	bool				empty() { return Buf.empty(); }
+	void				clear() { Buf.clear(); Buf.push_back(0); }
+	void				Append(const char* fmt, ...);
+};
+
+// Helper: Key->value storage
+// - Store collapse state for a tree
+// - Store color edit options, etc.
+// Typically you don't have to worry about this since a storage is held within each Window.
+// Declare your own storage if you want to manipulate the open/close state of a particular sub-tree in your interface.
+struct ImGuiStorage
+{
+	struct Pair { ImU32 key; int val; };
+	ImVector<Pair>	Data;
+
+	void	Clear();
+	int		GetInt(ImU32 key, int default_val = 0);
+	void	SetInt(ImU32 key, int val);
+	void	SetAllInt(int val);
+
+	int*	Find(ImU32 key);
+	void	Insert(ImU32 key, int val);
+};
+
+//-----------------------------------------------------------------------------
+// Draw List
+// Hold a series of drawing commands. The user provide a renderer for ImDrawList
+//-----------------------------------------------------------------------------
+
+enum ImDrawCmdType
+{
+	ImDrawCmdType_DrawTriangleList,
+	ImDrawCmdType_PushClipRect,
+	ImDrawCmdType_PopClipRect,
+};
+
+// sizeof() == 4
+struct ImDrawCmd
+{
+	ImDrawCmdType	cmd_type : 16;
+	unsigned int	vtx_count : 16;
+	ImDrawCmd(ImDrawCmdType _cmd_type = ImDrawCmdType_DrawTriangleList, unsigned int _vtx_count = 0) { cmd_type = _cmd_type; vtx_count = _vtx_count; }
+};
+
+#ifndef IMDRAW_TEX_UV_FOR_WHITE
+#define IMDRAW_TEX_UV_FOR_WHITE	ImVec2(0,0)
+#endif
+
+// sizeof() == 20
+struct ImDrawVert
+{
+	ImVec2	pos;
+	ImVec2  uv;
+	ImU32	col;
+};
+
+// Draw command list
+// User is responsible for providing a renderer for this in ImGuiIO::RenderDrawListFn
+struct ImDrawList
+{
+	ImVector<ImDrawCmd>		commands;
+	ImVector<ImDrawVert>	vtx_buffer;			// each command consume ImDrawCmd::vtx_count of those
+	ImVector<ImVec4>		clip_rect_buffer;	// each PushClipRect command consume 1 of those
+	ImVector<ImVec4>		clip_rect_stack_;	// [internal] clip rect stack while building the command-list (so text command can perform clipping early on)
+	ImDrawVert*				vtx_write_;			// [internal] point within vtx_buffer after each add command. allow us to use less [] and .resize on the vector (often slow on windows/debug)
+
+	ImDrawList() { Clear(); }
+
+	void Clear();
+	void PushClipRect(const ImVec4& clip_rect);
+	void PopClipRect();
+	void AddCommand(ImDrawCmdType cmd_type, int vtx_count);
+	void AddVtx(const ImVec2& pos, ImU32 col);
+	void AddVtxLine(const ImVec2& a, const ImVec2& b, ImU32 col);
+
+	// Primitives
+	void AddLine(const ImVec2& a, const ImVec2& b, ImU32 col);
+	void AddRect(const ImVec2& a, const ImVec2& b, ImU32 col, float rounding = 0.0f, int rounding_corners=0x0F);
+	void AddRectFilled(const ImVec2& a, const ImVec2& b, ImU32 col, float rounding = 0.0f, int rounding_corners=0x0F);
+	void AddTriangleFilled(const ImVec2& a, const ImVec2& b, const ImVec2& c, ImU32 col);
+	void AddCircle(const ImVec2& centre, float radius, ImU32 col, int num_segments = 12);
+	void AddCircleFilled(const ImVec2& centre, float radius, ImU32 col, int num_segments = 12);
+	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));
+	void AddText(ImFont font, float font_size, const ImVec2& pos, ImU32 col, const char* text_begin, const char* text_end);
+};
+
+// Optional bitmap font data loader & renderer into vertices
+//	#define ImFont to ImBitmapFont to use
+// 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 parameters.
+//  - kerning pair are not supported (because ImGui code does per-character CalcTextSize calls, need to turn it into something more stateful to allow kerning)
+struct ImBitmapFont
+{
+#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;
+		unsigned char	Outline;
+		//char			FontName[];
+	};
+
+	struct FntCommon
+	{
+		unsigned short	LineHeight;
+		unsigned short	Base;
+		unsigned short	ScaleW, ScaleH;
+		unsigned short	Pages;
+		unsigned char	BitField;
+		unsigned char	Channels[4];
+	};
+
+	struct FntGlyph
+	{
+		unsigned int	Id;
+		unsigned short	X, Y;
+		unsigned short	Width, Height;
+		signed short	XOffset, YOffset;
+		signed short	XAdvance;
+		unsigned char	Page;
+		unsigned char	Channel;
+	};
+
+	struct FntKerning
+	{
+		unsigned int	IdFirst;
+		unsigned int	IdSecond;
+		signed short	Amount;
+	};
+#pragma pack(pop)
+
+	unsigned char*			Data;				// Raw data, content of .fnt file
+	int						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)
+	size_t					KerningCount;		//
+	int						TabCount;			// FIXME: mishandled (add fixed amount instead of aligning to column)
+	ImVector<const char*>	Filenames;			// (point into raw data)
+	ImVector<int>			IndexLookup;		// (built)
+
+	ImBitmapFont();
+	~ImBitmapFont() { Clear(); }
+
+	bool					LoadFromMemory(const void* data, int data_size);
+	bool					LoadFromFile(const char* filename);
+	void					Clear();
+	void					BuildLookupTable();
+	const FntGlyph *		FindGlyph(unsigned short c) const;
+	float					GetFontSize() const	{ return (float)Info->FontSize; }
+
+	ImVec2					CalcTextSize(float size, float max_width, const char* text_begin, const char* text_end, const char** remaining = NULL) const;
+	void					RenderText(float size, ImVec2 pos, ImU32 col, const ImVec4& clip_rect, const char* text_begin, const char* text_end, ImDrawVert*& out_vertices) const;
+};