Fixed floating-point precision issue making the right-side value of a plot sometimes wrap to the left-side value.

Tricky bug, I was calling abs() which resolve to abs(float) under
Windows with the include we have, but abs(int) under Mac/Linux

README.md

@@ -1,17 +1,18 @@
 ImGui
 =====
 
-ImGui is a bloat-free graphical user interface library for C++. 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 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 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 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.
 
-After ImGui is setup in your application, you can use it like in this example:
+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
 -------
 
@@ -20,6 +21,16 @@ Gallery
 ![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).
+
+
 Credits
 -------
 

examples/directx9_example/main.cpp

@@ -86,89 +86,19 @@ static void ImImpl_RenderDrawLists(ImDrawList** const cmd_lists, int cmd_lists_c
 	int vtx_offset = 0;
 	for (int n = 0; n < cmd_lists_count; n++)
 	{
-		// Setup stack of clipping rectangles
-		int clip_rect_buf_offset = 0;
-		ImVector<ImVec4> clip_rect_stack; 
-		clip_rect_stack.push_back(ImVec4(-9999,-9999,+9999,+9999));
-
 		// Render command list
 		const ImDrawList* cmd_list = cmd_lists[n];
 		const ImDrawCmd* pcmd_end = cmd_list->commands.end();
 		for (const ImDrawCmd* pcmd = cmd_list->commands.begin(); pcmd != pcmd_end; pcmd++)
 		{
-			switch (pcmd->cmd_type)
-			{
-			case ImDrawCmdType_DrawTriangleList:
-				{
-					const ImVec4& clip_rect = clip_rect_stack.back();
-					const RECT r = { (LONG)clip_rect.x, (LONG)clip_rect.y, (LONG)clip_rect.z, (LONG)clip_rect.w };
-					g_pd3dDevice->SetScissorRect(&r);
-					g_pd3dDevice->DrawPrimitive(D3DPT_TRIANGLELIST, vtx_offset, pcmd->vtx_count/3);
-					vtx_offset += pcmd->vtx_count;
-				}
-				break;
-
-			case ImDrawCmdType_PushClipRect:
-				clip_rect_stack.push_back(cmd_list->clip_rect_buffer[clip_rect_buf_offset++]);
-				break;
-
-			case ImDrawCmdType_PopClipRect:
-				clip_rect_stack.pop_back();
-				break;
-			}
+			const RECT r = { (LONG)pcmd->clip_rect.x, (LONG)pcmd->clip_rect.y, (LONG)pcmd->clip_rect.z, (LONG)pcmd->clip_rect.w };
+			g_pd3dDevice->SetScissorRect(&r);
+			g_pd3dDevice->DrawPrimitive(D3DPT_TRIANGLELIST, vtx_offset, pcmd->vtx_count/3);
+			vtx_offset += pcmd->vtx_count;
 		}
 	}
 }
 
-// Get text data in Win32 clipboard
-static const char* ImImpl_GetClipboardTextFn()
-{
-	static char* buf_local = NULL;
-	if (buf_local)
-	{
-		free(buf_local);
-		buf_local = NULL;
-	}
-
-	if (!OpenClipboard(NULL)) 
-		return NULL;
-
-	HANDLE buf_handle = GetClipboardData(CF_TEXT); 
-	if (buf_handle == NULL)
-		return NULL;
-
-	if (char* buf_global = (char*)GlobalLock(buf_handle))
-		buf_local = strdup(buf_global);
-	GlobalUnlock(buf_handle); 
-	CloseClipboard(); 
-
-	return buf_local;
-}
-
-// Set text data in Win32 clipboard
-static void ImImpl_SetClipboardTextFn(const char* text, const char* text_end)
-{
-	if (!OpenClipboard(NULL))
-		return;
-
-	if (!text_end)
-		text_end = text + strlen(text);
-
-	const int buf_length = (text_end - text) + 1;
-	HGLOBAL buf_handle = GlobalAlloc(GMEM_MOVEABLE, buf_length * sizeof(char)); 
-	if (buf_handle == NULL)
-		return;
-
-	char* buf_global = (char *)GlobalLock(buf_handle); 
-	memcpy(buf_global, text, text_end - text);
-	buf_global[text_end - text] = 0;
-	GlobalUnlock(buf_handle); 
-
-	EmptyClipboard();
-	SetClipboardData(CF_TEXT, buf_handle);
-	CloseClipboard();
-}
-
 HRESULT InitD3D(HWND hWnd)
 {
     if (NULL == (g_pD3D = Direct3DCreate9(D3D_SDK_VERSION)))
@@ -271,8 +201,6 @@ void InitImGui()
 	io.KeyMap[ImGuiKey_Z] = 'Z';
 
 	io.RenderDrawListsFn = ImImpl_RenderDrawLists;
-	io.SetClipboardTextFn = ImImpl_SetClipboardTextFn;
-	io.GetClipboardTextFn = ImImpl_GetClipboardTextFn;
 	
 	// Create the vertex buffer
 	if (g_pd3dDevice->CreateVertexBuffer(10000 * sizeof(CUSTOMVERTEX), D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, D3DFVF_CUSTOMVERTEX, D3DPOOL_DEFAULT, &g_pVB, NULL) < 0)
@@ -292,6 +220,35 @@ void InitImGui()
 	}
 }
 
