删除plot_core

Qt/plot/Explicit_Plot.cpp

@@ -8,7 +8,7 @@ Explicit_Plot::Explicit_Plot()
     : Abs_Plot(new Abs_Plot_Private(false)) {}
 
 Render_Ticket Explicit_Plot::replot() {
-    return {d->core->render_frame(true)};
+    return {d->scene->render_frame(true)};
 }
 
 } // namespace renderive

Qt/plot/Latency_Eager_Plot.cpp

@@ -16,24 +16,24 @@ void Latency_Eager_Plot::pause() {
 }
 
 bool Latency_Eager_Plot::running() const {
-    return d->core->view_active();
+    return d->scene->view_active();
 }
 
 double Latency_Eager_Plot::max_render_fps() const {
-    return d->core->max_render_fps();
+    return d->scene->max_render_fps();
 }
 
 void Latency_Eager_Plot::set_max_render_fps(double fps) {
-    d->core->set_max_render_fps(fps);
+    d->scene->set_max_render_fps(fps);
     update_render_interval();
 }
 
 Low_Latency_Diagnostics Latency_Eager_Plot::diagnostics() const {
-    return d->core->diagnostics();
+    return d->scene->diagnostics();
 }
 
 Refresh_Control_Snapshot Latency_Eager_Plot::refresh_feedback_snapshot() const {
-    return d->core->refresh_feedback_snapshot();
+    return d->scene->refresh_feedback_snapshot();
 }
 
 } // namespace renderive

Qt/plot/Plot.cpp

@@ -38,18 +38,18 @@ std::string to_utf8_string(const QString& text) {
 } // namespace
 
 Abs_Plot_Private::Abs_Plot_Private(bool continuous_rendering)
-    : core(std::make_unique<Plot_Core>()), continuous(continuous_rendering) {}
+    : scene(std::make_unique<Scene2D>()), continuous(continuous_rendering) {}
 
 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);
+    scene->set_presentation_sink(presentation_sink);
     timer = new QTimer(plot);
     timer->setTimerType(Qt::PreciseTimer);
     QObject::connect(timer, &QTimer::timeout, plot, [this] {
-        if (core->view_active())
-            (void)core->render_frame();
+        if (scene->view_active())
+            (void)scene->render_frame();
     });
 }
 
@@ -67,42 +67,42 @@ Abs_Plot::~Abs_Plot() {
         return;
     if (d->timer)
         d->timer->stop();
-    d->core->deactivate_view();
+    d->scene->deactivate_view();
     delete d;
     d = nullptr;
 }
 
 void Abs_Plot::init() {
-    d->core->init();
+    d->scene->init();
 }
 
