Update ImGui to v1.92.1.

Author: stripe2933

extlibs/module-ports/imgui/imgui.cppm

@@ -1,5 +1,6 @@
 module;
 
+#define IMGUI_DISABLE_OBSOLETE_FUNCTIONS
 #include <imgui.h>
 
 export module imgui;
@@ -46,6 +47,7 @@ export using ::ImGuiTreeNodeFlags_SpanAllColumns;
 export using ::ImGuiTreeNodeFlags_Selected;
 export using ::ImGuiWindowFlags_AlwaysAutoResize;
 export using ::ImTextureID;
+export using ::ImTextureRef;
 export using ::ImU32;
 export using ::ImVec2;
 export using ::ImVec4;
@@ -54,7 +56,7 @@ export using ::ImWchar;
 
 #ifdef IMGUI_HAS_DOCK
 export using ::ImGuiConfigFlags_DockingEnable;
-export using ::ImGuiDockNodeFlags_NoDockingInCentralNode;
+export using ::ImGuiDockNodeFlags_NoDockingOverCentralNode;
 #endif
 
 namespace ImGui {

extlibs/module-ports/imgui/imgui.internal.cppm

@@ -10,7 +10,6 @@ export using ::ImGuiInputTextFlags_CallbackResize;
 export using ::ImGuiItemFlags_MixedValue;
 export using ::ImGuiSettingsHandler;
 export using ::ImGuiTextBuffer;
-export using ::ImGuiTreeNodeFlags_DrawTreeLines;
 export using ::ImGuiWindow;
 export using ::ImHashStr;
 export using ::ImRect;

impl/MainApp.cpp

@@ -162,6 +162,32 @@ void vk_gltf_viewer::MainApp::run() {
 
     std::array<bool, FRAMES_IN_FLIGHT> regenerateDrawCommands{};
 
+    // Current application running loop flow is like:
+    //
+    // while (application is running) {
+    //    waitForPreviousFrameGpuExecution();
+    //
+    //    // Collect frame tasks.
+    //    pollEvents(); // <- Collect task from window events (mouse, keyboard, drag and drop, ...).
+    //    imGuiFuncs(); // <- Collect task from GUI input (buton click, ...).
+    //
+    //    processFrameTasks();
+    //
+    //    recordCommandBuffers(); // Will call ImGui_ImplVulkan_RenderDrawData().
+    //    submitCommandBuffers();
+    //    presentFrame();
+    // }
+    //
+    // The problem is: changing glTF asset may be requested via ImGui menu click, and the previous asset will be
+    // destroyed in processFrameTasks() function. But, imGuiFuncs() was already executed, and it will store the
+    // ImTextureID (=VkDescriptorSet) in its internal state. Then recordCommandBuffers() will try to use the already
+    // destroyed texture.
+    //
+    // To work-around, before destroying the previously loaded asset, its ownership is shared to
+    // retainedAssetExtended[frameIndex % FRAMES_IN_FLIGHT], to prevent the asset is completely destroyed. The asset
+    // will be retained during its frame execution, and should be destroyed after the frame execution is completed.
+    std::array<std::shared_ptr<const gltf::AssetExtended>, FRAMES_IN_FLIGHT> retainedAssetExtended;
+
     // TODO: we need more general mechanism to upload the GPU buffer data in shared data. This is just a stopgap solution
     //  for current KHR_materials_variants implementation.
     const vk::raii::CommandPool graphicsCommandPool { gpu.device, vk::CommandPoolCreateInfo { {}, gpu.queueFamilies.graphicsPresent } };
@@ -265,6 +291,12 @@ void vk_gltf_viewer::MainApp::run() {
             }
         }
 
+        if (auto &retained = retainedAssetExtended[frameIndex % FRAMES_IN_FLIGHT]) {
+            // The previous execution of the frame requested destroying the asset, and now the request can be done
+            // (as ImGui will not refer its texture).
+            retained.reset();
+        }
+
         graphicsCommandPool.reset();
         sharedDataUpdateCommandBuffer.begin({ vk::CommandBufferUsageFlagBits::eOneTimeSubmit });
 
@@ -420,6 +452,8 @@ void vk_gltf_viewer::MainApp::run() {
                     frameDeferredTask.setPassthruExtent(extent);
                 },
                 [&](const control::task::LoadGltf &task) {
+                    retainedAssetExtended[frameIndex % FRAMES_IN_FLIGHT] = assetExtended;
+
                     loadGltf(task.path);
 
                     // All planned updates related to the previous glTF asset have to be canceled.
@@ -430,6 +464,8 @@ void vk_gltf_viewer::MainApp::run() {
                     regenerateDrawCommands.fill(true);
                 },
                 [&](control::task::CloseGltf) {
+                    retainedAssetExtended[frameIndex % FRAMES_IN_FLIGHT] = assetExtended;
+
                     closeGltf();
 
                     // All planned updates related to the previous glTF asset have to be canceled.
@@ -769,16 +805,13 @@ vk_gltf_viewer::MainApp::ImGuiContext::ImGuiContext(const control::AppWindow &wi
     ImGui::CheckVersion();
     ImGui::CreateContext();
 
-    ImGuiIO &io = ImGui::GetIO();
-    const glm::vec2 contentScale = window.getContentScale();
-    io.DisplayFramebufferScale = { contentScale.x, contentScale.y };
-#if __APPLE__
-    io.FontGlobalScale = 1.f / io.DisplayFramebufferScale.x;
-#endif
+    ImGuiIO &io = ImGui::GetIO();    
     io.ConfigFlags |= ImGuiConfigFlags_DockingEnable;
 
     ImFontConfig fontConfig;
-    fontConfig.SizePixels = 16.f * io.DisplayFramebufferScale.x;
+    const glm::vec2 contentScaleXY = window.getContentScale();
+	const float contentScale = std::sqrt(contentScaleXY.x * contentScaleXY.y);
+    fontConfig.SizePixels = 16.f * contentScale;
 
     const char *defaultFontPath =
 #ifdef _WIN32
@@ -791,7 +824,7 @@ vk_gltf_viewer::MainApp::ImGuiContext::ImGuiContext(const control::AppWindow &wi
 #error "Type your own font file in here!"
 #endif
     if (std::filesystem::exists(defaultFontPath)) {
-        io.Fonts->AddFontFromFileTTF(defaultFontPath, 16.f * io.DisplayFramebufferScale.x);
+        io.Fonts->AddFontFromFileTTF(defaultFontPath, 16.f * contentScale);
     }
     else {
         std::println(std::cerr, "Your system doesn't have expected system font at {}. Low-resolution font will be used instead.", defaultFontPath);
@@ -804,8 +837,6 @@ vk_gltf_viewer::MainApp::ImGuiContext::ImGuiContext(const control::AppWindow &wi
         asset::font::fontawesome_webfont_ttf_compressed_data_base85,
         fontConfig.SizePixels, &fontConfig, fontAwesomeIconRanges);
 
-    io.Fonts->Build();
-
     ImGui_ImplGlfw_InitForVulkan(window, true);
     const vk::Format colorAttachmentFormat = gpu.supportSwapchainMutableFormat ? vk::Format::eB8G8R8A8Unorm : vk::Format::eB8G8R8A8Srgb;
     ImGui_ImplVulkan_InitInfo initInfo {

impl/control/ImGuiTaskCollector.cpp

@@ -123,9 +123,9 @@ void makeWindowVisible(const char* window_name) {
     }
 }
 
-void hoverableImage(ImTextureID texture, const ImVec2 &size) {
+void hoverableImage(ImTextureRef tex_ref, const ImVec2 &size) {
     const ImVec2 texturePosition = ImGui::GetCursorScreenPos();
-    ImGui::Image(texture, size);
+    ImGui::Image(tex_ref, size);
 
     if (ImGui::BeginItemTooltip()) {
         const ImGuiIO &io = ImGui::GetIO();
@@ -136,16 +136,16 @@ void hoverableImage(ImTextureID texture, const ImVec2 &size) {
         region.y = std::clamp(region.y, 0.f, size.y - zoomedPortionSize.y);
 
         constexpr float zoomScale = 4.0f;
-        ImGui::Image(texture, zoomedPortionSize * zoomScale, region / size, (region + zoomedPortionSize) / size);
+        ImGui::Image(tex_ref, zoomedPortionSize * zoomScale, region / size, (region + zoomedPortionSize) / size);
         ImGui::TextUnformatted(tempStringBuffer.write("Showing: [{:.0f}, {:.0f}]x[{:.0f}, {:.0f}]", region.x, region.y, region.x + zoomedPortionSize.y, region.y + zoomedPortionSize.y));
 
         ImGui::EndTooltip();
     }
 }
 
-void hoverableImageCheckerboardBackground(ImTextureID texture, const ImVec2 &size) {
+void hoverableImageCheckerboardBackground(ImTextureRef texture_ref, const ImVec2 &size) {
     const ImVec2 texturePosition = ImGui::GetCursorScreenPos();
-    ImGui::ImageCheckerboardBackground(texture, size);
+    ImGui::ImageCheckerboardBackground(texture_ref, size);
 
     if (ImGui::BeginItemTooltip()) {
         const ImGuiIO &io = ImGui::GetIO();
@@ -156,7 +156,7 @@ void hoverableImageCheckerboardBackground(ImTextureID texture, const ImVec2 &siz
         region.y = std::clamp(region.y, 0.f, size.y - zoomedPortionSize.y);
 
         constexpr float zoomScale = 4.0f;
-        ImGui::ImageCheckerboardBackground(texture, zoomedPortionSize * zoomScale, region / size, (region + zoomedPortionSize) / size);
+        ImGui::ImageCheckerboardBackground(texture_ref, zoomedPortionSize * zoomScale, region / size, (region + zoomedPortionSize) / size);
         ImGui::TextUnformatted(tempStringBuffer.write("Showing: [{:.0f}, {:.0f}]x[{:.0f}, {:.0f}]", region.x, region.y, region.x + zoomedPortionSize.y, region.y + zoomedPortionSize.y));
 
         ImGui::EndTooltip();
@@ -301,7 +301,7 @@ vk_gltf_viewer::control::ImGuiTaskCollector::ImGuiTaskCollector(std::queue<Task>
     ImGui::NewFrame();
 
     // Enable global docking.
-    ImGuiID dockSpace = ImGui::DockSpaceOverViewport(0, nullptr, ImGuiDockNodeFlags_NoDockingInCentralNode | ImGuiDockNodeFlags_PassthruCentralNode);
+    ImGuiID dockSpace = ImGui::DockSpaceOverViewport(0, nullptr, ImGuiDockNodeFlags_NoDockingOverCentralNode | ImGuiDockNodeFlags_PassthruCentralNode);
     if (shouldMakeDefaultDockState) {
         dockSpace = makeDefaultDockState(dockSpace);
     }
@@ -1069,7 +1069,7 @@ void vk_gltf_viewer::control::ImGuiTaskCollector::sceneHierarchy(gltf::AssetExte
 
                 bool isNodeSelected = std::ranges::all_of(ancestorNodeIndices, LIFT(assetExtended.selectedNodes.contains)) && assetExtended.selectedNodes.contains(nodeIndex);
                 const bool isTreeNodeOpen = ImGui::WithStyleColor(ImGuiCol_Header, ImGui::GetStyleColorVec4(ImGuiCol_HeaderActive), [&]() {
-                    ImGuiTreeNodeFlags flags = ImGuiTreeNodeFlags_DefaultOpen | ImGuiTreeNodeFlags_SpanAvailWidth | ImGuiTreeNodeFlags_OpenOnArrow | ImGuiTreeNodeFlags_AllowOverlap;
+                    ImGuiTreeNodeFlags flags = ImGuiTreeNodeFlags_DefaultOpen | ImGuiTreeNodeFlags_SpanAvailWidth | ImGuiTreeNodeFlags_OpenOnArrow | ImGuiTreeNodeFlags_AllowOverlap | ImGuiTreeNodeFlags_DrawLinesToNodes;
                     if (nodeIndex == assetExtended.hoveringNode) flags |= ImGuiTreeNodeFlags_Framed;
                     if (isNodeSelected) flags |= ImGuiTreeNodeFlags_Selected;
                     if (node.children.empty()) flags |= ImGuiTreeNodeFlags_Bullet | ImGuiTreeNodeFlags_Leaf;
@@ -1540,13 +1540,13 @@ void vk_gltf_viewer::control::ImGuiTaskCollector::nodeInspector(gltf::AssetExten
 
 void vk_gltf_viewer::control::ImGuiTaskCollector::imageBasedLighting(
     const AppState::ImageBasedLighting &info,
-    ImTextureID eqmapTextureImGuiDescriptorSet
+    ImTextureRef eqmapTextureRef
 ) {
     if (ImGui::Begin("IBL")) {
         if (ImGui::CollapsingHeader("Equirectangular map")) {
             const float eqmapAspectRatio = static_cast<float>(info.eqmap.dimension.y) / info.eqmap.dimension.x;
             const ImVec2 eqmapTextureSize = ImVec2 { 1.f, eqmapAspectRatio } * ImGui::GetContentRegionAvail().x;
-            hoverableImage(eqmapTextureImGuiDescriptorSet, eqmapTextureSize);
+            hoverableImage(eqmapTextureRef, eqmapTextureSize);
 
             ImGui::WithLabel("File"sv, [&]() {
                 ImGui::TextLinkOpenURL(PATH_C_STR(info.eqmap.path.filename()), PATH_C_STR(info.eqmap.path));

interface/control/ImGuiTaskCollector.cppm

@@ -27,7 +27,7 @@ namespace vk_gltf_viewer::control {
         void materialVariants(gltf::AssetExtended &assetExtended);
         void sceneHierarchy(gltf::AssetExtended &assetExtended);
         void nodeInspector(gltf::AssetExtended &assetExtended);
-        void imageBasedLighting(const AppState::ImageBasedLighting &info, ImTextureID eqmapTextureImGuiDescriptorSet);
+        void imageBasedLighting(const AppState::ImageBasedLighting &info, ImTextureRef eqmapTextureImGuiDescriptorSet);
         void rendererSetting(Renderer &renderer);
         void imguizmo(Renderer &renderer);
         void imguizmo(Renderer &renderer, gltf::AssetExtended &assetExtended);

interface/helpers/imgui/mod.cppm

@@ -73,7 +73,7 @@ namespace ImGui {
         }
     }
 
-    export bool ImageButtonWithText(std::string_view str_id, ImTextureID user_texture_id, std::string_view text, const ImVec2 &image_size, const ImVec2& uv0 = ImVec2(0, 0), const ImVec2& uv1 = ImVec2(1, 1), const ImVec4& bg_col = ImVec4(0, 0, 0, 0), const ImVec4& tint_col = ImVec4(1, 1, 1, 1), ImGuiButtonFlags flags = 0) {
+    export bool ImageButtonWithText(std::string_view str_id, ImTextureRef tex_ref, std::string_view text, const ImVec2 &image_size, const ImVec2& uv0 = ImVec2(0, 0), const ImVec2& uv1 = ImVec2(1, 1), const ImVec4& bg_col = ImVec4(0, 0, 0, 0), const ImVec4& tint_col = ImVec4(1, 1, 1, 1), ImGuiButtonFlags flags = 0) {
         ImGuiStyle &style = GetStyle();
         ImGuiWindow* window = GetCurrentWindow();
         if (window->SkipItems)
@@ -100,20 +100,20 @@ namespace ImGui {
         if (bg_col.w > 0.0f)
             window->DrawList->AddRectFilled(p_min, p_max, GetColorU32(bg_col));
         window->DrawList->AddImage(static_cast<const vk_gltf_viewer::imgui::UserData*>(GetIO().UserData)->platformResource->checkerboardTextureID, p_min, p_max, image_size * uv0 / 16.f, image_size * uv1 / 16.f, GetColorU32(tint_col));
-        window->DrawList->AddImage(user_texture_id, p_min, p_max, uv0, uv1, GetColorU32(tint_col));
+        window->DrawList->AddImage(tex_ref, p_min, p_max, uv0, uv1, GetColorU32(tint_col));
         window->DrawList->PushClipRect({ p_min.x, p_max.y }, { p_max.x, p_max.y + GetTextLineHeight() }, true);
         window->DrawList->AddText({ p_min.x, p_max.y }, GetColorU32(ImGuiCol_Text), text.data(), text.data() + text.size());
         window->DrawList->PopClipRect();
 
         return pressed;
     }
 
-    export void ImageCheckerboardBackground(ImTextureID textureId, const ImVec2 &size, const ImVec2 &uv0 = {}, const ImVec2 &uv1 = { 1, 1 }) {
+    export void ImageCheckerboardBackground(ImTextureRef tex_ref, const ImVec2 &size, const ImVec2 &uv0 = {}, const ImVec2 &uv1 = { 1, 1 }) {
         const ImVec2 texturePosition = GetCursorScreenPos();
         SetNextItemAllowOverlap();
         Image(static_cast<const vk_gltf_viewer::imgui::UserData*>(GetIO().UserData)->platformResource->checkerboardTextureID, size, size * uv0 / 16.f, size * uv1 / 16.f);
         SetCursorScreenPos(texturePosition);
-        Image(textureId, size, uv0, uv1);
+        Image(tex_ref, size, uv0, uv1);
     }
 
     export template <std::invocable F>