+INT64 ticks_per_second = 0;
+INT64 time = 0;
+
+void UpdateImGui()
+{
+	ImGuiIO& io = ImGui::GetIO();
+
+	// Setup timestep
+	INT64 current_time;
+	QueryPerformanceCounter((LARGE_INTEGER *)&current_time); 
+	io.DeltaTime = (float)(current_time - time) / ticks_per_second;
+	time = current_time;
+
+	// Setup inputs
+	// (we already got mouse position, buttons, wheel from the window message callback)
+	BYTE keystate[256];
+	GetKeyboardState(keystate);
+	for (int i = 0; i < 256; i++)
+		io.KeysDown[i] = (keystate[i] & 0x80) != 0;
+	io.KeyCtrl = (keystate[VK_CONTROL] & 0x80) != 0;
+	io.KeyShift = (keystate[VK_SHIFT] & 0x80) != 0;
+	// io.MousePos : filled by WM_MOUSEMOVE event
+	// io.MouseDown : filled by WM_*BUTTON* events
+	// io.MouseWheel : filled by WM_MOUSEWHEEL events
+
+	// Start the frame
+	ImGui::NewFrame();
+}
+
 int WINAPI wWinMain(HINSTANCE hInst, HINSTANCE, LPWSTR, int)
 {
     // Register the window class
@@ -301,101 +258,91 @@ int WINAPI wWinMain(HINSTANCE hInst, HINSTANCE, LPWSTR, int)
     // Create the application's window
     hWnd = CreateWindow(L"ImGui Example", L"ImGui DirectX9 Example", WS_OVERLAPPEDWINDOW, 100, 100, 1280, 800, NULL, NULL, wc.hInstance, NULL);
 
-	INT64 ticks_per_second, time;
 	if (!QueryPerformanceFrequency((LARGE_INTEGER *)&ticks_per_second))
 		return 1;
 	if (!QueryPerformanceCounter((LARGE_INTEGER *)&time))
 		return 1;
 
 	// Initialize Direct3D
-    if (InitD3D(hWnd) >= 0)
+    if (InitD3D(hWnd) < 0)
+	{
+		if (g_pVB)
+			g_pVB->Release();
+	    UnregisterClass(L"ImGui Example", wc.hInstance);
+		return 1;
+	}
+
+	// Show the window
+	ShowWindow(hWnd, SW_SHOWDEFAULT);
+	UpdateWindow(hWnd);
+
+	InitImGui();
+
+    // Enter the message loop
+    MSG msg;
+    ZeroMemory(&msg, sizeof(msg));
+    while (msg.message != WM_QUIT)
     {
-        // Show the window
-        ShowWindow(hWnd, SW_SHOWDEFAULT);
-        UpdateWindow(hWnd);
-
-		InitImGui();
-
-        // Enter the message loop
-        MSG msg;
-        ZeroMemory(&msg, sizeof(msg));
-        while (msg.message != WM_QUIT)
+        if (PeekMessage(&msg, NULL, 0U, 0U, PM_REMOVE))
         {
-            if (PeekMessage(&msg, NULL, 0U, 0U, PM_REMOVE))
-            {
-                TranslateMessage(&msg);
-                DispatchMessage(&msg);
-				continue;
-            }
+            TranslateMessage(&msg);
+            DispatchMessage(&msg);
+			continue;
+        }
 		
-			// 1) ImGui start frame, setup time delta & inputs
-			ImGuiIO& io = ImGui::GetIO();
-			INT64 current_time;
-			QueryPerformanceCounter((LARGE_INTEGER *)&current_time); 
-			io.DeltaTime = (float)(current_time - time) / ticks_per_second;
-			time = current_time;
-			BYTE keystate[256];
-			GetKeyboardState(keystate);
-			for (int i = 0; i < 256; i++)
-				io.KeysDown[i] = (keystate[i] & 0x80) != 0;
-			io.KeyCtrl = (keystate[VK_CONTROL] & 0x80) != 0;
-			io.KeyShift = (keystate[VK_SHIFT] & 0x80) != 0;
-			// io.MousePos : filled by WM_MOUSEMOVE event
-			// io.MouseDown : filled by WM_*BUTTON* events
-			// io.MouseWheel : filled by WM_MOUSEWHEEL events
-			ImGui::NewFrame();
+		UpdateImGui();
 
-			// 2) ImGui usage
-			static bool show_test_window = true;
-			static bool show_another_window = false;
-			static float f;
-			ImGui::Text("Hello, world!");
-			ImGui::SliderFloat("float", &f, 0.0f, 1.0f);
-			show_test_window ^= ImGui::Button("Test Window");
-			show_another_window ^= ImGui::Button("Another Window");
+		// Create a simple window
+		// Tip: if we don't call ImGui::Begin()/ImGui::End() the widgets appears in a window automatically called "Debug"
+		static bool show_test_window = true;
+		static bool show_another_window = false;
+		static float f;
+		ImGui::Text("Hello, world!");
+		ImGui::SliderFloat("float", &f, 0.0f, 1.0f);
+		show_test_window ^= ImGui::Button("Test Window");
+		show_another_window ^= ImGui::Button("Another Window");
 
-			// Calculate and show framerate
-			static float ms_per_frame[120] = { 0 };
-			static int ms_per_frame_idx = 0;
-			static float ms_per_frame_accum = 0.0f;
-			ms_per_frame_accum -= ms_per_frame[ms_per_frame_idx];
-			ms_per_frame[ms_per_frame_idx] = io.DeltaTime * 1000.0f;
-			ms_per_frame_accum += ms_per_frame[ms_per_frame_idx];
-			ms_per_frame_idx = (ms_per_frame_idx + 1) % 120;
-			const float ms_per_frame_avg = ms_per_frame_accum / 120;
-			ImGui::Text("Application average %.3f ms/frame (%.1f FPS)", ms_per_frame_avg, 1000.0f / ms_per_frame_avg);
+		// Calculate and show framerate
+		static float ms_per_frame[120] = { 0 };
+		static int ms_per_frame_idx = 0;
+		static float ms_per_frame_accum = 0.0f;
+		ms_per_frame_accum -= ms_per_frame[ms_per_frame_idx];
+		ms_per_frame[ms_per_frame_idx] = ImGui::GetIO().DeltaTime * 1000.0f;
+		ms_per_frame_accum += ms_per_frame[ms_per_frame_idx];
+		ms_per_frame_idx = (ms_per_frame_idx + 1) % 120;
+		const float ms_per_frame_avg = ms_per_frame_accum / 120;
+		ImGui::Text("Application average %.3f ms/frame (%.1f FPS)", ms_per_frame_avg, 1000.0f / ms_per_frame_avg);
 
-			if (show_test_window)
-			{
-				// More example code in ShowTestWindow()
-				ImGui::SetNewWindowDefaultPos(ImVec2(650, 20));		// Normally user code doesn't need/want to call it because positions are saved in .ini file anyway. Here we just want to make the demo initial state a bit more friendly!
-				ImGui::ShowTestWindow(&show_test_window);
-			}
-
-			if (show_another_window)
-			{
-				ImGui::Begin("Another Window", &show_another_window, ImVec2(200,100));
-				ImGui::Text("Hello");
-				ImGui::End();
-			}
-
-			// 3) Rendering
-			// Clear frame buffer
-		    g_pd3dDevice->SetRenderState(D3DRS_ZENABLE, false);
-			g_pd3dDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, false);
-			g_pd3dDevice->SetRenderState(D3DRS_SCISSORTESTENABLE, false);
-			g_pd3dDevice->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB(204, 153, 153), 1.0f, 0);
-			if (g_pd3dDevice->BeginScene() >= 0)
-			{
-				// Render ImGui
-				ImGui::Render();
-				g_pd3dDevice->EndScene();
-			}
-		    g_pd3dDevice->Present(NULL, NULL, NULL, NULL);
+		// Show the ImGui test window
+		// Most of user example code is in ImGui::ShowTestWindow()
+		if (show_test_window)
+		{
+			ImGui::SetNewWindowDefaultPos(ImVec2(650, 20));		// Normally user code doesn't need/want to call it because positions are saved in .ini file anyway. Here we just want to make the demo initial state a bit more friendly!
+			ImGui::ShowTestWindow(&show_test_window);
 		}
 
