Minor warning fixes.

docs/CHANGELOG.txt

@@ -31,6 +31,20 @@ HOW TO UPDATE?
 - Please report any issue!
 
 
+-----------------------------------------------------------------------
+ VERSION 1.88 WIP (In Progress)
+-----------------------------------------------------------------------
+
+Breaking changes:
+
+Other Changes:
+
+- Stack Tool: Added option to copy item path to clipboard. (#4631)
+- Misc: Added constexpr to ImVec2/ImVec4 inline constructors. (#4995) [@Myriachan]
+- ImVector: Fixed erase() with empty range. (#5009) [@thedmd]
+- Drawlist: Fixed PathArcTo() emitting terminating vertices too close to arc vertices. (#4993) [@thedmd]
+
+
 -----------------------------------------------------------------------
  VERSION 1.87 (Released 2022-02-07)
 -----------------------------------------------------------------------
@@ -103,7 +117,6 @@ Breaking Changes:
   better support for IME. Updated backends accordingly. Because the old field is set by existing backends,
   we are keeping it (marked as obsolete).
 
-
 Other Changes:
 
 - IO: Added event based input queue API, which now trickles events to support low framerates. [@thedmd, @ocornut]

examples/premake5-lib.lua

@@ -1,7 +0,0 @@
-project "imgui"
-    kind "StaticLib"
-    files { "../*.h", "../*.cpp" }
-    vpaths { ["imgui"] = { "../*.cpp", "../*.h", "../misc/debuggers/*.natvis" } }
-    filter { "toolset:msc*" }
-        files { "../misc/debuggers/*.natvis" }
-

examples/premake5.lua

@@ -1,298 +0,0 @@
-
--- We use Premake5 to generate project files (Visual Studio solutions, XCode solutions, Makefiles, etc.)
--- Download Premake5: at https://premake.github.io/download
--- YOU NEED PREMAKE 5.0.0-alpha10 or later
-
---------- HELP
--- To reduce friction for people who don't aren't used to Premake, we list some concrete usage examples.
-
-if _ACTION == nil then
-	print "-----------------------------------------"
-	print " DEAR IMGUI EXAMPLES - PROJECT GENERATOR"
-	print "-----------------------------------------"
-	print "Usage:"
-	print "  premake5 [generator] [options]"
-	print "Examples:"
-	print "  premake5 vs2010"
-	print "  premake5 vs2019 --with-sdl --with-vulkan"
-	print "  premake5 xcode4 --with-glfw"
-    print "  premake5 gmake2 --with-glfw --cc=clang"
-	print "Generators:"
-	print "  codelite gmake gmake2 vs2008 vs2010 vs2012 vs2013 vs2015 vs2017 xcode4 etc."
-	print "Options:"
-	print "  --with-dx9       Enable dear imgui DirectX 9 example"
-	print "  --with-dx10      Enable dear imgui DirectX 10 example"
-	print "  --with-dx11      Enable dear imgui DirectX 11 example"
-	print "  --with-dx12      Enable dear imgui DirectX 12 example (vs2015+)"
-	print "  --with-glfw      Enable dear imgui GLFW examples"
-	print "  --with-sdl       Enable dear imgui SDL examples"
-	print "  --with-vulkan    Enable dear imgui Vulkan example"
-    print "  --cc=clang       Compile with Clang"
-    print "  --cc=gcc         Compile with GCC"
-	print "Project and object files will be created in the build/ folder. You can delete your build/ folder at any time."
-	print ""
-end
-
----------- OPTIONS
-
-newoption { trigger = "with-dx9",    description="Enable dear imgui DirectX 9 example" }
-newoption { trigger = "with-dx10",   description="Enable dear imgui DirectX 10 example" }
-newoption { trigger = "with-dx11",   description="Enable dear imgui DirectX 11 example" }
-newoption { trigger = "with-dx12",   description="Enable dear imgui DirectX 12 example" }
-newoption { trigger = "with-glfw",   description="Enable dear imgui GLFW examples" }
-newoption { trigger = "with-sdl",    description="Enable dear imgui SDL examples" }
-newoption { trigger = "with-vulkan", description="Enable dear imgui Vulkan example" }
-
--- Enable/detect default options under Windows
-if _ACTION ~= nil and ((os.istarget ~= nil and os.istarget("windows")) or (os.is ~= nil and os.is("windows"))) then
-	print("( enabling --with-dx9 )");
-	print("( enabling --with-dx10 )");
-	print("( enabling --with-dx11 )");
-	_OPTIONS["with-dx9"] = 1
-	_OPTIONS["with-dx10"] = 1
-	_OPTIONS["with-dx11"] = 1
-	if _ACTION >= "vs2015" then
-		print("( enabling --with-dx12 because compiler is " .. _ACTION .. " )");
-		_OPTIONS["with-dx12"] = 1
-	end
-	print("( enabling --with-glfw because GLFW is included in the libs/ folder )");
-	_OPTIONS["with-glfw"] = 1
-	if os.getenv("SDL2_DIR") then
-		print("( enabling --with-sdl because SDL2_DIR environment variable was found )");
-		_OPTIONS["with-sdl"] = 1
-	end
-	if os.getenv("VULKAN_SDK") then
-		print("( enabling --with-vulkan because VULKAN_SDK environment variable was found )");
-		_OPTIONS["with-vulkan"] = 1
-	end
-end
-
-
---------- HELPER FUNCTIONS
-
--- Helper function: add dear imgui source files into project
-function imgui_as_src(fs_path, project_path)
-	if (project_path == nil) then project_path = fs_path; end;	        -- default to same virtual folder as the file system folder (in this project it would be ".." !)
-
-	files { fs_path .. "/*.cpp", fs_path .. "/*.h" }
-	includedirs { fs_path, fs_path .. "/backends" }
-	vpaths { [project_path] = { fs_path .. "/*.*", fs_path .. "/misc/debuggers/*.natvis" } }  -- add in a specific folder of the Visual Studio project
-	filter { "toolset:msc*" }
-		files { fs_path .. "/misc/debuggers/*.natvis" }
-	filter {}
-end
-
--- Helper function: add dear imgui as a library (uncomment the 'include "premake5-lib"' line)
---include "premake5-lib"
-function imgui_as_lib(fs_path)
-	includedirs { fs_path, fs_path .. "/backends" }
-	links "imgui"
-end
-
---------- SOLUTION, PROJECTS
-
-workspace "imgui_examples"
-	configurations { "Debug", "Release" }
-	platforms { "x86", "x86_64" }
-
-	location "build/"
-	symbols "On"
-	warnings "Extra"
-	--flags { "FatalCompileWarnings"}
-
-	filter { "configurations:Debug" }
-		optimize "Off"
-	filter { "configurations:Release" }
-		optimize "On"
-    filter { "toolset:clang", "system:windows" }
-        buildoptions { "-Xclang", "-flto-visibility-public-std" }   -- Remove "warning LNK4049: locally defined symbol ___std_terminate imported"
-
--- example_win32_directx11 (Win32 + DirectX 11)
--- We have DX11 as the first project because this is what Visual Studio uses
-if (_OPTIONS["with-dx11"]) then
-	project "example_win32_directx11"
-		kind "ConsoleApp"
-		imgui_as_src ("..", "imgui")
-		--imgui_as_lib ("..")
-		files { "../backends/imgui_impl_win32.*", "../backends/imgui_impl_dx11.*", "example_win32_directx11/*.cpp", "example_win32_directx11/*.h", "README.txt" }
-        vpaths { ["sources"] = "./**" }
-		filter { "system:windows", "toolset:msc-v80 or msc-v90 or msc-v100" }
-			includedirs { "$(DXSDK_DIR)/Include" }
-		filter { "system:windows", "toolset:msc-v80 or msc-v90 or msc-v100", "platforms:x86" }
-			libdirs { "$(DXSDK_DIR)/Lib/x86" }
-		filter { "system:windows", "toolset:msc-v80 or msc-v90 or msc-v100", "platforms:x86_64" }
-			libdirs { "$(DXSDK_DIR)/Lib/x64" }
-		filter { "system:windows" }
-			links { "d3d11", "d3dcompiler", "dxgi" }
-end
-
--- example_win32_directx9 (Win32 + DirectX 9)
-if (_OPTIONS["with-dx9"]) then
-	project "example_win32_directx9"
-		kind "ConsoleApp"
-		imgui_as_src ("..", "imgui")
-		--imgui_as_lib ("..")
-		files { "../backends/imgui_impl_win32.*", "../backends/imgui_impl_dx9.*", "example_win32_directx9/*.cpp", "example_win32_directx9/*.h", "README.txt" }
-        vpaths { ["sources"] = "./**" }
-		filter { "system:windows" }
-			links { "d3d9" }
-end
-
--- example_win32_directx10 (Win32 + DirectX 10)
-if (_OPTIONS["with-dx10"]) then
-	project "example_win32_directx10"
-		kind "ConsoleApp"
-		imgui_as_src ("..", "imgui")
-		--imgui_as_lib ("..")
-		files { "../backends/imgui_impl_win32.*", "../backends/imgui_impl_dx10.*", "example_win32_directx10/*.cpp", "example_win32_directx10/*.h", "README.txt" }
-        vpaths { ["sources"] = "./**" }
-		filter { "system:windows", "toolset:msc-v80 or msc-v90 or msc-v100" }
-			includedirs { "$(DXSDK_DIR)/Include" }
-		filter { "system:windows", "toolset:msc-v80 or msc-v90 or msc-v100", "platforms:x86" }
-			libdirs { "$(DXSDK_DIR)/Lib/x86" }
-		filter { "system:windows", "toolset:msc-v80 or msc-v90 or msc-v100", "platforms:x86_64" }
-			libdirs { "$(DXSDK_DIR)/Lib/x64" }
-		filter { "system:windows" }
-			links { "d3d10", "d3dcompiler", "dxgi" }
-end
-
--- example_win32_directx12 (Win32 + DirectX 12)
-if (_OPTIONS["with-dx12"]) then
-	project "example_win32_directx12"
-		kind "ConsoleApp"
-		systemversion "10.0.16299.0"
-		imgui_as_src ("..", "imgui")
-		--imgui_as_lib ("..")
-		files { "../backends/imgui_impl_win32.*", "../backends/imgui_impl_dx12.*", "example_win32_directx12/*.cpp", "example_win32_directx12/*.h", "README.txt" }
-        vpaths { ["sources"] = "./**" }
-		filter { "system:windows" }
-			links { "d3d12", "d3dcompiler", "dxgi" }
-end
-
--- example_glfw_opengl2 (GLFW + OpenGL2)
-if (_OPTIONS["with-glfw"]) then
-	project "example_glfw_opengl2"
-		kind "ConsoleApp"
-		imgui_as_src ("..", "imgui")
-		--imgui_as_lib ("..")
-		files { "../backends/imgui_impl_glfw.*", "../backends/imgui_impl_opengl2.*", "example_glfw_opengl2/*.h", "example_glfw_opengl2/*.cpp", "README.txt"}
-        vpaths { ["sources"] = "./**" }
-		includedirs { "libs/glfw/include" }
-		filter { "system:windows", "platforms:x86" }
-			libdirs { "libs/glfw/lib-vc2010-32" }
-		filter { "system:windows", "platforms:x86_64" }
-			libdirs { "libs/glfw/lib-vc2010-64" }
-		filter { "system:windows" }
-			ignoredefaultlibraries { "msvcrt" }
-			links { "opengl32", "glfw3" }
-		filter { "system:macosx" }
-			libdirs { "/usr/local/lib" }
-			links { "glfw" }
-			linkoptions { "-framework OpenGL" }
-end
-
--- example_glfw_opengl3 (GLFW + OpenGL3)
-if (_OPTIONS["with-glfw"]) then
-	project "example_glfw_opengl3"
-		kind "ConsoleApp"
-		imgui_as_src ("..", "imgui")
-		--imgui_as_lib ("..")
-        vpaths { ["sources"] = "./**" }
-		files { "../backends/imgui_impl_glfw.*", "../backends/imgui_impl_opengl3.*", "example_glfw_opengl3/*.h", "example_glfw_opengl3/*.cpp", "./README.txt", "libs/gl3w/GL/gl3w.c" }
-		includedirs { "libs/glfw/include", "libs/gl3w" }
-		filter { "system:windows", "platforms:x86" }
-			libdirs { "libs/glfw/lib-vc2010-32" }
-		filter { "system:windows", "platforms:x86_64" }
-			libdirs { "libs/glfw/lib-vc2010-64" }
-		filter { "system:windows" }
-			ignoredefaultlibraries { "msvcrt" }
-			links { "opengl32", "glfw3" }
-		filter { "system:macosx" }
-			libdirs { "/usr/local/lib" }
-			links { "glfw" }
-			linkoptions { "-framework OpenGL" }
-end
-
--- example_glfw_vulkan (GLFW + Vulkan)
-if (_OPTIONS["with-vulkan"]) then
-    project "example_glfw_vulkan"
-        kind "ConsoleApp"
-        imgui_as_src ("..", "imgui")
-        --imgui_as_lib ("..")
-        vpaths { ["sources"] = "./**" }
-        files { "../backends/imgui_impl_glfw*", "../backends/imgui_impl_vulkan.*", "example_glfw_vulkan/*.h", "example_glfw_vulkan/*.cpp", "./README.txt" }
-        includedirs { "libs/glfw/include", "%VULKAN_SDK%/include" }
-        filter { "system:windows", "platforms:x86" }
-            libdirs { "libs/glfw/lib-vc2010-32", "%VULKAN_SDK%/lib32" }
-        filter { "system:windows", "platforms:x86_64" }
-            libdirs { "libs/glfw/lib-vc2010-64", "%VULKAN_SDK%/lib" }
-        filter { "system:windows" }
-            ignoredefaultlibraries { "msvcrt" }
-            links { "vulkan-1", "glfw3" }
-end
-
--- example_null (no rendering)
-if (true) then
-	project "example_null"
-		kind "ConsoleApp"
-		imgui_as_src ("..", "imgui")
-		--imgui_as_lib ("..")
-        vpaths { ["sources"] = "./**" }
-		files { "example_null/*.h", "example_null/*.cpp", "./README.txt" }
-		filter { "system:windows" }
-			ignoredefaultlibraries { "msvcrt" }
-end
-
--- example_sdl_opengl2 (SDL + OpenGL2)
-if (_OPTIONS["with-sdl"]) then
-	project "example_sdl_opengl2"
-		kind "ConsoleApp"
-		imgui_as_src ("..", "imgui")
-		--imgui_as_lib ("..")
-        vpaths { ["sources"] = "./**" }
-		files { "../backends/imgui_impl_sdl*", "../backends/imgui_impl_opengl2.*", "example_sdl_opengl2/*.h", "example_sdl_opengl2/*.cpp", "./README.txt" }
-		includedirs { "%SDL2_DIR%/include" }
-		filter { "system:windows", "platforms:x86" }
-			libdirs { "%SDL2_DIR%/lib/x86" }
-		filter { "system:windows", "platforms:x86_64" }
-			libdirs { "%SDL2_DIR%/lib/x64" }
-		filter { "system:windows" }
-			ignoredefaultlibraries { "msvcrt" }
-			links { "SDL2", "SDL2main", "opengl32" }
-end
-
--- example_sdl_opengl3 (SDL + OpenGL3)
-if (_OPTIONS["with-sdl"]) then
-	project "example_sdl_opengl3"
-		kind "ConsoleApp"
-		imgui_as_src ("..", "imgui")
-		--imgui_as_lib ("..")
-        vpaths { ["sources"] = "./**" }
-		files { "../backends/imgui_impl_sdl*", "../backends/imgui_impl_opengl3.*", "example_sdl_opengl3/*.h", "example_sdl_opengl3/*.cpp", "./README.txt", "libs/gl3w/GL/gl3w.c" }
-		includedirs { "%SDL2_DIR%/include", "libs/gl3w" }
-		filter { "system:windows", "platforms:x86" }
-			libdirs { "%SDL2_DIR%/lib/x86" }
-		filter { "system:windows", "platforms:x86_64" }
-			libdirs { "%SDL2_DIR%/lib/x64" }
-		filter { "system:windows" }
-			ignoredefaultlibraries { "msvcrt" }
-			links { "SDL2", "SDL2main", "opengl32" }
-end
-
--- example_sdl_vulkan (SDL + Vulkan)
-if (_OPTIONS["with-vulkan"]) then
-    project "example_sdl_vulkan"
-        kind "ConsoleApp"
-        imgui_as_src ("..", "imgui")
-        --imgui_as_lib ("..")
-        vpaths { ["sources"] = "./**" }
-        files { "../backends/imgui_impl_sdl*", "../backends/imgui_impl_vulkan.*", "example_sdl_vulkan/*.h", "example_sdl_vulkan/*.cpp", "./README.txt" }
-        includedirs { "%SDL2_DIR%/include", "%VULKAN_SDK%/include" }
-        filter { "system:windows", "platforms:x86" }
-            libdirs { "%SDL2_DIR%/lib/x86", "%VULKAN_SDK%/lib32" }
-        filter { "system:windows", "platforms:x86_64" }
-            libdirs { "%SDL2_DIR%/lib/x64", "%VULKAN_SDK%/lib" }
-        filter { "system:windows" }
-            ignoredefaultlibraries { "msvcrt" }
-            links { "SDL2", "SDL2main", "vulkan-1" }
-end

imconfig.h

@@ -82,11 +82,11 @@
 // This will be inlined as part of ImVec2 and ImVec4 class declarations.
 /*
 #define IM_VEC2_CLASS_EXTRA                                                     \
-        ImVec2(const MyVec2& f) { x = f.x; y = f.y; }                       \
+        constexpr 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; }     \
+        constexpr 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); }
 */
 

imgui.cpp

@@ -1,4 +1,4 @@
-// dear imgui, v1.87
+// dear imgui, 1.88 WIP
 // (main code and documentation)
 
 // Help:
@@ -1180,7 +1180,7 @@ void ImGuiIO::AddInputCharacter(unsigned int c)
         return;
 
     ImGuiInputEvent e;
-    e.Type = ImGuiInputEventType_Char;
+    e.Type = ImGuiInputEventType_Text;
     e.Source = ImGuiInputSource_Keyboard;
     e.Text.Char = c;
     g.InputEventsQueue.push_back(e);
@@ -3193,6 +3193,32 @@ void ImGui::RenderNavHighlight(const ImRect& bb, ImGuiID id, ImGuiNavHighlightFl
     }
 }
 
+void ImGui::RenderMouseCursor(ImVec2 base_pos, float base_scale, ImGuiMouseCursor mouse_cursor, ImU32 col_fill, ImU32 col_border, ImU32 col_shadow)
+{
+    ImGuiContext& g = *GImGui;
+    IM_ASSERT(mouse_cursor > ImGuiMouseCursor_None && mouse_cursor < ImGuiMouseCursor_COUNT);
+    for (int n = 0; n < g.Viewports.Size; n++)
+    {
+        ImGuiViewportP* viewport = g.Viewports[n];
+        ImDrawList* draw_list = GetForegroundDrawList(viewport);
+        ImFontAtlas* font_atlas = draw_list->_Data->Font->ContainerAtlas;
+        ImVec2 offset, size, uv[4];
+        if (font_atlas->GetMouseCursorTexData(mouse_cursor, &offset, &size, &uv[0], &uv[2]))
+        {
+            const ImVec2 pos = base_pos - offset;
+            const float scale = base_scale;
+            ImTextureID tex_id = font_atlas->TexID;
+            draw_list->PushTextureID(tex_id);
+            draw_list->AddImage(tex_id, pos + ImVec2(1, 0) * scale, pos + (ImVec2(1, 0) + size) * scale, uv[2], uv[3], col_shadow);
+            draw_list->AddImage(tex_id, pos + ImVec2(2, 0) * scale, pos + (ImVec2(2, 0) + size) * scale, uv[2], uv[3], col_shadow);
+            draw_list->AddImage(tex_id, pos,                        pos + size * scale,                  uv[2], uv[3], col_border);
+            draw_list->AddImage(tex_id, pos,                        pos + size * scale,                  uv[0], uv[1], col_fill);
+            draw_list->PopTextureID();
+        }
+    }
+}
+
+
 //-----------------------------------------------------------------------------
 // [SECTION] MAIN CODE (most of the code! lots of stuff, needs tidying up!)
 //-----------------------------------------------------------------------------
@@ -4888,6 +4914,10 @@ void ImGui::Render()
         if (windows_to_render_top_most[n] && IsWindowActiveAndVisible(windows_to_render_top_most[n])) // NavWindowingTarget is always temporarily displayed as the top-most window
             AddRootWindowToDrawData(windows_to_render_top_most[n]);
 
+    // Draw software mouse cursor if requested by io.MouseDrawCursor flag
+    if (g.IO.MouseDrawCursor && first_render_of_frame && g.MouseCursor != ImGuiMouseCursor_None)
+        RenderMouseCursor(g.IO.MousePos, g.Style.MouseCursorScale, g.MouseCursor, IM_COL32_WHITE, IM_COL32_BLACK, IM_COL32(0, 0, 0, 48));
+
     // Setup ImDrawData structures for end-user
     g.IO.MetricsRenderVertices = g.IO.MetricsRenderIndices = 0;
     for (int n = 0; n < g.Viewports.Size; n++)
@@ -4895,10 +4925,6 @@ void ImGui::Render()
         ImGuiViewportP* viewport = g.Viewports[n];
         viewport->DrawDataBuilder.FlattenIntoSingleLayer();
 
-        // Draw software mouse cursor if requested by io.MouseDrawCursor flag
-        if (g.IO.MouseDrawCursor && first_render_of_frame)
-            RenderMouseCursor(GetForegroundDrawList(viewport), g.IO.MousePos, g.Style.MouseCursorScale, g.MouseCursor, IM_COL32_WHITE, IM_COL32_BLACK, IM_COL32(0, 0, 0, 48));
-
         // Add foreground ImDrawList (for each active viewport)
         if (viewport->DrawLists[1] != NULL)
             AddDrawListToDrawData(&viewport->DrawDataBuilder.Layers[0], GetForegroundDrawList(viewport));
@@ -7856,7 +7882,7 @@ void ImGui::UpdateInputEvents(bool trickle_fast_inputs)
                 }
             }
         }
