Vulkan texture retirement, UI and probe fixes

Introduce deferred Vulkan texture destruction and submit-serial tracking to avoid destroying resources still in use: add RetiredVulkanTexture, retire_texture/drain_retired_textures, per-frame submit serial bookkeeping, and flush retired textures on device idle/cleanup. Replace immediate destroy with destroy_now for safe teardown. Fix renderer wait-idle error reporting on shutdown.

Misc UI and UX fixes: sync per-view fit_image_to_window state, only zoom with mouse wheel when the image canvas accepts mouse input, improve pixel-closeup numeric formatting and layout (new format_probe_display_value, stable column layout, fixed mono font size). Add regression test steps to verify zoom-after-fit interactions. Also add a new design doc (imiv_tiling.md) describing a tiled large-image architecture and phased implementation guidance.

Signed-off-by: Vlad (Kuzmin) Erium <libalias@gmail.com>
Signed-off-by: Vlad <shaamaan@gmail.com>

Author: ssh4net

src/imiv/imiv_app.cpp

@@ -769,6 +769,10 @@ run(const AppConfig& config)
             continue;
         renderer_destroy_texture(renderer_state, view->viewer.texture);
     }
+    if (!renderer_wait_idle(renderer_state, prefs_save_error)
+        && !prefs_save_error.empty())
+        print(stderr, "imiv: failed to finalize renderer idle: {}\n",
+              prefs_save_error);
 #if defined(IMGUI_ENABLE_TEST_ENGINE)
     test_engine_stop(test_engine_runtime);
 #endif

src/imiv/imiv_frame.cpp

@@ -1534,6 +1534,7 @@ draw_viewer_ui(MultiViewWorkspace& workspace, ImageLibraryState& library,
                                    active && actions.recenter_requested);
         ImGui::End();
         if (active) {
+            ui_state.fit_image_to_window = view_ui_state.fit_image_to_window;
             ui_state.image_window_force_dock = view_ui_state.image_window_force_dock;
         }
     }

src/imiv/imiv_image_view.cpp

@@ -470,7 +470,7 @@ draw_image_window_contents(ViewerState& viewer, PlaceholderUiState& ui_state,
             viewer.zoom_drag_active = false;
         }
 
-        if (viewport_accepts_mouse && io.MouseWheel != 0.0f) {
+        if (image_canvas_accepts_mouse && io.MouseWheel != 0.0f) {
             const float scale = (io.MouseWheel > 0.0f) ? 1.1f : 0.9f;
             request_zoom_scale(pending_zoom, scale, true);
         }

src/imiv/imiv_overlays.cpp

@@ -227,51 +227,26 @@ namespace {
         }
     }
 
-    std::string format_probe_iv_float(double value)
+    std::string format_probe_display_value(double value)
     {
-        if (value < 10.0)
-            return Strutil::fmt::format("{:.3f}", value);
-        if (value < 100.0)
-            return Strutil::fmt::format("{:.2f}", value);
-        if (value < 1000.0)
-            return Strutil::fmt::format("{:.1f}", value);
-        return Strutil::fmt::format("{:.0f}", value);
-    }
+        if (!std::isfinite(value))
+            return Strutil::fmt::format("{:>8}", value);
 
-    std::string format_probe_integer_trunc(UploadDataType type, double value)
-    {
-        switch (type) {
-        case UploadDataType::UInt8:
-            return Strutil::fmt::format("{}",
-                                        static_cast<unsigned int>(
-                                            std::clamp(value, 0.0, 255.0)));
-        case UploadDataType::UInt16:
-            return Strutil::fmt::format("{}",
-                                        static_cast<unsigned int>(
-                                            std::clamp(value, 0.0, 65535.0)));
-        case UploadDataType::UInt32:
-            return Strutil::fmt::format("{}", static_cast<uint32_t>(
-                                                  std::clamp(value, 0.0,
-                                                             4294967295.0)));
-        default: break;
-        }
-        return Strutil::fmt::format("{:.0f}", value);
-    }
-
-    bool probe_type_is_integer(UploadDataType type)
-    {
-        return type == UploadDataType::UInt8 || type == UploadDataType::UInt16;
-    }
+        const double abs_value = std::abs(value);
+        if ((abs_value > 99999.0) || (abs_value > 0.0 && abs_value < 0.00001))
+            return Strutil::fmt::format("{: .1e}", value);
 