-		ImGui::Shutdown();
-    }
+		// Show another simple window
+		if (show_another_window)
+		{
+			ImGui::Begin("Another Window", &show_another_window, ImVec2(200,100));
+			ImGui::Text("Hello");
+			ImGui::End();
+		}
+
+		// Rendering
+		g_pd3dDevice->SetRenderState(D3DRS_ZENABLE, false);
+		g_pd3dDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, false);
+		g_pd3dDevice->SetRenderState(D3DRS_SCISSORTESTENABLE, false);
+		g_pd3dDevice->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB(204, 153, 153), 1.0f, 0);
+		if (g_pd3dDevice->BeginScene() >= 0)
+		{
+			ImGui::Render();
+			g_pd3dDevice->EndScene();
+		}
+		g_pd3dDevice->Present(NULL, NULL, NULL, NULL);
+	}
+
+	ImGui::Shutdown();
 
 	if (g_pVB)
 		g_pVB->Release();

examples/opengl_example/Makefile.Linux

@@ -0,0 +1,18 @@
+#
+# Quick and dirty makefile to build on Linux
+# tested on Ubuntu 14.04.1 32bit
+#
+
+SRC = main.cpp ../../imgui.cpp
+
+OBJ = $(SRC:.cpp=.o)
+
+CXXFLAGS = -I../../ `pkg-config --cflags glfw3`
+
+LIBS = `pkg-config --static --libs glfw3` -lGLEW
+
+all: $(OBJ)
+	$(CXX) $(OBJ) $(LIBS)
+
+clean:
+	$(RM) -f $(OBJ)

examples/opengl_example/Makefile.Macosx

@@ -0,0 +1,18 @@
+# This makefile currently only works for mac os
+# You should install via homebrew:
+#    brew install glew
+#    brew install glfw3
+#
+
+CXXFLAGS=-framework OpenGL -framework Cocoa -framework IOKit 
+CXXFLAGS+=-I/usr/local/Cellar/glew/1.10.0/include -I/usr/local/Cellar/glfw3/3.0.4/include
+CXXFLAGS+=-L/usr/local/Cellar/glew/1.10.0/lib -L/usr/local/Cellar/glfw3/3.0.4/lib
+CXXFLAGS+=-lglew -lglfw3
+CXXFLAGS+=-I../../
+CXXFLAGS+= -D__APPLE__
+
+main: main.cpp ../../imgui.cpp
+	$(CXX) $(CXXFLAGS) -o $@ $^
+
+clean:
+	rm main

examples/opengl_example/main.cpp

@@ -2,106 +2,65 @@
 #include <GL/glew.h>
 #include <GLFW/glfw3.h>
 #define STB_IMAGE_IMPLEMENTATION
-#include "stb_image.h"				// for .png loading
+#include "stb_image.h"					// for .png loading
 #include "../../imgui.h"
 #ifdef _MSC_VER
-#pragma warning (disable: 4996)		// 'This function or variable may be unsafe': strcpy, strdup, sprintf, vsnprintf, sscanf, fopen
+#pragma warning (disable: 4996)			// 'This function or variable may be unsafe': strcpy, strdup, sprintf, vsnprintf, sscanf, fopen
 #endif
 
 static GLFWwindow* window;