-        else if (e->Type == ImGuiInputEventType_Char)
+        else if (e->Type == ImGuiInputEventType_Text)
         {
             // Trickling Rule: Stop processing queued events if keys/mouse have been interacted with
             if (trickle_fast_inputs && (key_changed || mouse_button_changed != 0 || mouse_moved || mouse_wheeled))
@@ -13000,27 +13026,44 @@ void ImGui::DebugHookIdInfo(ImGuiID id, ImGuiDataType data_type, const void* dat
     ImGuiStackLevelInfo* info = &tool->Results[tool->StackLevel];
     IM_ASSERT(info->ID == id && info->QueryFrameCount > 0);
 
-    int data_len;
     switch (data_type)
     {
     case ImGuiDataType_S32:
         ImFormatString(info->Desc, IM_ARRAYSIZE(info->Desc), "%d", (int)(intptr_t)data_id);
         break;
     case ImGuiDataType_String:
-        data_len = data_id_end ? (int)((const char*)data_id_end - (const char*)data_id) : (int)strlen((const char*)data_id);
-        ImFormatString(info->Desc, IM_ARRAYSIZE(info->Desc), "\"%.*s\"", data_len, (const char*)data_id);
+        ImFormatString(info->Desc, IM_ARRAYSIZE(info->Desc), "%.*s", data_id_end ? (int)((const char*)data_id_end - (const char*)data_id) : (int)strlen((const char*)data_id), (const char*)data_id);
         break;
     case ImGuiDataType_Pointer:
         ImFormatString(info->Desc, IM_ARRAYSIZE(info->Desc), "(void*)0x%p", data_id);
         break;
     case ImGuiDataType_ID:
-        if (info->Desc[0] == 0) // PushOverrideID() is often used to avoid hashing twice, which would lead to 2 calls to DebugHookIdInfo(). We prioritize the first one.
+        if (info->Desc[0] != 0) // PushOverrideID() is often used to avoid hashing twice, which would lead to 2 calls to DebugHookIdInfo(). We prioritize the first one.
+            return;
         ImFormatString(info->Desc, IM_ARRAYSIZE(info->Desc), "0x%08X [override]", id);
         break;
     default:
         IM_ASSERT(0);
     }
     info->QuerySuccess = true;
+    info->DataType = data_type;
+}
+
+static int StackToolFormatLevelInfo(ImGuiStackTool* tool, int n, bool format_for_ui, char* buf, size_t buf_size)
+{
+    ImGuiStackLevelInfo* info = &tool->Results[n];
+    ImGuiWindow* window = (info->Desc[0] == 0 && n == 0) ? ImGui::FindWindowByID(info->ID) : NULL;
+    if (window)                                                                 // Source: window name (because the root ID don't call GetID() and so doesn't get hooked)
+        return ImFormatString(buf, buf_size, format_for_ui ? "\"%s\" [window]" : "%s", window->Name);
+    if (info->QuerySuccess)                                                     // Source: GetID() hooks (prioritize over ItemInfo() because we frequently use patterns like: PushID(str), Button("") where they both have same id)
+        return ImFormatString(buf, buf_size, (format_for_ui && info->DataType == ImGuiDataType_String) ? "\"%s\"" : "%s", info->Desc);
+    if (tool->StackLevel < tool->Results.Size)                                  // Only start using fallback below when all queries are done, so during queries we don't flickering ??? markers.
+        return (*buf = 0);
+#ifdef IMGUI_ENABLE_TEST_ENGINE
+    if (const char* label = ImGuiTestEngine_FindItemDebugLabel(GImGui, info->ID))   // Source: ImGuiTestEngine's ItemInfo()
+        return ImFormatString(buf, buf_size, format_for_ui ? "??? \"%s\"" : "%s", label);
+#endif
+    return ImFormatString(buf, buf_size, "???");
 }
 
 // Stack Tool: Display UI
@@ -13036,6 +13079,7 @@ void ImGui::ShowStackToolWindow(bool* p_open)
     }
 
     // Display hovered/active status
