明面上没bug了

Qt/plot/Plot.cpp

@@ -4,8 +4,11 @@
 #include "../bridge/Qt_Presentation_Sink.h"
 #include "Core/architecture/Render_Time.h"
 #include "Core/base/global.h"
+#include "Core/plottable/export.h"
 #include <QPainter>
+#include <QPointer>
 #include <QResizeEvent>
+#include <QTimer>
 
 namespace renderive {
 
@@ -31,8 +34,8 @@ std::string to_utf8_string(const QString& text) {
 
 } // namespace
 
-void start_render_scheduler() {
-    Global::instance()->start_render_scheduler();
+void start_render_scheduler(Render_Runtime_Config config) {
+    Global::instance()->start_render_scheduler(config);
 }
 
 Abs_Plot_Private::Abs_Plot_Private(std::unique_ptr<Refresh_Strategy> refresh_strategy)
@@ -44,6 +47,17 @@ Abs_Plot_Private::~Abs_Plot_Private() = default;
 void Abs_Plot_Private::attach_widget(Abs_Plot* plot) {
     presentation_sink = std::make_shared<Qt_Presentation_Sink>(plot);
     core->set_presentation_sink(presentation_sink);
+    QPointer<Abs_Plot> guarded_plot(plot);
+    auto pending = performance_update_pending;
+    set_performance_shower_update_callback(*core, [guarded_plot, pending]() mutable {
+        if (!guarded_plot || pending->exchange(true, std::memory_order_acq_rel))
+            return;
+        QTimer::singleShot(0, guarded_plot.data(), [guarded_plot, pending]() mutable {
+            pending->store(false, std::memory_order_release);
+            if (guarded_plot)
+                guarded_plot->update();
+        });
+    });
 }
 
 Abs_Plot::Abs_Plot(Abs_Plot_Private* private_data)
@@ -56,6 +70,7 @@ Abs_Plot::Abs_Plot(Abs_Plot_Private* private_data)
 
 Abs_Plot::~Abs_Plot() {
     if (d) {
+        set_performance_shower_update_callback(*d->core, {});
         d->core->pause_render();
         delete d;
         d = nullptr;
@@ -132,16 +147,40 @@ void Abs_Plot_Private::paint_event(Abs_Plot* plot, QPaintEvent* event) {
     else {
         painter.fillRect(plot->rect(), plot->background_color());
     }
+    auto performance_snapshot = performance_shower_snapshot(*core);
+    if (performance_snapshot && !performance_snapshot->image.empty()) {
+        Size current_size = core->viewport_size();
+        auto ctx = core->render_context();
+        std::uint64_t current_viewport_version = ctx ? ctx->viewport_version.load(std::memory_order_acquire) : 0;
+        if (performance_snapshot->viewport_size == current_size && performance_snapshot->viewport_version == current_viewport_version) {
+            QImage overlay = Qt_Image_Adapter::to_qimage(performance_snapshot->image.view());
+            const RectF& target = performance_snapshot->destination_rect;
+            painter.drawImage(QRectF(target.x, target.y, target.width, target.height), overlay);
+        }
+    }
     painter.end();
 
     core->end_present(std::move(frame), paint_begin_time, steady_now_ns());
 }
 
+void Abs_Plot_Private::request_performance_overlay_update(Abs_Plot* plot) {
+    if (!plot || performance_update_pending->exchange(true, std::memory_order_acq_rel))
+        return;
+    QPointer<Abs_Plot> guarded_plot(plot);
+    auto pending = performance_update_pending;
+    QTimer::singleShot(0, plot, [guarded_plot, pending]() mutable {
+        pending->store(false, std::memory_order_release);
+        if (guarded_plot)
+            guarded_plot->update();
+    });
+}
+
 bool Abs_Plot_Private::event(Abs_Plot* plot, QEvent* event, bool base_result) {
     switch (event->type()) {
     case QEvent::Resize: {
         auto* resize_event = static_cast<QResizeEvent*>(event);
         core->set_viewport_size(Qt_Event_Adapter::to_size(resize_event->size()));
+        notify_performance_shower_viewport_changed(*core);
         core->dispatch_event(Qt_Event_Adapter::to_resize_event(resize_event));
         core->mark_render_state_dirty();
         break;
@@ -163,18 +202,48 @@ bool Abs_Plot_Private::event(Abs_Plot* plot, QEvent* event, bool base_result) {
         core->dispatch_event(leave_event);
         break;
     }
-    case QEvent::Wheel:
-        core->dispatch_event(Qt_Event_Adapter::to_wheel_event(static_cast<QWheelEvent*>(event)));
+    case QEvent::Wheel: {
+        auto wheel_event = Qt_Event_Adapter::to_wheel_event(static_cast<QWheelEvent*>(event));
+        if (performance_shower_handle_wheel(*core, wheel_event.position, wheel_event.angle_delta_y, wheel_event.pixel_delta_y)) {
+            event->accept();
+            request_performance_overlay_update(plot);
+            return true;
+        }
+        core->dispatch_event(wheel_event);
         break;
-    case QEvent::MouseMove:
-        core->dispatch_event(Qt_Event_Adapter::to_pointer_event(static_cast<QMouseEvent*>(event), Event_Type::Pointer_Move));
+    }
+    case QEvent::MouseMove: {
+        auto pointer_event = Qt_Event_Adapter::to_pointer_event(static_cast<QMouseEvent*>(event), Event_Type::Pointer_Move);
+        if (performance_shower_handle_pointer_move(*core, pointer_event.position)) {
+            event->accept();
+            request_performance_overlay_update(plot);
+            return true;
+        }
+        core->dispatch_event(pointer_event);
         break;
-    case QEvent::MouseButtonPress:
-        core->dispatch_event(Qt_Event_Adapter::to_pointer_event(static_cast<QMouseEvent*>(event), Event_Type::Pointer_Press));
+    }
+    case QEvent::MouseButtonPress: {
+        auto* mouse_event = static_cast<QMouseEvent*>(event);
+        auto pointer_event = Qt_Event_Adapter::to_pointer_event(mouse_event, Event_Type::Pointer_Press);
+        if (mouse_event->button() == Qt::LeftButton && performance_shower_handle_pointer_press(*core, pointer_event.position)) {
+            event->accept();
+            request_performance_overlay_update(plot);
+            return true;
+        }
+        core->dispatch_event(pointer_event);
         break;
-    case QEvent::MouseButtonRelease:
-        core->dispatch_event(Qt_Event_Adapter::to_pointer_event(static_cast<QMouseEvent*>(event), Event_Type::Pointer_Release));
+    }
+    case QEvent::MouseButtonRelease: {
+        auto* mouse_event = static_cast<QMouseEvent*>(event);
+        auto pointer_event = Qt_Event_Adapter::to_pointer_event(mouse_event, Event_Type::Pointer_Release);
+        if (mouse_event->button() == Qt::LeftButton && performance_shower_handle_pointer_release(*core, pointer_event.position)) {
+            event->accept();
+            request_performance_overlay_update(plot);
+            return true;
+        }
+        core->dispatch_event(pointer_event);
         break;
+    }
     case QEvent::KeyPress:
         core->dispatch_event(Qt_Event_Adapter::to_key_event(static_cast<QKeyEvent*>(event), Event_Type::Key_Press));
         break;