-static GLuint vbo;
-static GLuint vao;
-static GLuint vertexShader;
-static GLuint fragmentShader;
-static GLuint shaderProgram;
 static GLuint fontTex;
 
 // This is the main rendering function that you have to implement and provide to ImGui (via setting up 'RenderDrawListsFn' in the ImGuiIO structuer)
+// We are using the fixed pipeline. 
+// A faster way would be to collate all vertices from all cmd_lists into a single vertex buffer
 static void ImImpl_RenderDrawLists(ImDrawList** const cmd_lists, int cmd_lists_count)
 {
-	size_t total_vtx_count = 0;
-	for (int n = 0; n < cmd_lists_count; n++)
-		total_vtx_count += cmd_lists[n]->vtx_buffer.size();
-	if (total_vtx_count == 0)
+	if (cmd_lists_count == 0)
 		return;
 
-	// Copy all vertices into a single contiguous GL buffer
-	glBindBuffer(GL_ARRAY_BUFFER, vbo);
-	glBindVertexArray(vao);
-	glBufferData(GL_ARRAY_BUFFER, total_vtx_count * sizeof(ImDrawVert), NULL, GL_STREAM_DRAW);
-	unsigned char* buffer_data = (unsigned char*)glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY);
-	if (!buffer_data)
-		return;
-	for (int n = 0; n < cmd_lists_count; n++)
-	{
-		const ImDrawList* cmd_list = cmd_lists[n];
-		memcpy(buffer_data, &cmd_list->vtx_buffer[0], cmd_list->vtx_buffer.size() * sizeof(ImDrawVert));
-		buffer_data += cmd_list->vtx_buffer.size() * sizeof(ImDrawVert);
-	}
-	glUnmapBuffer(GL_ARRAY_BUFFER);
-
-	// Setup render state: alpha-blending enabled, no face culling, no depth testing
+	// Setup render state: alpha-blending enabled, no face culling, no depth testing, scissor enabled, vertex/texcoord/color pointers.
 	glEnable(GL_BLEND);
 	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 	glDisable(GL_CULL_FACE);
 	glDisable(GL_DEPTH_TEST);
+	glEnable(GL_SCISSOR_TEST);
+	glEnableClientState(GL_VERTEX_ARRAY);
+	glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+	glEnableClientState(GL_COLOR_ARRAY);
 
-	// Bind texture and enable our shader
+	// Setup texture
 	glBindTexture(GL_TEXTURE_2D, fontTex);
-	glUseProgram(shaderProgram);
-	const GLint uniMVP = glGetUniformLocation(shaderProgram, "MVP");
-	const GLint uniClipRect = glGetUniformLocation(shaderProgram, "ClipRect");
+	glEnable(GL_TEXTURE_2D);
 
 	// Setup orthographic projection matrix
 	const float width = ImGui::GetIO().DisplaySize.x;
 	const float height = ImGui::GetIO().DisplaySize.y;
-	const float mvp[4][4] =
-	{
-		{ 2.0f/width,	0.0f,			0.0f,		0.0f },
-		{ 0.0f,			2.0f/-height,	0.0f,		0.0f },
-		{ 0.0f,			0.0f,			-1.0f,		0.0f },
-		{ -1.0f,		1.0f,			0.0f,		1.0f },
-	};
-	glUniformMatrix4fv(uniMVP, 1, GL_FALSE, &mvp[0][0]);
+	glMatrixMode(GL_PROJECTION);
+	glLoadIdentity();
+	glOrtho(0.0f, width, height, 0.0f, -1.0f, +1.0f);
+	glMatrixMode(GL_MODELVIEW);
+	glLoadIdentity();
 
 	// Render command lists
-	int vtx_offset = 0;
 	for (int n = 0; n < cmd_lists_count; n++)
 	{
-		// Setup stack of clipping rectangles
-		int clip_rect_buf_offset = 0;
-		ImVector<ImVec4> clip_rect_stack;
-		clip_rect_stack.push_back(ImVec4(-9999,-9999,+9999,+9999));
-
-		// Render command list
 		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++)
 		{
-			switch (pcmd->cmd_type)
-			{
-			case ImDrawCmdType_DrawTriangleList:
-				glUniform4fv(uniClipRect, 1, (float*)&clip_rect_stack.back());
-				glDrawArrays(GL_TRIANGLES, vtx_offset, pcmd->vtx_count);
-				vtx_offset += pcmd->vtx_count;
-				break;
-
-			case ImDrawCmdType_PushClipRect:
-				clip_rect_stack.push_back(cmd_list->clip_rect_buffer[clip_rect_buf_offset++]);
-				break;
-
-			case ImDrawCmdType_PopClipRect:
-				clip_rect_stack.pop_back();
-				break;
-			}
+			glScissor((int)pcmd->clip_rect.x, (int)(height - 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;
 		}
 	}
-
-	// Cleanup GL state
-	glBindTexture(GL_TEXTURE_2D, 0);
-	glBindVertexArray(0);
-	glBindBuffer(GL_ARRAY_BUFFER, 0);
-	glUseProgram(0);
+	glDisable(GL_SCISSOR_TEST);
 }
 
 static const char* ImImpl_GetClipboardTextFn()
@@ -114,56 +73,33 @@ static void ImImpl_SetClipboardTextFn(const char* text, const char* text_end)
 	if (!text_end)
 		text_end = text + strlen(text);
 
-	// Add a zero-terminator because glfw function doesn't take a size
-	char* buf = (char*)malloc(text_end - text + 1);
-	memcpy(buf, text, text_end-text);
-	buf[text_end-text] = '\0';
-	glfwSetClipboardString(window, buf);
-	free(buf);
+	if (*text_end == 0)
+	{
+		// Already got a zero-terminator at 'text_end', we don't need to add one
+		glfwSetClipboardString(window, text);
+	}
+	else
+	{
+		// Add a zero-terminator because glfw function doesn't take a size
+		char* buf = (char*)malloc(text_end - text + 1);
+		memcpy(buf, text, text_end-text);
+		buf[text_end-text] = '\0';
+		glfwSetClipboardString(window, buf);
+		free(buf);
+	}
 }
 