-    double probe_channel_integer_denominator(UploadDataType type)
-    {
-        switch (type) {
-        case UploadDataType::UInt8: return 255.0;
-        case UploadDataType::UInt16: return 65535.0;
-        case UploadDataType::UInt32: return 4294967295.0;
-        default: break;
+        int digits_before_decimal = 1;
+        if (abs_value >= 1.0) {
+            digits_before_decimal
+                = static_cast<int>(std::floor(std::log10(abs_value))) + 1;
         }
-        return 1.0;
+        digits_before_decimal = std::clamp(digits_before_decimal, 1, 5);
+        const int decimals    = std::clamp(6 - digits_before_decimal, 1, 5);
+
+        const std::string format
+            = Strutil::fmt::format("{{: .{}f}}", decimals);
+        return Strutil::fmt::format(format, value);
     }
 
     OverlayPanelRect
@@ -563,16 +538,14 @@ draw_pixel_closeup_overlay(const ViewerState& viewer,
 
     std::vector<std::string> lines;
     std::vector<ImU32> line_colors;
-    lines.emplace_back("Pixel Closeup:");
-    line_colors.emplace_back(IM_COL32(240, 242, 245, 255));
     if (viewer.image.path.empty()) {
         lines.emplace_back("No image loaded.");
         line_colors.emplace_back(IM_COL32(240, 242, 245, 255));
     } else if (!viewer.probe_valid) {
         lines.emplace_back("Hover over image to inspect.");
         line_colors.emplace_back(IM_COL32(240, 242, 245, 255));
     } else {
-        lines.emplace_back(Strutil::fmt::format("          ({:d},{:d})",
+        lines.emplace_back(Strutil::fmt::format("X:  {:>7}       Y:  {:>7}",
                                                 viewer.probe_x,
                                                 viewer.probe_y));
         line_colors.emplace_back(IM_COL32(0, 255, 255, 220));
@@ -581,67 +554,37 @@ draw_pixel_closeup_overlay(const ViewerState& viewer,
         std::vector<double> max_values;
         std::vector<double> avg_values;
         int sample_count        = 0;
-        const bool integer_type = probe_type_is_integer(viewer.image.type);
-        const ProbeStatsSemantics preview_semantics
-            = integer_type ? ProbeStatsSemantics::RawStored
-                           : ProbeStatsSemantics::OIIOFloat;
         const bool have_stats
             = compute_area_stats(viewer.image, viewer.probe_x, viewer.probe_y,
                                  ui_state.closeup_avg_pixels, min_values,
                                  max_values, avg_values, sample_count,
-                                 preview_semantics);
+                                 ProbeStatsSemantics::OIIOFloat);
 
-        const double denom = probe_channel_integer_denominator(
-            viewer.image.type);
-        if (integer_type) {
-            lines.emplace_back("      Val    Norm   Min   Max   Avg");
-        } else {
-            lines.emplace_back("      Val    Min    Max    Avg");
-        }
+        lines.emplace_back("");
+        line_colors.emplace_back(IM_COL32(240, 242, 245, 255));
+        lines.emplace_back(Strutil::fmt::format(
+            "{:<2} {:>8} {:>8} {:>8} {:>8}", "", "Val", "Min", "Max",
+            "Avg"));
         line_colors.emplace_back(IM_COL32(255, 255, 160, 220));
         for (size_t c = 0; c < viewer.probe_channels.size(); ++c) {
             const std::string label
                 = pixel_preview_channel_label(viewer.image,
                                               static_cast<int>(c));
             const double semantic_value
-                = integer_type
-                      ? viewer.probe_channels[c]
-                      : probe_value_to_oiio_float(viewer.image.type,
-                                                  viewer.probe_channels[c]);
-            const std::string value
-                = integer_type
-                      ? format_probe_integer_trunc(viewer.image.type,
-                                                   viewer.probe_channels[c])
-                      : format_probe_iv_float(semantic_value);
+                = probe_value_to_oiio_float(viewer.image.type,
+                                            viewer.probe_channels[c]);
+            const std::string value = format_probe_display_value(semantic_value);
             if (have_stats && c < min_values.size() && c < max_values.size()
                 && c < avg_values.size()) {
-                if (integer_type && denom > 0.0) {
-                    lines.emplace_back(Strutil::fmt::format(
-                        "{:<2}: {:>5}  {:>6.3f}  {:>3}  {:>3}  {:>3}", label,
-                        value, viewer.probe_channels[c] / denom,
-                        format_probe_integer_trunc(viewer.image.type,
-                                                   min_values[c]),
-                        format_probe_integer_trunc(viewer.image.type,
-                                                   max_values[c]),
-                        format_probe_integer_trunc(viewer.image.type,
-                                                   avg_values[c])));
-                } else {
-                    lines.emplace_back(Strutil::fmt::format(
-                        "{:<2}: {:>6}  {:>6}  {:>6}  {:>6}", label, value,
-                        format_probe_iv_float(min_values[c]),
-                        format_probe_iv_float(max_values[c]),
-                        format_probe_iv_float(avg_values[c])));
-                }
+                lines.emplace_back(Strutil::fmt::format(
+                    "{:<2} {:>8} {:>8} {:>8} {:>8}", label, value,
+                    format_probe_display_value(min_values[c]),
+                    format_probe_display_value(max_values[c]),
+                    format_probe_display_value(avg_values[c])));
             } else {
-                if (integer_type) {
-                    lines.emplace_back(Strutil::fmt::format(
-                        "{:<2}: {:>5}  {:>6}  {:>3}  {:>3}  {:>3}", label,
-                        value, "-----", "---", "---", "---"));
-                } else {
-                    lines.emplace_back(Strutil::fmt::format(
-                        "{:<2}: {:>6}  {:>6}  {:>6}  {:>6}", label, value,
-                        "-----", "-----", "-----"));
-                }
+                lines.emplace_back(Strutil::fmt::format(
+                    "{:<2} {:>8} {:>8} {:>8} {:>8}", label, value, "-----",
+                    "-----", "-----"));
             }
             ImU32 channel_color = IM_COL32(220, 220, 220, 255);
             if (!label.empty()) {
@@ -666,9 +609,8 @@ draw_pixel_closeup_overlay(const ViewerState& viewer,
     const float text_to_window_gap  = 2.0f;
     const float text_wrap_w         = std::max(8.0f,
                                                closeup_window_size - text_pad_x * 2.0f);
-    ImFont* text_font          = fonts.mono ? fonts.mono : ImGui::GetFont();
-    const float text_font_size = text_font ? text_font->LegacySize
-                                           : ImGui::GetFontSize();
+    ImFont* text_font = fonts.mono ? fonts.mono : ImGui::GetFont();
+    const float text_font_size = 13.5f;
 
     float text_panel_h = text_pad_y * 2.0f;
     for (const std::string& line : lines) {

src/imiv/imiv_renderer_vulkan.cpp

@@ -139,7 +139,7 @@ vulkan_destroy_texture(RendererState& renderer_state, RendererTexture& texture)
     VulkanTexture* vk_texture = reinterpret_cast<VulkanTexture*>(
         texture.backend);
     if (vk_state != nullptr && vk_texture != nullptr)
-        destroy_texture(*vk_state, *vk_texture);
+        retire_texture(*vk_state, *vk_texture);
     delete vk_texture;
 }
 
@@ -277,6 +277,7 @@ vulkan_wait_idle(RendererState& renderer_state, std::string& error_message)
     }
     const VkResult err = vkDeviceWaitIdle(vk_state->device);
     if (err == VK_SUCCESS) {
+        drain_retired_textures(*vk_state, true);
         error_message.clear();
         return true;
     }