+    ImGuiStackTool* tool = &g.DebugStackTool;
     const ImGuiID hovered_id = g.HoveredIdPreviousFrame;
     const ImGuiID active_id = g.ActiveId;
 #ifdef IMGUI_ENABLE_TEST_ENGINE
@@ -13046,8 +13090,33 @@ void ImGui::ShowStackToolWindow(bool* p_open)
     SameLine();
     MetricsHelpMarker("Hover an item with the mouse to display elements of the ID Stack leading to the item's final ID.\nEach level of the stack correspond to a PushID() call.\nAll levels of the stack are hashed together to make the final ID of a widget (ID displayed at the bottom level of the stack).\nRead FAQ entry about the ID stack for details.");
 
+    // CTRL+C to copy path
+    const float time_since_copy = (float)g.Time - tool->CopyToClipboardLastTime;
+    Checkbox("Ctrl+C: copy path to clipboard", &tool->CopyToClipboardOnCtrlC);
+    SameLine();
+    TextColored((time_since_copy >= 0.0f && time_since_copy < 0.75f && ImFmod(time_since_copy, 0.25f) < 0.25f * 0.5f) ? ImVec4(1.f, 1.f, 0.3f, 1.f) : ImVec4(), "*COPIED*");
+    if (tool->CopyToClipboardOnCtrlC && IsKeyDown(ImGuiKey_ModCtrl) && IsKeyPressed(ImGuiKey_C))
+    {
+        tool->CopyToClipboardLastTime = (float)g.Time;
+        char* p = g.TempBuffer;
+        char* p_end = p + IM_ARRAYSIZE(g.TempBuffer);
+        for (int stack_n = 0; stack_n < tool->Results.Size && p + 3 < p_end; stack_n++)
+        {
+            *p++ = '/';
+            char level_desc[256];
+            StackToolFormatLevelInfo(tool, stack_n, false, level_desc, IM_ARRAYSIZE(level_desc));
+            for (int n = 0; level_desc[n] && p + 2 < p_end; n++)
+            {
+                if (level_desc[n] == '/')
+                    *p++ = '\\';
+                *p++ = level_desc[n];
+            }
+        }
+        *p = '\0';
+        SetClipboardText(g.TempBuffer);
+    }
+
     // Display decorated stack