-// Shader sources
-const GLchar* vertexSource =
-    "#version 150 core\n"
-	"uniform mat4 MVP;"
-    "in vec2 i_pos;"
-	"in vec2 i_uv;"
-	"in vec4 i_col;"
-	"out vec4 col;"
-	"out vec2 pixel_pos;"
-	"out vec2 uv;"
-    "void main() {"
-	"   col = i_col;"
-	"   pixel_pos = i_pos;"
-	"   uv = i_uv;"
-	"   gl_Position = MVP * vec4(i_pos.x, i_pos.y, 0.0f, 1.0f);"
-    "}";
-
-const GLchar* fragmentSource =
-    "#version 150 core\n"
-	"uniform sampler2D Tex;"
-	"uniform vec4 ClipRect;"
-	"in vec4 col;"
-	"in vec2 pixel_pos;"
-	"in vec2 uv;"
-    "out vec4 o_col;"
-    "void main() {"
-    "   o_col = texture(Tex, uv) * col;"
-	//"   if (pixel_pos.x < ClipRect.x || pixel_pos.y < ClipRect.y || pixel_pos.x > ClipRect.z || pixel_pos.y > ClipRect.w) discard;"						// Clipping: using discard
-	//"   if (step(ClipRect.x,pixel_pos.x) * step(ClipRect.y,pixel_pos.y) * step(pixel_pos.x,ClipRect.z) * step(pixel_pos.y,ClipRect.w) < 1.0f) discard;"	// Clipping: using discard and step
-	"   o_col.w *= (step(ClipRect.x,pixel_pos.x) * step(ClipRect.y,pixel_pos.y) * step(pixel_pos.x,ClipRect.z) * step(pixel_pos.y,ClipRect.w));"			// Clipping: branch-less, set alpha 0.0f
-    "}";
 
 // GLFW callbacks to get events
 static void glfw_error_callback(int error, const char* description)
 {
-    fputs(description, stderr);
+	fputs(description, stderr);
 }
 
-static float mouse_wheel = 0.0f;
 static void glfw_scroll_callback(GLFWwindow* window, double xoffset, double yoffset)
 {
-	mouse_wheel = (float)yoffset;
+	ImGuiIO& io = ImGui::GetIO();
+	io.MouseWheel = (yoffset != 0.0f) ? yoffset > 0.0f ? 1 : - 1 : 0;			// Mouse wheel: -1,0,+1
 }
 
 static void glfw_key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
@@ -188,29 +124,17 @@ void InitGL()
 {
 	glfwSetErrorCallback(glfw_error_callback);
 
-    if (!glfwInit())
-        exit(1);
+	if (!glfwInit())
+		exit(1);
 
-	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
-	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
-	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
-	glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
-	glfwWindowHint(GLFW_REFRESH_RATE, 60);
 	glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
 	window = glfwCreateWindow(1280, 720, "ImGui OpenGL example", NULL, NULL);
 	glfwMakeContextCurrent(window);
-
 	glfwSetKeyCallback(window, glfw_key_callback);
 	glfwSetScrollCallback(window, glfw_scroll_callback);
 	glfwSetCharCallback(window, glfw_char_callback);
 
-	glewExperimental = GL_TRUE;
 	glewInit();
-
-	// After calling glewInit() our GL error state may be GL_INVALID_ENUM
-	const GLenum err = glGetError();
-	(void)err;
-    IM_ASSERT(err == GL_NO_ERROR || err == GL_INVALID_ENUM);
 }
 
 void InitImGui()
@@ -219,10 +143,10 @@ void InitImGui()
 	glfwGetWindowSize(window, &w, &h);
 
 	ImGuiIO& io = ImGui::GetIO();
-	io.DisplaySize = ImVec2((float)w, (float)h);			// Display size, in pixels. For clamping windows positions.
-	io.DeltaTime = 1.0f/60.0f;								// Time elapsed since last frame, in seconds (in this sample app we'll override this every frame because our timestep is variable)
-	io.PixelCenterOffset = 0.5f;							// Align OpenGL texels
-	io.KeyMap[ImGuiKey_Tab] = GLFW_KEY_TAB;					// Keyboard mapping. ImGui will use those indices to peek into the io.KeyDown[] array that we will update during the application lifetime.
+	io.DisplaySize = ImVec2((float)w, (float)h);            // Display size, in pixels. For clamping windows positions.
+	io.DeltaTime = 1.0f/60.0f;                                // Time elapsed since last frame, in seconds (in this sample app we'll override this every frame because our timestep is variable)
+	io.PixelCenterOffset = 0.5f;                            // Align OpenGL texels
+	io.KeyMap[ImGuiKey_Tab] = GLFW_KEY_TAB;                    // Keyboard mapping. ImGui will use those indices to peek into the io.KeyDown[] array.
 	io.KeyMap[ImGuiKey_LeftArrow] = GLFW_KEY_LEFT;
 	io.KeyMap[ImGuiKey_RightArrow] = GLFW_KEY_RIGHT;
 	io.KeyMap[ImGuiKey_UpArrow] = GLFW_KEY_UP;
@@ -244,68 +168,11 @@ void InitImGui()
 	io.SetClipboardTextFn = ImImpl_SetClipboardTextFn;
 	io.GetClipboardTextFn = ImImpl_GetClipboardTextFn;
 
