Fix modal measurement picks under Vulkan

Author: MrNeRF

src/python/lfs/py_ui.cpp

@@ -938,7 +938,10 @@ namespace lfs::python {
                     }
                     try {
                         PyEvent py_event = convert_modal_event(event);
+                        const auto redraw_generation_before = lfs::python::redraw_request_generation();
                         nb::object result = instance.attr("modal")(nb::none(), py_event);
+                        if (lfs::python::redraw_request_generation() != redraw_generation_before)
+                            lfs::python::request_pre_scene_panel_sync();
                         const auto status = parse_operator_result(result, instance);
                         if (has_undo && status == vis::op::OperatorResult::FINISHED) {
                             push_python_operator_undo_entry(label.empty() ? class_id : label, instance);

src/python/python_runtime.cpp

@@ -177,6 +177,8 @@ namespace lfs::python {
 
         // Redraw request flag
         std::atomic<bool> g_redraw_requested{false};
+        std::atomic<uint64_t> g_redraw_generation{0};
+        std::atomic<uint64_t> g_pre_scene_panel_sync_generation{0};
         MainLoopWakeCallback g_main_loop_wake_callback = nullptr;
     } // namespace
 
@@ -213,6 +215,7 @@ namespace lfs::python {
     // Redraw request mechanism
     void request_redraw() {
         const bool was_requested = g_redraw_requested.exchange(true, std::memory_order_acq_rel);
+        g_redraw_generation.fetch_add(1, std::memory_order_acq_rel);
         if (!was_requested && g_main_loop_wake_callback)
             g_main_loop_wake_callback();
     }
@@ -221,6 +224,19 @@ namespace lfs::python {
         return g_redraw_requested.exchange(false, std::memory_order_acq_rel);
     }
 
+    uint64_t redraw_request_generation() {
+        return g_redraw_generation.load(std::memory_order_acquire);
+    }
+
+    void request_pre_scene_panel_sync() {
+        g_pre_scene_panel_sync_generation.store(redraw_request_generation(),
+                                                std::memory_order_release);
+    }
+
+    uint64_t pre_scene_panel_sync_generation() {
+        return g_pre_scene_panel_sync_generation.load(std::memory_order_acquire);
+    }
+
     void set_main_loop_wake_callback(MainLoopWakeCallback cb) {
         g_main_loop_wake_callback = cb;
     }

src/python/python_runtime.hpp

@@ -90,6 +90,9 @@ namespace lfs::python {
     // UI redraw request mechanism
     LFS_PYTHON_RUNTIME_API void request_redraw();
     LFS_PYTHON_RUNTIME_API bool consume_redraw_request();
+    LFS_PYTHON_RUNTIME_API uint64_t redraw_request_generation();
+    LFS_PYTHON_RUNTIME_API void request_pre_scene_panel_sync();
+    LFS_PYTHON_RUNTIME_API uint64_t pre_scene_panel_sync_generation();
     using MainLoopWakeCallback = void (*)();
     LFS_PYTHON_RUNTIME_API void set_main_loop_wake_callback(MainLoopWakeCallback cb);
 

src/visualizer/gui/gui_manager.cpp

@@ -6610,6 +6610,102 @@ namespace lfs::vis::gui {
                 now >= next_vram_hud_publish_);
     }
 
+    void GuiManager::syncVisiblePanelsBeforeSceneRender() {
+        const std::uint64_t sync_generation = lfs::python::pre_scene_panel_sync_generation();
+        if (sync_generation == 0 ||
+            sync_generation == last_pre_scene_panel_sync_generation_)
+            return;
+        last_pre_scene_panel_sync_generation_ = sync_generation;
+
+        if (!viewer_ || !show_main_panel_ || ui_hidden_) {
+            return;
+        }
+
+        auto& reg = PanelRegistry::instance();
+        const auto main_tabs = reg.get_panels_for_space(PanelSpace::MainPanelTab);
+        if (main_tabs.empty()) {
+            return;
+        }
+
+        panel_layout_.syncActiveTab(main_tabs, focus_panel_name_);
+        const std::string& active_tab = panel_layout_.getActiveTab();
+        if (active_tab.empty()) {
+            return;
+        }
+
+        const ImGuiViewport* const mvp = ImGui::GetMainViewport();
+        if (!mvp || mvp->WorkSize.x <= 0.0f || mvp->WorkSize.y <= 0.0f) {
+            return;
+        }
+
+        auto& editor_ctx = viewer_->getEditorContext();
+        auto* scene_manager = viewer_->getSceneManager();
+        auto* trainer_manager = viewer_->getTrainerManager();
+        editor_ctx.update(scene_manager, trainer_manager);
+
+        UIContext ctx{
+            .viewer = viewer_,
+            .window_states = &window_states_,
+            .editor = &editor_ctx,
+            .sequencer_controller = &sequencer_ui_.controller(),
+            .rml_manager = &rmlui_manager_,
+            .fonts = buildFontSet()};
+
+        lfs::core::Scene* scene = nullptr;
+        if (scene_manager)
+            scene = &scene_manager->getScene();
+
+        PanelDrawContext draw_ctx;
+        draw_ctx.ui = &ctx;
+        draw_ctx.viewport = &viewport_layout_;
+        draw_ctx.scene = scene;
+        draw_ctx.ui_hidden = ui_hidden_;
+        draw_ctx.scene_generation = python::get_scene_generation();
+        if (scene_manager)
+            draw_ctx.has_selection = scene_manager->hasSelectedNode();
+        if (auto* cc = lfs::event::command_center())
+            draw_ctx.is_training = cc->snapshot().is_running;
+
+        PanelInputState input;
+        input.mouse_x = -1.0e9f;
+        input.mouse_y = -1.0e9f;
+        input.screen_x = mvp->Pos.x;
+        input.screen_y = mvp->Pos.y;
+        input.screen_w = static_cast<int>(mvp->Size.x);
+        input.screen_h = static_cast<int>(mvp->Size.y);
+
+        const float dpi = lfs::python::get_shared_dpi_scale();
+        const float panel_h = mvp->WorkSize.y - PanelLayoutManager::STATUS_BAR_HEIGHT * dpi;
+        if (panel_h <= 0.0f) {
+            return;
+        }
+
+        constexpr float kPanelPad = 8.0f;
+        constexpr float kPreloadMaxHeight = 100000.0f;
+        const float content_w = panel_layout_.getRightPanelWidth() - 2.0f * kPanelPad;
+        if (content_w <= 0.0f) {
+            return;
+        }
+
+        const float splitter_h = PanelLayoutManager::SPLITTER_H * dpi;
+        const float tab_bar_h = PanelLayoutManager::TAB_BAR_H * dpi;
+        const float avail_h = panel_h - 2.0f * kPanelPad;
+        const float scene_h =
+            std::max(80.0f * dpi,
+                     avail_h * panel_layout_.getScenePanelRatio() - splitter_h * 0.5f);
+        const float content_top = mvp->WorkPos.y + kPanelPad;
+        const float tab_content_y = content_top + scene_h + splitter_h + tab_bar_h;
+        const float tab_content_h =
+            std::max(0.0f, content_top + avail_h - tab_content_y);
+        const float clip_y_min = tab_content_y;
+        const float clip_y_max = tab_content_y + tab_content_h;
+
+        reg.preload_single_panel_direct(active_tab, content_w, kPreloadMaxHeight, draw_ctx,
+                                        clip_y_min, clip_y_max, &input);
+        reg.preload_child_panels_direct(active_tab, content_w, kPreloadMaxHeight, draw_ctx,
+                                        clip_y_min, clip_y_max, &input);
+    }
+
     bool GuiManager::needsAnimationFrame() const {
         if (isViewportExportLocked())
             return true;

src/visualizer/gui/gui_manager.hpp

@@ -77,6 +77,7 @@ namespace lfs::vis {
             void init();
             void shutdown();
             void render();
+            void syncVisiblePanelsBeforeSceneRender();
             void setRmlResizeDeferring(bool defer) { rmlui_manager_.setResizeDeferring(defer); }
 
             // Sub-manager access
@@ -382,6 +383,7 @@ namespace lfs::vis {
                 RightPanelPointerRegion::None;
             bool bottom_dock_pointer_live_capture_ = false;
             std::string last_ui_layout_active_tab_;
+            std::uint64_t last_pre_scene_panel_sync_generation_ = 0;
 
             struct DevResourceWatchState {
                 bool enabled = false;

src/visualizer/rendering/vksplat_viewport_renderer.cpp

@@ -3577,10 +3577,6 @@ namespace lfs::vis {
             return -1.0f;
         }
 
-        if (!context.waitForSubmittedFrames()) {
-            return std::unexpected(context.lastError());
-        }
-
         const VkDevice device = context.device();
         constexpr VkDeviceSize byte_count = sizeof(float);
         ScopedStagingBuffer staging{};

src/visualizer/visualizer_impl.cpp

@@ -1366,6 +1366,9 @@ namespace lfs::vis {
         }
 
         if (!viewport_export_locked) {
+            if (frame_demand.python_redraw && gui_manager_)
+                gui_manager_->syncVisiblePanelsBeforeSceneRender();
+
             const auto vulkan_frame = rendering_manager_->renderVulkanFrame(context);
             if (gui_manager_) {
                 if (vulkan_frame.external_image != VK_NULL_HANDLE) {