-Plot_Core* Abs_Plot::core() const {
-    return d ? d->core.get() : nullptr;
+Scene2D* Abs_Plot::scene() const {
+    return d ? d->scene.get() : nullptr;
 }
 
 std::shared_ptr<Renderable> Abs_Plot::root_renderable() const {
-    return d->core->root_renderable();
+    return d->scene->root_renderable();
 }
 
 std::shared_ptr<Renderable> Abs_Plot::create_renderable_node(
     const std::shared_ptr<Renderable>& parent, const QString& object_name) const {
-    return d->core->create_renderable_node(parent, to_utf8_string(object_name));
+    return d->scene->create_renderable_node(parent, to_utf8_string(object_name));
 }
 
 void Abs_Plot::remove_renderable(const std::shared_ptr<Renderable>& renderable) {
-    d->core->remove_renderable(renderable);
+    d->scene->remove_renderable(renderable);
 }
 
 QColor Abs_Plot::background_color() const {
-    return to_qcolor(d->core->background_color());
+    return to_qcolor(d->scene->background_color());
 }
 
 void Abs_Plot::set_background_color(const QColor& color) {
-    d->core->set_background_color(from_qcolor(color));
+    d->scene->set_background_color(from_qcolor(color));
 }
 
 void Abs_Plot::start_render_timer() {
-    d->core->activate_view();
+    d->scene->activate_view();
     update_render_interval();
     if (d->timer && !d->timer->isActive())
         d->timer->start();
@@ -111,13 +111,13 @@ void Abs_Plot::start_render_timer() {
 void Abs_Plot::stop_render_timer() {
     if (d->timer)
         d->timer->stop();
-    d->core->deactivate_view();
+    d->scene->deactivate_view();
 }
 
 void Abs_Plot::update_render_interval() {
     if (!d->timer)
         return;
-    const double fps = std::max(1.0, d->core->max_render_fps());
+    const double fps = std::max(1.0, d->scene->max_render_fps());
     d->timer->setInterval(std::max(1, static_cast<int>(std::lround(1000.0 / fps))));
 }
 
@@ -128,7 +128,7 @@ void Abs_Plot::paintEvent(QPaintEvent*) {
 void Abs_Plot_Private::paint_event(Abs_Plot* plot) {
     QPainter painter(plot);
     painter.fillRect(plot->rect(), plot->background_color());
-    core->with_frame([&painter](Image_View view) {
+    scene->with_frame([&painter](Image_View view) {
         if (!view.empty())
             painter.drawImage(QPoint(0, 0), Qt_Image_Adapter::to_qimage(view));
     });
@@ -137,11 +137,11 @@ void Abs_Plot_Private::paint_event(Abs_Plot* plot) {
 }
 
 void Abs_Plot_Private::draw_performance_overlay(Abs_Plot* plot, QPainter& painter) {
-    const auto overlay = core->performance_overlay();
+    const auto overlay = scene->performance_overlay();
     if (!overlay || !overlay->enabled())
         return;
     const auto snapshot = overlay->display_snapshot();
-    if (!snapshot || snapshot->viewport_size != core->viewport_size())
+    if (!snapshot || snapshot->viewport_size != scene->viewport_size())
         return;
     const auto& options = snapshot->style;
     QFont font = painter.font();
@@ -186,7 +186,7 @@ void Abs_Plot_Private::draw_performance_overlay(Abs_Plot* plot, QPainter& painte
 
 bool Abs_Plot::event(QEvent* event) {
     const auto dispatch = [this, event](const Event& translated) {
-        d->core->dispatch_event(translated);
+        d->scene->dispatch_event(translated);
         if (!translated.is_accepted())
             return false;
         event->accept();
@@ -195,17 +195,17 @@ bool Abs_Plot::event(QEvent* event) {
     switch (event->type()) {
     case QEvent::Resize: {
         auto* resize = static_cast<QResizeEvent*>(event);
-        d->core->set_viewport_size(Qt_Event_Adapter::to_size(resize->size()));
-        d->core->dispatch_event(Qt_Event_Adapter::to_resize_event(resize));
+        d->scene->set_viewport_size(Qt_Event_Adapter::to_size(resize->size()));
+        d->scene->dispatch_event(Qt_Event_Adapter::to_resize_event(resize));
         break;
     }
     case QEvent::Show:
-        d->core->dispatch_event(Event(Event_Type::Show));
+        d->scene->dispatch_event(Event(Event_Type::Show));
         if (d->continuous)
             start_render_timer();
         break;
     case QEvent::Hide:
-        d->core->dispatch_event(Event(Event_Type::Hide));
+        d->scene->dispatch_event(Event(Event_Type::Hide));
         if (d->continuous)
             stop_render_timer();
         break;

Qt/plot/Plot.h

@@ -15,7 +15,7 @@ class LIB_DECL Abs_Plot : public QWidget {
 public:
     virtual void init();
     [[nodiscard]] QColor background_color() const;
-    [[nodiscard]] Plot_Core* core() const;
+    [[nodiscard]] Scene2D* scene() const;
     [[nodiscard]] std::shared_ptr<Renderable> root_renderable() const;
     [[nodiscard]] std::shared_ptr<Renderable> create_renderable_node(
         const std::shared_ptr<Renderable>& parent, const QString& object_name = {}) const;

Qt/plot/Plot_p.h

@@ -19,7 +19,7 @@ struct Abs_Plot_Private {
     void paint_event(Abs_Plot* plot);
     void draw_performance_overlay(Abs_Plot* plot, QPainter& painter);
 
-    std::unique_ptr<Plot_Core> core;
+    std::unique_ptr<Scene2D> scene;
     std::shared_ptr<Qt_Presentation_Sink> presentation_sink;
     QTimer* timer{};
     bool continuous{};