-	// Setup graphics backend
-	GLint status = GL_TRUE;
-	GLenum err = GL_NO_ERROR;
-	err = glGetError(); IM_ASSERT(err == GL_NO_ERROR);
-
-	// Create and compile the vertex shader
-	vertexShader = glCreateShader(GL_VERTEX_SHADER);
-	glShaderSource(vertexShader, 1, &vertexSource, NULL);
-	glCompileShader(vertexShader);
-	glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &status);
-	if (status != GL_TRUE)
-	{
-		char buffer[512];
-		glGetShaderInfoLog(vertexShader, 1024, NULL, buffer);
-		printf("%s", buffer);
-		IM_ASSERT(status == GL_TRUE);
-	}
-
-	// Create and compile the fragment shader
-	fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
-	glShaderSource(fragmentShader, 1, &fragmentSource, NULL);
-	glCompileShader(fragmentShader);
-	glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &status);
-	IM_ASSERT(status == GL_TRUE);
-
-	// Link the vertex and fragment shader into a shader program
-	shaderProgram = glCreateProgram();
-	glAttachShader(shaderProgram, vertexShader);
-	glAttachShader(shaderProgram, fragmentShader);
-	glBindFragDataLocation(shaderProgram, 0, "o_col");
-	glLinkProgram(shaderProgram);
-	glGetProgramiv(shaderProgram, GL_LINK_STATUS, &status);
-	IM_ASSERT(status == GL_TRUE);
-
-	// Create Vertex Buffer Objects & Vertex Array Objects
-	glGenBuffers(1, &vbo);
-	glBindBuffer(GL_ARRAY_BUFFER, vbo);
-	glGenVertexArrays(1, &vao);
-	glBindVertexArray(vao);
-
-	GLint posAttrib = glGetAttribLocation(shaderProgram, "i_pos");
-	glVertexAttribPointer(posAttrib, 2, GL_FLOAT, GL_FALSE, sizeof(ImDrawVert), 0);
-	glEnableVertexAttribArray(posAttrib);
-
-	GLint uvAttrib = glGetAttribLocation(shaderProgram, "i_uv");
-	glEnableVertexAttribArray(uvAttrib);
-	glVertexAttribPointer(uvAttrib, 2, GL_FLOAT, GL_FALSE, sizeof(ImDrawVert), (void*)(2*sizeof(float)));
-
-	GLint colAttrib = glGetAttribLocation(shaderProgram, "i_col");
-	glVertexAttribPointer(colAttrib, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(ImDrawVert), (void*)(4*sizeof(float)));
-	glEnableVertexAttribArray(colAttrib);
-	err = glGetError(); IM_ASSERT(err == GL_NO_ERROR);
-
-	glBindVertexArray(0);
-	glBindBuffer(GL_ARRAY_BUFFER, 0);
-
 	// Load font texture
 	glGenTextures(1, &fontTex);
 	glBindTexture(GL_TEXTURE_2D, fontTex);
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-
 	const void* png_data;
 	unsigned int png_size;
 	ImGui::GetDefaultFontData(NULL, NULL, &png_data, &png_size);
@@ -315,44 +182,43 @@ void InitImGui()
 	stbi_image_free(tex_data);
 }
 
-void Shutdown()
+void UpdateImGui()
 {
-	ImGui::Shutdown();
+	ImGuiIO& io = ImGui::GetIO();
 
-    glDeleteProgram(shaderProgram);
-    glDeleteShader(fragmentShader);
-    glDeleteShader(vertexShader);
-    glDeleteBuffers(1, &vbo);
-    glDeleteVertexArrays(1, &vao);
+	// Setup timestep
+	static double time = 0.0f;
+	const double current_time =  glfwGetTime();
+	io.DeltaTime = (float)(current_time - time);
+	time = current_time;
 
-	glfwTerminate();
+	// Setup inputs
+	// (we already got mouse wheel, keyboard keys & characters from glfw callbacks polled in glfwPollEvents())
+	double mouse_x, mouse_y;
+	glfwGetCursorPos(window, &mouse_x, &mouse_y);
+	io.MousePos = ImVec2((float)mouse_x, (float)mouse_y);                           // Mouse position, in pixels (set to -1,-1 if no mouse / on another screen, etc.)
+	io.MouseDown[0] = glfwGetMouseButton(window, GLFW_MOUSE_BUTTON_LEFT) != 0;
+	io.MouseDown[1] = glfwGetMouseButton(window, GLFW_MOUSE_BUTTON_RIGHT) != 0;
+
+	// Start the frame
+	ImGui::NewFrame();
 }
 