-    ImGuiStackTool* tool = &g.DebugStackTool;
     tool->LastActiveFrame = g.FrameCount;
     if (tool->Results.Size > 0 && BeginTable("##table", 3, ImGuiTableFlags_Borders))
     {
@@ -13061,23 +13130,9 @@ void ImGui::ShowStackToolWindow(bool* p_open)
             ImGuiStackLevelInfo* info = &tool->Results[n];
             TableNextColumn();
             Text("0x%08X", (n > 0) ? tool->Results[n - 1].ID : 0);
-
             TableNextColumn();
-            ImGuiWindow* window = (info->Desc[0] == 0 && n == 0) ? FindWindowByID(info->ID) : NULL;
-            if (window)                                         // Source: window name (because the root ID don't call GetID() and so doesn't get hooked)
-                Text("\"%s\" [window]", window->Name);
-            else if (info->QuerySuccess)                        // Source: GetID() hooks (prioritize over ItemInfo() because we frequently use patterns like: PushID(str), Button("") where they both have same id)
-                TextUnformatted(info->Desc);
-            else if (tool->StackLevel >= tool->Results.Size)    // Only start using fallback below when all queries are done, so during queries we don't flickering ??? markers.
-            {
-#ifdef IMGUI_ENABLE_TEST_ENGINE
-                if (const char* label = ImGuiTestEngine_FindItemDebugLabel(&g, info->ID))    // Source: ImGuiTestEngine's ItemInfo()
-                    Text("??? \"%s\"", label);
-                else
-#endif
-                    TextUnformatted("???");
-            }
-
+            StackToolFormatLevelInfo(tool, n, true, g.TempBuffer, IM_ARRAYSIZE(g.TempBuffer));
+            TextUnformatted(g.TempBuffer);
             TableNextColumn();
             Text("0x%08X", info->ID);
             if (n == tool->Results.Size - 1)

imgui.h

@@ -1,4 +1,4 @@
-// dear imgui, v1.87
+// dear imgui, v1.88 WIP
 // (headers)
 
 // Help:
@@ -64,8 +64,8 @@ Index of this file:
 
 // Version
 // (Integer encoded as XYYZZ for use in #if preprocessor conditionals. Work in progress versions typically starts at XYY99 then bounce up to XYY00, XYY01 etc. when release tagging happens)
-#define IMGUI_VERSION               "1.87"
-#define IMGUI_VERSION_NUM           18700
+#define IMGUI_VERSION               "1.88 WIP"
+#define IMGUI_VERSION_NUM           18704
 #define IMGUI_CHECKVERSION()        ImGui::DebugCheckVersionAndDataLayout(IMGUI_VERSION, sizeof(ImGuiIO), sizeof(ImGuiStyle), sizeof(ImVec2), sizeof(ImVec4), sizeof(ImDrawVert), sizeof(ImDrawIdx))
 #define IMGUI_HAS_TABLE
 
@@ -249,8 +249,8 @@ IM_MSVC_RUNTIME_CHECKS_OFF
 struct ImVec2
 {
     float                                   x, y;
-    ImVec2()                                { x = y = 0.0f; }
-    ImVec2(float _x, float _y)              { x = _x; y = _y; }
+    constexpr ImVec2()                      : x(0.0f), y(0.0f) { }
+    constexpr ImVec2(float _x, float _y)    : x(_x), y(_y) { }
     float  operator[] (size_t idx) const    { IM_ASSERT(idx <= 1); return (&x)[idx]; }    // We very rarely use this [] operator, the assert overhead is fine.
     float& operator[] (size_t idx)          { IM_ASSERT(idx <= 1); return (&x)[idx]; }    // We very rarely use this [] operator, the assert overhead is fine.
 #ifdef IM_VEC2_CLASS_EXTRA
@@ -262,8 +262,8 @@ struct ImVec2
 struct ImVec4
 {
     float                                                     x, y, z, w;
-    ImVec4()                                        { x = y = z = w = 0.0f; }
-    ImVec4(float _x, float _y, float _z, float _w)  { x = _x; y = _y; z = _z; w = _w; }
+    constexpr ImVec4()                                        : x(0.0f), y(0.0f), z(0.0f), w(0.0f) { }
+    constexpr 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     // Define additional constructors and implicit cast operators in imconfig.h to convert back and forth between your math types and ImVec4.
 #endif

imgui_demo.cpp

@@ -1,4 +1,4 @@
-// dear imgui, v1.87
+// dear imgui, v1.88 WIP
 // (demo code)
 
 // Help:

imgui_draw.cpp

@@ -1,4 +1,4 @@
-// dear imgui, v1.87
+// dear imgui, v1.88 WIP
 // (drawing and font code)
 
 /*
@@ -716,7 +716,7 @@ void ImDrawList::PrimQuadUV(const ImVec2& a, const ImVec2& b, const ImVec2& c, c
 #define IM_FIXNORMAL2F_MAX_INVLEN2          100.0f // 500.0f (see #4053, #3366)
 #define IM_FIXNORMAL2F(VX,VY)               { float d2 = VX*VX + VY*VY; if (d2 > 0.000001f) { float inv_len2 = 1.0f / d2; if (inv_len2 > IM_FIXNORMAL2F_MAX_INVLEN2) inv_len2 = IM_FIXNORMAL2F_MAX_INVLEN2; VX *= inv_len2; VY *= inv_len2; } } (void)0
 
-// TODO: Thickness anti-aliased lines cap are missing their AA fringe.
+// FIXME: Thickness anti-aliased lines cap are missing their AA fringe.
 // We avoid using the ImVec2 math operators here to reduce cost to a minimum for debug/non-inlined builds.
 void ImDrawList::AddPolyline(const ImVec2* points, const int points_count, ImU32 col, ImDrawFlags flags, float thickness)
 {
@@ -728,6 +728,264 @@ void ImDrawList::AddPolyline(const ImVec2* points, const int points_count, ImU32
     const int count = closed ? points_count : points_count - 1; // The number of line segments we need to draw
     const bool thick_line = (thickness > _FringeScale);
 
+// (Intentionally incorrect indentation to avoid altering)
+bool USE_NEW_CODE = true;
+//bool USE_NEW_CODE = ImGui::GetIO().KeyShift;
+if (USE_NEW_CODE)
+{
+    const float AA_SIZE = 1.0f;
+    const ImU32 col_trans = col & ~IM_COL32_A_MASK;
+    const bool antialias = (Flags & ImDrawListFlags_AntiAliasedLines) != 0;
+
+    if (antialias && !thick_line)
+    {
+        // Anti-aliased stroke approximation
+        const int idx_count = count * 12;
+        const int vtx_count = count * 6;      // FIXME-OPT: Not sharing edges
+        PrimReserve(idx_count, vtx_count);
+        ImU32 col_faded = col;
+        if (thickness < 1.0f)
+            col_faded = col_trans | ((int)(((col >> IM_COL32_A_SHIFT) & 0xFF) * thickness) << IM_COL32_A_SHIFT);
+
+        for (int i1 = 0; i1 < count; i1++)
+        {
+            const int i2 = (i1 + 1) == points_count ? 0 : i1 + 1;
+            const ImVec2& p1 = points[i1];
+            const ImVec2& p2 = points[i2];
+
+            float dx = p2.x - p1.x;
+            float dy = p2.y - p1.y;
+            IM_NORMALIZE2F_OVER_ZERO(dx, dy);
+            dx *= AA_SIZE;
+            dy *= AA_SIZE;
+
+            _VtxWritePtr[0].pos.x = p1.x + dy; _VtxWritePtr[0].pos.y = p1.y - dx; _VtxWritePtr[0].uv = opaque_uv; _VtxWritePtr[0].col = col_trans;
+            _VtxWritePtr[1].pos.x = p1.x;      _VtxWritePtr[1].pos.y = p1.y;      _VtxWritePtr[1].uv = opaque_uv; _VtxWritePtr[1].col = col_faded;
+            _VtxWritePtr[2].pos.x = p1.x - dy; _VtxWritePtr[2].pos.y = p1.y + dx; _VtxWritePtr[2].uv = opaque_uv; _VtxWritePtr[2].col = col_trans;
+
+            _VtxWritePtr[3].pos.x = p2.x + dy; _VtxWritePtr[3].pos.y = p2.y - dx; _VtxWritePtr[3].uv = opaque_uv; _VtxWritePtr[3].col = col_trans;
+            _VtxWritePtr[4].pos.x = p2.x;      _VtxWritePtr[4].pos.y = p2.y;      _VtxWritePtr[4].uv = opaque_uv; _VtxWritePtr[4].col = col_faded;
+            _VtxWritePtr[5].pos.x = p2.x - dy; _VtxWritePtr[5].pos.y = p2.y + dx; _VtxWritePtr[5].uv = opaque_uv; _VtxWritePtr[5].col = col_trans;
+            _VtxWritePtr += 6;
+
+            _IdxWritePtr[0] = (ImDrawIdx)(_VtxCurrentIdx);     _IdxWritePtr[1] = (ImDrawIdx)(_VtxCurrentIdx + 1); _IdxWritePtr[2] = (ImDrawIdx)(_VtxCurrentIdx + 4);
+            _IdxWritePtr[3] = (ImDrawIdx)(_VtxCurrentIdx);     _IdxWritePtr[4] = (ImDrawIdx)(_VtxCurrentIdx + 4); _IdxWritePtr[5] = (ImDrawIdx)(_VtxCurrentIdx + 3);
+            _IdxWritePtr[6] = (ImDrawIdx)(_VtxCurrentIdx + 1); _IdxWritePtr[7] = (ImDrawIdx)(_VtxCurrentIdx + 2); _IdxWritePtr[8] = (ImDrawIdx)(_VtxCurrentIdx + 5);
+            _IdxWritePtr[9] = (ImDrawIdx)(_VtxCurrentIdx + 1); _IdxWritePtr[10]= (ImDrawIdx)(_VtxCurrentIdx + 5); _IdxWritePtr[11]= (ImDrawIdx)(_VtxCurrentIdx + 4);
+            _IdxWritePtr += 12;
+            _VtxCurrentIdx += 6;
+        }
+    }
+    else
+    {
+        // Precise line with bevels on acute angles
+        const int max_n_vtx = antialias ? 6 : 3;
+        const int max_n_idx = 3 * (antialias ? 9 : 3);
+        const int vtx_count = points_count * max_n_vtx;
+        const int idx_count = count * max_n_idx;
+        PrimReserve(idx_count, vtx_count);
+
+        const float half_thickness = (antialias ? thickness - AA_SIZE : thickness) * 0.5f;
+        const float half_thickness_aa = half_thickness + AA_SIZE;
+        const unsigned int first_vtx_idx = _VtxCurrentIdx;
+
+        // Declare temporary variables in outer scope. Declared without a default value would trigger static analyser, and doing it in inner-scope would be more wasteful.
+        float mlx, mly, mrx, mry;                                   // Left and right miters
+        float mlax = 0.0f, mlay = 0.0f, mrax = 0.0f, mray = 0.0f;   // Left and right miters including anti-aliasing
+        float b1x = 0.0f, b1y = 0.0f, b2x = 0.0f, b2y = 0.0f;       // First and second bevel point
+        float b1ax = 0.0f, b1ay = 0.0f, b2ax = 0.0f, b2ay = 0.0f;   // First and second bevel point including anti-aliasing
+
+        float sqlen1 = 0.0f;
+        float dx1 = 0.0f, dy1 = 0.0f;
+        if (closed)
+        {
+            dx1 = points[0].x - points[points_count - 1].x;
+            dy1 = points[0].y - points[points_count - 1].y;
+            sqlen1 = dx1 * dx1 + dy1 * dy1;
+            IM_NORMALIZE2F_OVER_ZERO(dx1, dy1);
+        }
+
+        for (int i1 = 0; i1 < points_count; i1++)
+        {
+            const int i2 = (i1 + 1 == points_count) ? 0 : i1 + 1;
+            const ImVec2& p1 = points[i1];
+            const ImVec2& p2 = points[i2];
+            float dx2 = p1.x - p2.x;
+            float dy2 = p1.y - p2.y;
+            float sqlen2 = dx2 * dx2 + dy2 * dy2;
+            IM_NORMALIZE2F_OVER_ZERO(dx2, dy2);
+
+            if (!closed && i1 == 0)
+            {
+                dx1 = -dx2;
+                dy1 = -dy2;
+                sqlen1 = sqlen2;
+            }
+            else if (!closed && i1 == points_count - 1)
+            {
+                dx2 = -dx1;
+                dy2 = -dy1;
+                sqlen2 = sqlen1;
+            }
+
+            float miter_l_recip = dx1 * dy2 - dy1 * dx2;
+            const bool bevel = (dx1 * dx2 + dy1 * dy2) > 1e-5f;
+            if (ImFabs(miter_l_recip) > 1e-5f)
+            {
+                float miter_l = half_thickness / miter_l_recip;
+                // Limit (inner) miter so it doesn't shoot away when miter is longer than adjacent line segments on acute angles
+                if (bevel)
+                {
+                    // This is too aggressive (not exactly precise)
+                    float min_sqlen = sqlen1 > sqlen2 ? sqlen2 : sqlen1;
+                    float miter_sqlen = ((dx1 + dx2) * (dx1 + dx2) + (dy1 + dy2) * (dy1 + dy2)) * miter_l * miter_l;
+                    if (miter_sqlen > min_sqlen)
+                        miter_l *= ImSqrt(min_sqlen / miter_sqlen);
+                }
+                mlx = p1.x - (dx1 + dx2) * miter_l;
+                mly = p1.y - (dy1 + dy2) * miter_l;
+                mrx = p1.x + (dx1 + dx2) * miter_l;
+                mry = p1.y + (dy1 + dy2) * miter_l;
+                if (antialias)
+                {
+                    float miter_al = half_thickness_aa / miter_l_recip;
+                    mlax = p1.x - (dx1 + dx2) * miter_al;
+                    mlay = p1.y - (dy1 + dy2) * miter_al;
+                    mrax = p1.x + (dx1 + dx2) * miter_al;
+                    mray = p1.y + (dy1 + dy2) * miter_al;
+                }
+            }
+            else
+            {
+                // Avoid degeneracy for (nearly) straight lines
+                mlx = p1.x + dy1 * half_thickness;
+                mly = p1.y - dx1 * half_thickness;
+                mrx = p1.x - dy1 * half_thickness;
+                mry = p1.y + dx1 * half_thickness;
+                if (antialias)
+                {
+                    mlax = p1.x + dy1 * half_thickness_aa;
+                    mlay = p1.y - dx1 * half_thickness_aa;
+                    mrax = p1.x - dy1 * half_thickness_aa;
+                    mray = p1.y + dx1 * half_thickness_aa;
+                }
+            }
+            // The two bevel vertices if the angle is right or obtuse
+            // miter_sign == 1, iff the outer (maybe bevelled) edge is on the right, -1 iff it is on the left
+            int miter_sign = (miter_l_recip >= 0) - (miter_l_recip < 0);
+            if (bevel)
+            {
+                // FIXME-OPT: benchmark if doing these computations only once in AA case saves cycles
+                b1x = p1.x + (dx1 - dy1 * miter_sign) * half_thickness;
+                b1y = p1.y + (dy1 + dx1 * miter_sign) * half_thickness;
+                b2x = p1.x + (dx2 + dy2 * miter_sign) * half_thickness;
+                b2y = p1.y + (dy2 - dx2 * miter_sign) * half_thickness;
+                if (antialias)
+                {
+                    b1ax = p1.x + (dx1 - dy1 * miter_sign) * half_thickness_aa;
+                    b1ay = p1.y + (dy1 + dx1 * miter_sign) * half_thickness_aa;
+                    b2ax = p1.x + (dx2 + dy2 * miter_sign) * half_thickness_aa;
+                    b2ay = p1.y + (dy2 - dx2 * miter_sign) * half_thickness_aa;
+                }
+            }
+
+            // Set the previous line direction so it doesn't need to be recomputed
+            dx1 = -dx2;
+            dy1 = -dy2;
+            sqlen1 = sqlen2;
+
+            // Now that we have all the point coordinates, put them into buffers
+
+            // Vertices for each point are ordered in vertex buffer like this (looking in the direction of the polyline):
+            // - left vertex*
+            // - right vertex*
+            // - left vertex AA fringe*  (if antialias)
+            // - right vertex AA fringe* (if antialias)
+            // - the remaining vertex (if bevel)
+            // - the remaining vertex AA fringe (if bevel and antialias)
+            // (*) if there is bevel, these vertices are the ones on the incoming edge.
+            // Having all the vertices of the incoming edge in predictable positions is important - we reference them
+            // even if we don't know relevant line properties yet
+
+            const int vertex_count = antialias ? (bevel ? 6 : 4) : (bevel ? 3 : 2); // FIXME: shorten the expression
+            const unsigned int bi = antialias ? 4 : 2; // Outgoing edge bevel vertex index
+            const bool bevel_l = bevel && miter_sign < 0;
+            const bool bevel_r = bevel && miter_sign > 0;
+
+            _VtxWritePtr[0].pos.x = bevel_l ? b1x : mlx; _VtxWritePtr[0].pos.y = bevel_l ? b1y : mly; _VtxWritePtr[0].uv = opaque_uv; _VtxWritePtr[0].col = col;
+            _VtxWritePtr[1].pos.x = bevel_r ? b1x : mrx; _VtxWritePtr[1].pos.y = bevel_r ? b1y : mry; _VtxWritePtr[1].uv = opaque_uv; _VtxWritePtr[1].col = col;
+            if (bevel)
+            {
+                _VtxWritePtr[bi].pos.x = b2x; _VtxWritePtr[bi].pos.y = b2y; _VtxWritePtr[bi].uv = opaque_uv; _VtxWritePtr[bi].col = col;
+            }
+
+            if (antialias)
+            {
+                _VtxWritePtr[2].pos.x = bevel_l ? b1ax : mlax; _VtxWritePtr[2].pos.y = bevel_l ? b1ay : mlay; _VtxWritePtr[2].uv = opaque_uv; _VtxWritePtr[2].col = col_trans;
+                _VtxWritePtr[3].pos.x = bevel_r ? b1ax : mrax; _VtxWritePtr[3].pos.y = bevel_r ? b1ay : mray; _VtxWritePtr[3].uv = opaque_uv; _VtxWritePtr[3].col = col_trans;
+                if (bevel)
+                {
+                    _VtxWritePtr[5].pos.x = b2ax; _VtxWritePtr[5].pos.y = b2ay; _VtxWritePtr[5].uv = opaque_uv; _VtxWritePtr[5].col = col_trans;
+                }
+            }
+            _VtxWritePtr += vertex_count;
+
+            if (i1 < count)
+            {
+                const int vtx_next_id = i1 < points_count - 1 ? _VtxCurrentIdx + vertex_count : first_vtx_idx;
+                unsigned int l1i = _VtxCurrentIdx + (bevel_l ? bi : 0);
+                unsigned int r1i = _VtxCurrentIdx + (bevel_r ? bi : 1);
+                unsigned int l2i = vtx_next_id;
+                unsigned int r2i = vtx_next_id + 1;
+                unsigned int ebi = _VtxCurrentIdx + (bevel_l ? 0 : 1); // incoming edge bevel vertex index
+
+                _IdxWritePtr[0] = (ImDrawIdx)l1i; _IdxWritePtr[1] = (ImDrawIdx)r1i; _IdxWritePtr[2] = (ImDrawIdx)r2i;
+                _IdxWritePtr[3] = (ImDrawIdx)l1i; _IdxWritePtr[4] = (ImDrawIdx)r2i; _IdxWritePtr[5] = (ImDrawIdx)l2i;
+                _IdxWritePtr += 6;
+
+                if (bevel)
+                {
+                    _IdxWritePtr[0] = (ImDrawIdx)l1i; _IdxWritePtr[1] = (ImDrawIdx)r1i; _IdxWritePtr[2] = (ImDrawIdx)ebi;
+                    _IdxWritePtr += 3;
+                }
+
+                if (antialias)
+                {
+                    unsigned int l1ai = _VtxCurrentIdx + (bevel_l ? 5 : 2);
+                    unsigned int r1ai = _VtxCurrentIdx + (bevel_r ? 5 : 3);
+                    unsigned int l2ai = vtx_next_id + 2;
+                    unsigned int r2ai = vtx_next_id + 3;
+
+                    _IdxWritePtr[0] = (ImDrawIdx)l1ai; _IdxWritePtr[1] = (ImDrawIdx)l1i; _IdxWritePtr[2] = (ImDrawIdx)l2i;
+                    _IdxWritePtr[3] = (ImDrawIdx)l1ai; _IdxWritePtr[4] = (ImDrawIdx)l2i; _IdxWritePtr[5] = (ImDrawIdx)l2ai;
+                    _IdxWritePtr[6] = (ImDrawIdx)r1ai; _IdxWritePtr[7] = (ImDrawIdx)r1i; _IdxWritePtr[8] = (ImDrawIdx)r2i;
+                    _IdxWritePtr[9] = (ImDrawIdx)r1ai; _IdxWritePtr[10] = (ImDrawIdx)r2i; _IdxWritePtr[11] = (ImDrawIdx)r2ai;
+                    _IdxWritePtr += 12;
+
+                    if (bevel)
+                    {
+                        _IdxWritePtr[0] = (ImDrawIdx)(_VtxCurrentIdx + (bevel_r ? 1 : 2));
+                        _IdxWritePtr[1] = (ImDrawIdx)(_VtxCurrentIdx + (bevel_r ? 3 : 0));
+                        _IdxWritePtr[2] = (ImDrawIdx)(_VtxCurrentIdx + (bevel_r ? 5 : 4));
+
+                        _IdxWritePtr[3] = (ImDrawIdx)(_VtxCurrentIdx + (bevel_r ? 1 : 2));
+                        _IdxWritePtr[4] = (ImDrawIdx)(_VtxCurrentIdx + (bevel_r ? 5 : 4));
+                        _IdxWritePtr[5] = (ImDrawIdx)(_VtxCurrentIdx + (bevel_r ? 4 : 5));
+                        _IdxWritePtr += 6;
+                    }
+                }
+            }
+            _VtxCurrentIdx += vertex_count;
+        }
+
+        const int unused_indices = (int)(IdxBuffer.Data + IdxBuffer.Size - _IdxWritePtr);
+        const int unused_vertices = (int)(VtxBuffer.Size - _VtxCurrentIdx - _CmdHeader.VtxOffset);
+        if (unused_indices > 0 || unused_vertices > 0)
+            PrimUnreserve(unused_indices, unused_vertices);
+    }
+}
+else
+{
     if (Flags & ImDrawListFlags_AntiAliasedLines)
     {
         // Anti-aliased stroke
@@ -972,6 +1230,7 @@ void ImDrawList::AddPolyline(const ImVec2* points, const int points_count, ImU32
         }
     }
 }
+}
 
 // We intentionally avoid using ImVec2 and its math operators here to reduce cost to a minimum for debug/non-inlined builds.
 void ImDrawList::AddConvexPolyFilled(const ImVec2* points, const int points_count, ImU32 col)
@@ -1206,8 +1465,8 @@ void ImDrawList::PathArcTo(const ImVec2& center, float radius, float a_min, floa
 
         const float a_min_segment_angle = a_min_sample * IM_PI * 2.0f / IM_DRAWLIST_ARCFAST_SAMPLE_MAX;
         const float a_max_segment_angle = a_max_sample * IM_PI * 2.0f / IM_DRAWLIST_ARCFAST_SAMPLE_MAX;
-        const bool a_emit_start = (a_min_segment_angle - a_min) != 0.0f;
-        const bool a_emit_end = (a_max - a_max_segment_angle) != 0.0f;
+        const bool a_emit_start = ImAbs(a_min_segment_angle - a_min) >= 1e-5f;
+        const bool a_emit_end = ImAbs(a_max - a_max_segment_angle) >= 1e-5f;
 
         _Path.reserve(_Path.Size + (a_mid_samples + 1 + (a_emit_start ? 1 : 0) + (a_emit_end ? 1 : 0)));
         if (a_emit_start)
@@ -3736,7 +3995,6 @@ void ImFont::RenderText(ImDrawList* draw_list, float size, ImVec2 pos, ImU32 col
 // - RenderArrow()
 // - RenderBullet()
 // - RenderCheckMark()
-// - RenderMouseCursor()
 // - RenderArrowPointingAt()
 // - RenderRectFilledRangeH()
 // - RenderRectFilledWithHole()
@@ -3797,27 +4055,6 @@ void ImGui::RenderCheckMark(ImDrawList* draw_list, ImVec2 pos, ImU32 col, float
     draw_list->PathStroke(col, 0, thickness);
 }
 
-void ImGui::RenderMouseCursor(ImDrawList* draw_list, ImVec2 pos, float scale, ImGuiMouseCursor mouse_cursor, ImU32 col_fill, ImU32 col_border, ImU32 col_shadow)
-{
-    if (mouse_cursor == ImGuiMouseCursor_None)
-        return;
-    IM_ASSERT(mouse_cursor > ImGuiMouseCursor_None && mouse_cursor < ImGuiMouseCursor_COUNT);
-
-    ImFontAtlas* font_atlas = draw_list->_Data->Font->ContainerAtlas;
-    ImVec2 offset, size, uv[4];
-    if (font_atlas->GetMouseCursorTexData(mouse_cursor, &offset, &size, &uv[0], &uv[2]))
-    {
-        pos -= offset;
-        ImTextureID tex_id = font_atlas->TexID;
-        draw_list->PushTextureID(tex_id);
-        draw_list->AddImage(tex_id, pos + ImVec2(1, 0) * scale, pos + (ImVec2(1, 0) + size) * scale,    uv[2], uv[3], col_shadow);
-        draw_list->AddImage(tex_id, pos + ImVec2(2, 0) * scale, pos + (ImVec2(2, 0) + size) * scale,    uv[2], uv[3], col_shadow);
-        draw_list->AddImage(tex_id, pos,                        pos + size * scale,                     uv[2], uv[3], col_border);
-        draw_list->AddImage(tex_id, pos,                        pos + size * scale,                     uv[0], uv[1], col_fill);
-        draw_list->PopTextureID();
-    }
-}
-
 // Render an arrow. 'pos' is position of the arrow tip. half_sz.x is length from base to tip. half_sz.y is length on each side.
 void ImGui::RenderArrowPointingAt(ImDrawList* draw_list, ImVec2 pos, ImVec2 half_sz, ImGuiDir direction, ImU32 col)
 {

imgui_internal.h

@@ -1,4 +1,4 @@
-// dear imgui, v1.87
+// dear imgui, v1.88 WIP
 // (internal structures/api)
 
 // You may use this file to debug, understand or extend ImGui features but we don't provide any guarantee of forward compatibility!
@@ -469,17 +469,17 @@ IM_MSVC_RUNTIME_CHECKS_OFF
 struct ImVec1
 {
     float   x;
-    ImVec1()         { x = 0.0f; }
-    ImVec1(float _x) { x = _x; }
+    constexpr ImVec1()         : x(0.0f) { }
+    constexpr ImVec1(float _x) : x(_x) { }
 };
 
 // Helper: ImVec2ih (2D vector, half-size integer, for long-term packed storage)
 struct ImVec2ih
 {
     short   x, y;
-    ImVec2ih()                           { x = y = 0; }
-    ImVec2ih(short _x, short _y)         { x = _x; y = _y; }
-    explicit ImVec2ih(const ImVec2& rhs) { x = (short)rhs.x; y = (short)rhs.y; }
+    constexpr ImVec2ih()                           : x(0), y(0) {}
+    constexpr ImVec2ih(short _x, short _y)         : x(_x), y(_y) {}
+    constexpr explicit ImVec2ih(const ImVec2& rhs) : x((short)rhs.x), y((short)rhs.y) {}
 };
 
 // Helper: ImRect (2D axis aligned bounding-box)
@@ -489,10 +489,10 @@ struct IMGUI_API ImRect
     ImVec2      Min;    // Upper-left
     ImVec2      Max;    // Lower-right
 
-    ImRect()                                        : Min(0.0f, 0.0f), Max(0.0f, 0.0f)  {}
-    ImRect(const ImVec2& min, const ImVec2& max)    : Min(min), Max(max)                {}
-    ImRect(const ImVec4& v)                         : Min(v.x, v.y), Max(v.z, v.w)      {}
-    ImRect(float x1, float y1, float x2, float y2)  : Min(x1, y1), Max(x2, y2)          {}
+    constexpr ImRect()                                        : Min(0.0f, 0.0f), Max(0.0f, 0.0f)  {}
+    constexpr ImRect(const ImVec2& min, const ImVec2& max)    : Min(min), Max(max)                {}
+    constexpr ImRect(const ImVec4& v)                         : Min(v.x, v.y), Max(v.z, v.w)      {}
+    constexpr ImRect(float x1, float y1, float x2, float y2)  : Min(x1, y1), Max(x2, y2)          {}
 
     ImVec2      GetCenter() const                   { return ImVec2((Min.x + Max.x) * 0.5f, (Min.y + Max.y) * 0.5f); }
     ImVec2      GetSize() const                     { return ImVec2(Max.x - Min.x, Max.y - Min.y); }
@@ -1171,7 +1171,7 @@ enum ImGuiInputEventType
     ImGuiInputEventType_MouseWheel,
     ImGuiInputEventType_MouseButton,
     ImGuiInputEventType_Key,
-    ImGuiInputEventType_Char,
+    ImGuiInputEventType_Text,
     ImGuiInputEventType_Focus,
     ImGuiInputEventType_COUNT
 };
@@ -1510,7 +1510,8 @@ struct ImGuiStackLevelInfo
     ImGuiID                 ID;
     ImS8                    QueryFrameCount;            // >= 1: Query in progress
     bool                    QuerySuccess;               // Obtained result from DebugHookIdInfo()
-    char                    Desc[58];                   // Arbitrarily sized buffer to hold a result (FIXME: could replace Results[] with a chunk stream?)
+    ImGuiDataType           DataType : 8;
+    char                    Desc[57];                   // Arbitrarily sized buffer to hold a result (FIXME: could replace Results[] with a chunk stream?) FIXME: Now that we added CTRL+C this should be fixed.
 
     ImGuiStackLevelInfo()   { memset(this, 0, sizeof(*this)); }
 };
@@ -1522,8 +1523,10 @@ struct ImGuiStackTool
     int                     StackLevel;                 // -1: query stack and resize Results, >= 0: individual stack level
     ImGuiID                 QueryId;                    // ID to query details for
     ImVector<ImGuiStackLevelInfo> Results;
+    bool                    CopyToClipboardOnCtrlC;
+    float                   CopyToClipboardLastTime;
 
-    ImGuiStackTool()        { memset(this, 0, sizeof(*this)); }
+    ImGuiStackTool()        { memset(this, 0, sizeof(*this)); CopyToClipboardLastTime = -FLT_MAX; }
 };
 
 //-----------------------------------------------------------------------------
@@ -2760,12 +2763,12 @@ namespace ImGui
     IMGUI_API void          RenderColorRectWithAlphaCheckerboard(ImDrawList* draw_list, ImVec2 p_min, ImVec2 p_max, ImU32 fill_col, float grid_step, ImVec2 grid_off, float rounding = 0.0f, ImDrawFlags flags = 0);
     IMGUI_API void          RenderNavHighlight(const ImRect& bb, ImGuiID id, ImGuiNavHighlightFlags flags = ImGuiNavHighlightFlags_TypeDefault); // Navigation highlight
     IMGUI_API const char*   FindRenderedTextEnd(const char* text, const char* text_end = NULL); // Find the optional ## from which we stop displaying text.
+    IMGUI_API void          RenderMouseCursor(ImVec2 pos, float scale, ImGuiMouseCursor mouse_cursor, ImU32 col_fill, ImU32 col_border, ImU32 col_shadow);
 
     // Render helpers (those functions don't access any ImGui state!)
     IMGUI_API void          RenderArrow(ImDrawList* draw_list, ImVec2 pos, ImU32 col, ImGuiDir dir, float scale = 1.0f);
     IMGUI_API void          RenderBullet(ImDrawList* draw_list, ImVec2 pos, ImU32 col);
     IMGUI_API void          RenderCheckMark(ImDrawList* draw_list, ImVec2 pos, ImU32 col, float sz);
-    IMGUI_API void          RenderMouseCursor(ImDrawList* draw_list, ImVec2 pos, float scale, ImGuiMouseCursor mouse_cursor, ImU32 col_fill, ImU32 col_border, ImU32 col_shadow);
     IMGUI_API void          RenderArrowPointingAt(ImDrawList* draw_list, ImVec2 pos, ImVec2 half_sz, ImGuiDir direction, ImU32 col);
     IMGUI_API void          RenderRectFilledRangeH(ImDrawList* draw_list, const ImRect& rect, ImU32 col, float x_start_norm, float x_end_norm, float rounding);
     IMGUI_API void          RenderRectFilledWithHole(ImDrawList* draw_list, ImRect outer, ImRect inner, ImU32 col, float rounding);

imgui_tables.cpp

@@ -1,4 +1,4 @@
-// dear imgui, v1.87
+// dear imgui, v1.88 WIP
 // (tables and columns code)
 
 /*

imgui_widgets.cpp

@@ -1,4 +1,4 @@
-// dear imgui, v1.87
+// dear imgui, v1.88 WIP
 // (widgets code)
 
 /*
@@ -82,6 +82,7 @@ Index of this file:
 #pragma GCC diagnostic ignored "-Wpragmas"                          // warning: unknown option after '#pragma GCC diagnostic' kind
 #pragma GCC diagnostic ignored "-Wformat-nonliteral"                // warning: format not a string literal, format string not checked
 #pragma GCC diagnostic ignored "-Wclass-memaccess"                  // [__GNUC__ >= 8] warning: 'memset/memcpy' clearing/writing an object of type 'xxxx' with no trivial copy-assignment; use assignment or value-initialization instead
+#pragma GCC diagnostic ignored "-Wdeprecated-enum-enum-conversion"  // warning: bitwise operation between different enumeration types ('XXXFlags_' and 'XXXFlagsPrivate_') is deprecated
 #endif
 
 //-------------------------------------------------------------------------