+// Application code
 int main(int argc, char** argv)
 {
 	InitGL();
 	InitImGui();
 
-	double time = glfwGetTime();
 	while (!glfwWindowShouldClose(window))
 	{
 		ImGuiIO& io = ImGui::GetIO();
+		io.MouseWheel = 0;
 		glfwPollEvents();
+		UpdateImGui();
 
-		// 1) ImGui start frame, setup time delta & inputs
-		const double current_time =  glfwGetTime();
-		io.DeltaTime = (float)(current_time - time);
-		time = current_time;
-		double mouse_x, mouse_y;
-		glfwGetCursorPos(window, &mouse_x, &mouse_y);
-		io.MousePos = ImVec2((float)mouse_x, (float)mouse_y);							// Mouse position, in pixels (set to -1,-1 if no mouse / on another screen, etc.)
-		io.MouseDown[0] = glfwGetMouseButton(window, GLFW_MOUSE_BUTTON_LEFT) != 0;
-		io.MouseDown[1] = glfwGetMouseButton(window, GLFW_MOUSE_BUTTON_RIGHT) != 0;
-		io.MouseWheel = (mouse_wheel != 0) ? mouse_wheel > 0.0f ? 1 : - 1 : 0;			// Mouse wheel: -1,0,+1
-		mouse_wheel = 0.0f;
-		ImGui::NewFrame();
-
-		// 2) ImGui usage
+		// Create a simple window
+		// Tip: if we don't call ImGui::Begin()/ImGui::End() the widgets appears in a window automatically called "Debug"
 		static bool show_test_window = true;
 		static bool show_another_window = false;
 		static float f;
@@ -366,19 +232,21 @@ int main(int argc, char** argv)
 		static int ms_per_frame_idx = 0;
 		static float ms_per_frame_accum = 0.0f;
 		ms_per_frame_accum -= ms_per_frame[ms_per_frame_idx];
-		ms_per_frame[ms_per_frame_idx] = io.DeltaTime * 1000.0f;
+		ms_per_frame[ms_per_frame_idx] = ImGui::GetIO().DeltaTime * 1000.0f;
 		ms_per_frame_accum += ms_per_frame[ms_per_frame_idx];
 		ms_per_frame_idx = (ms_per_frame_idx + 1) % 120;
 		const float ms_per_frame_avg = ms_per_frame_accum / 120;
 		ImGui::Text("Application average %.3f ms/frame (%.1f FPS)", ms_per_frame_avg, 1000.0f / ms_per_frame_avg);
 
+		// Show the ImGui test window
+		// Most of user example code is in ImGui::ShowTestWindow()
 		if (show_test_window)
 		{
-			// More example code in ShowTestWindow()
-			ImGui::SetNewWindowDefaultPos(ImVec2(650, 20));		// Normally user code doesn't need/want to call it because positions are saved in .ini file anyway. Here we just want to make the demo initial state a bit more friendly!
+			ImGui::SetNewWindowDefaultPos(ImVec2(650, 20));        // Normally user code doesn't need/want to call it because positions are saved in .ini file anyway. Here we just want to make the demo initial state a bit more friendly!
 			ImGui::ShowTestWindow(&show_test_window);
 		}
 
+		// Show another simple window
 		if (show_another_window)
 		{
 			ImGui::Begin("Another Window", &show_another_window, ImVec2(200,100));
@@ -386,14 +254,15 @@ int main(int argc, char** argv)
 			ImGui::End();
 		}
 
-        // 3) Rendering
-        glClearColor(0.8f, 0.6f, 0.6f, 1.0f);
-        glClear(GL_COLOR_BUFFER_BIT);
+		// Rendering
+		glViewport(0, 0, (int)io.DisplaySize.x, (int)io.DisplaySize.y);
+		glClearColor(0.8f, 0.6f, 0.6f, 1.0f);
+		glClear(GL_COLOR_BUFFER_BIT);
 		ImGui::Render();
-
 		glfwSwapBuffers(window);
 	}
 
-	Shutdown();
+	ImGui::Shutdown();
+	glfwTerminate();
 	return 0;
 }

imconfig.h

@@ -4,15 +4,22 @@
 
 #pragma once
 
-//----- Define your own ImVector<> type if you don't want to use the provided implementation defined in imgui.h
+//---- 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 assertion handler. Defaults to calling assert().
+//#define IM_ASSERT(_EXPR)	MyAssert(_EXPR)
 
-//----- Define implicit cast operators to convert back<>forth from your math types and ImVec2/ImVec4.
+//---- Don't implement default clipboard handlers for Windows (so as not to link with OpenClipboard(), etc.)
+//#define IMGUI_DISABLE_WIN32_DEFAULT_CLIPBOARD_FUNCS
+
+//---- If you are loading a custom font, ImGui expect to find a pure white pixel at (0,0)
+// Change it's UV coordinate here if you can't have a white pixel at (0,0)
+//#define IMGUI_FONT_TEX_UV_FOR_WHITE	ImVec2(0.f/256.f,0.f/256.f)
+
+//---- 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; }						\
@@ -23,12 +30,12 @@
 		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.
+//---- 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);
+	void	Value(const char* prefix, const MyVec2& v, const char* float_format = NULL);
+	void	Value(const char* prefix, const MyVec4& v, const char* float_format = NULL);
 };
 */

imgui.h

@@ -29,8 +29,8 @@ 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 int ImGuiWindowFlags;		// enum ImGuiWindowFlags_
+typedef int ImGuiInputTextFlags;	// enum ImGuiInputTextFlags_
 typedef ImBitmapFont* ImFont;
 
 struct ImVec2
@@ -85,9 +85,9 @@ public:
 
 	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 const_iterator		begin() const					{ return _data; }
 	inline iterator				end()							{ return _data + _size; }
-	inline const iterator		end() const						{ 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); }
@@ -135,7 +135,7 @@ namespace ImGui
 	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
+	void		SetWindowPos(const ImVec2& pos);									// set current window pos
 	ImVec2		GetWindowSize();
 	ImVec2		GetWindowContentRegionMin();
 	ImVec2		GetWindowContentRegionMax();
@@ -143,14 +143,20 @@ namespace ImGui
 	void		SetFontScale(float scale);
 	void		SetScrollPosHere();
 	void		SetTreeStateStorage(ImGuiStorage* tree);
+	ImGuiStorage* GetTreeStateStorage();
 	void		PushItemWidth(float item_width);
 	void		PopItemWidth();
 	float		GetItemWidth();
 	void		PushAllowKeyboardFocus(bool v);
 	void		PopAllowKeyboardFocus();
-	void		PushStyleColor(ImGuiCol idx, ImVec4 col);
+	void		PushStyleColor(ImGuiCol idx, const ImVec4& col);
 	void		PopStyleColor();
 
+	// 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		EndTooltip();
+
 	// Layout
 	void		Separator();														// horizontal line
 	void		SameLine(int column_x = 0, int spacing_w = -1);						// call between widgets to layout them horizontally
@@ -160,8 +166,8 @@ namespace ImGui
 	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);
+	ImVec2		GetCursorPos();														// cursor position is relative to window position
+	void		SetCursorPos(const ImVec2& pos);									// "
 	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();
@@ -175,6 +181,7 @@ namespace ImGui
 	// Widgets
 	void		Text(const char* fmt, ...);
 	void		TextV(const char* fmt, va_list args);
+	void		TextColored(const ImVec4& col, const char* fmt, ...);				// shortcut to doing PushStyleColor(ImGuiCol_Text, col); Text(fmt, ...); PopStyleColor();
 	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, ...);
@@ -182,16 +189,18 @@ namespace ImGui
 	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		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		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		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), size_t stride = sizeof(float));
+	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), size_t stride = sizeof(float));
 	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		InputFloat2(const char* label, float v[2], 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);
@@ -221,17 +230,20 @@ namespace ImGui
 
 	// Logging
 	void		LogButtons();
-	void		LogToTTY(int max_depth);
-	void		LogToFile(int max_depth, const char* filename);
-	void		LogToClipboard(int max_depth);
+	void		LogToTTY(int max_depth = -1);
+	void		LogToFile(int max_depth = -1, const char* filename = NULL);
+	void		LogToClipboard(int max_depth = -1);
 
 	// 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
+	void		SetNewWindowDefaultPos(const 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)
+	ImVec2		GetItemBoxMin();													// get bounding box of last item
+	ImVec2		GetItemBoxMax();													// get bounding box of last item
+	bool		IsClipped(const 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);
+	bool		IsMouseDoubleClicked(int button);
+	bool		IsMouseHoveringBox(const ImVec2& box_min, const ImVec2& box_max);
 	ImVec2		GetMousePos();
 	float		GetTime();
 	int			GetFrameCount();
@@ -377,14 +389,20 @@ struct ImGuiIO
 	bool		FontAllowScaling;			// = false					// Set to allow scaling text with CTRL+Wheel.
 	float		PixelCenterOffset;			// = 0.5f					// Set to 0.0f for DirectX <= 9, 0.5f for Direct3D >= 10 and OpenGL.
 
-	// 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')
+	// Settings - Rendering function (REQUIRED)
+	// See example code if you are unsure of how to implement this.
+	void		(*RenderDrawListsFn)(ImDrawList** const draw_lists, int count);
+
+	// Settings - Clipboard Support
+	// Override to provide your clipboard handlers.
+	// On Windows architecture, defaults to use the native Win32 clipboard, otherwise default to use a ImGui private clipboard. 
+	// NB- for SetClipboardTextFn, the string is *NOT* zero-terminated at 'text_end'
+	const char*	(*GetClipboardTextFn)();										
+	void		(*SetClipboardTextFn)(const char* text, const char* text_end);
 
 	// Input - Fill before calling NewFrame()
 	ImVec2		MousePos;					// Mouse position, in pixels (set to -1,-1 if no mouse / on another screen, etc.)
-	bool		MouseDown[2];				// Mouse buttons
+	bool		MouseDown[5];				// Mouse buttons. ImGui itself only uses button 0 (left button) but you can use others as storage for convenience.
 	int			MouseWheel;					// Mouse wheel: -1,0,+1
 	bool		KeyCtrl;					// Keyboard modifier pressed: Control
 	bool		KeyShift;					// Keyboard modifier pressed: Shift
@@ -401,11 +419,11 @@ struct ImGuiIO
 	// [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];
+	bool		MouseClicked[5];
+	ImVec2		MouseClickedPos[5];
+	float		MouseClickedTime[5];
+	bool		MouseDoubleClicked[5];
+	float		MouseDownTime[5];
 	float		KeysDownTime[512];
 
 	ImGuiIO();
@@ -469,7 +487,7 @@ struct ImGuiTextBuffer
 	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, ...);
+	void				append(const char* fmt, ...);
 };
 
 // Helper: Key->value storage
@@ -496,23 +514,14 @@ struct ImGuiStorage
 // 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; }
+	unsigned int	vtx_count;
+	ImVec4			clip_rect;
 };
 
-#ifndef IMDRAW_TEX_UV_FOR_WHITE
-#define IMDRAW_TEX_UV_FOR_WHITE	ImVec2(0,0)
+#ifndef IMGUI_FONT_TEX_UV_FOR_WHITE
+#define IMGUI_FONT_TEX_UV_FOR_WHITE	ImVec2(0.f,0.f)
 #endif
 
 // sizeof() == 20
@@ -527,18 +536,20 @@ struct ImDrawVert
 // User is responsible for providing a renderer for this in ImGuiIO::RenderDrawListFn
 struct ImDrawList
 {
-	ImVector<ImDrawCmd>		commands;
+	// This is what you have to render
+	ImVector<ImDrawCmd>		commands;			// 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)
+
+	// [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)
+	ImDrawVert*				vtx_write;			// [internal] point within vtx_buffer after each add command (to avoid using the ImVector<> operators too much)
 
 	ImDrawList() { Clear(); }
 
 	void Clear();
 	void PushClipRect(const ImVec4& clip_rect);
 	void PopClipRect();
-	void AddCommand(ImDrawCmdType cmd_type, int vtx_count);
+	void ReserveVertices(unsigned int vtx_count);
 	void AddVtx(const ImVec2& pos, ImU32 col);
 	void AddVtxLine(const ImVec2& a, const ImVec2& b, ImU32 col);