改名

Qt/bridge/Qt_Presentation_Sink.h

@@ -1,5 +1,5 @@
 #pragma once
-#include "render_2D/scene/Plot_Scene.h"
+#include "render_2D/scene/Render_Scene_2D.h"
 #include <QPointer>
 #include <memory>
 class QWidget;

Qt/plot/Plot.cpp

@@ -33,7 +33,7 @@ QColor to_qcolor(Color color) {
 } // namespace
 
 Abs_Plot_Private::Abs_Plot_Private(bool continuous_rendering)
-    : scene(std::make_unique<Plot_Scene>()), continuous(continuous_rendering) {}
+    : scene(std::make_unique<Render_Scene_2D>()), continuous(continuous_rendering) {}
 
 Abs_Plot_Private::~Abs_Plot_Private() = default;
 
@@ -76,7 +76,7 @@ void Abs_Plot::init() {
     d->scene->init();
 }
 
-Plot_Scene* Abs_Plot::scene() const {
+Render_Scene_2D* Abs_Plot::scene() const {
     return d ? d->scene.get() : nullptr;
 }
 

Qt/plot/Plot.h

@@ -13,7 +13,7 @@ class LIB_DECL Abs_Plot : public QWidget {
 public:
     virtual void init();
     [[nodiscard]] QColor background_color() const;
-    [[nodiscard]] Plot_Scene* scene() const;
+    [[nodiscard]] Render_Scene_2D* scene() const;
     [[nodiscard]] renderive_Owner<Renderable> root_renderable() const;
     void set_background_color(const QColor& color);
     ~Abs_Plot() override;

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_Scene> scene;
+    std::unique_ptr<Render_Scene_2D> scene;
     std::shared_ptr<Qt_Presentation_Sink> presentation_sink;
     QTimer* timer{};
     bool continuous{};

render_2D/render_2D/export.h

@@ -3,7 +3,7 @@
 #include "base/Types.h"
 #include "event/Event.h"
 #include "renderable/Renderable.h"
-#include "scene/Plot_Scene.h"
+#include "scene/Render_Scene_2D.h"
 #include "axis/Axis.h"
 #include "plottable/Hover_Tooltip.h"
 #include "plottable/Plottables.h"

render_2D/render_2D/plottable/Performance_Overlay.h

@@ -1,6 +1,6 @@
 #pragma once
 #include "../base/Types.h"
-#include "../scene/Plot_Scene.h"
+#include "../scene/Render_Scene_2D.h"
 #include <cstdint>
 #include <memory>
 #include <string>
@@ -45,10 +45,10 @@ struct LIB_DECL Performance_Overlay {
     [[nodiscard]] bool enabled() const noexcept;
     [[nodiscard]] std::shared_ptr<const Performance_Display_Snapshot> display_snapshot() const;
 private:
-    friend std::shared_ptr<Performance_Overlay> attach_performance_overlay(Plot_Scene&);
+    friend std::shared_ptr<Performance_Overlay> attach_performance_overlay(Render_Scene_2D&);
-    friend std::shared_ptr<Performance_Overlay> attach_performance_overlay(Plot_Scene&, const Performance_Overlay_Options&);
+    friend std::shared_ptr<Performance_Overlay> attach_performance_overlay(Render_Scene_2D&, const Performance_Overlay_Options&);
-    friend void set_performance_plot_name(Plot_Scene&, std::string);
+    friend void set_performance_plot_name(Render_Scene_2D&, std::string);
-    friend void set_performance_overlay_enabled(Plot_Scene&, bool);
+    friend void set_performance_overlay_enabled(Render_Scene_2D&, bool);
     struct Impl;
     std::unique_ptr<Impl> impl_;
     void set_enabled(bool enabled);
@@ -60,14 +60,14 @@ private:
                       std::size_t renderable_count,
                       Size viewport);
 };
-inline std::shared_ptr<Performance_Overlay> attach_performance_overlay(Plot_Scene& scene) {
+inline std::shared_ptr<Performance_Overlay> attach_performance_overlay(Render_Scene_2D& scene) {
     if (auto existing = scene.performance_overlay())
         return existing;
     auto overlay = std::make_shared<Performance_Overlay>();
     scene.set_performance_overlay(overlay);
     return overlay;
 }
-inline std::shared_ptr<Performance_Overlay> attach_performance_overlay(Plot_Scene& scene, const Performance_Overlay_Options& options) {
+inline std::shared_ptr<Performance_Overlay> attach_performance_overlay(Render_Scene_2D& scene, const Performance_Overlay_Options& options) {
     if (auto existing = scene.performance_overlay()) {
         existing->set_options(options);
         scene.request_redraw();
@@ -77,14 +77,14 @@ inline std::shared_ptr<Performance_Overlay> attach_performance_overlay(Plot_Scen
     scene.set_performance_overlay(overlay);
     return overlay;
 }
-inline void set_performance_plot_name(Plot_Scene& scene, std::string name) {
+inline void set_performance_plot_name(Render_Scene_2D& scene, std::string name) {
     auto overlay = scene.performance_overlay();
     if (!overlay)
         overlay = attach_performance_overlay(scene);
     overlay->set_plot_name(std::move(name));
     scene.request_redraw();
 }
-inline void set_performance_overlay_enabled(Plot_Scene& scene, bool enabled) {
+inline void set_performance_overlay_enabled(Render_Scene_2D& scene, bool enabled) {
     auto overlay = scene.performance_overlay();
     if (!overlay && !enabled)
         return;

render_2D/render_2D/scene/Plot_Scene.cpp

@@ -1,203 +0,0 @@
-#include <renderive/error/Error_Policy.hpp>
-#include "Plot_Scene.h"
-#include "detail/Plot_Scene_Model.hpp"
-#include "../plottable/Performance_Overlay.h"
-#include "../renderable/Renderable.h"
-#include <renderive/scene/base/Scene_Base.hpp>
-
-#include <stdexcept>
-#include <variant>
-
-namespace renderive::detail {
-void record_performance_frame(Performance_Overlay& overlay, double duration_ms, const Low_Latency_Diagnostics& diagnostics, std::size_t renderable_count, Size viewport) {
-    overlay.record_frame(duration_ms, diagnostics, renderable_count, viewport);
-}
-}
-
-namespace renderive {
-namespace {
-using Manual_Plot_Scene = Plot_Scene_Model<detail::Manual_Frame_Control>;
-using Low_Latency_Plot_Scene = Plot_Scene_Model<detail::Low_Latency_Frame_Control>;
-using Playback_Plot_Scene = Plot_Scene_Model<detail::Playback_Frame_Control>;
-}
-
-struct Plot_Scene::Impl {
-    using Model = std::variant<std::unique_ptr<Manual_Plot_Scene>,
-                               std::unique_ptr<Low_Latency_Plot_Scene>,
-                               std::unique_ptr<Playback_Plot_Scene>>;
-
-    explicit Impl(Plot_Frame_Mode mode) : mode(mode), model(create(mode)) {}
-
-    template <class Operation>
-    decltype(auto) apply(Operation&& operation) {
-        return std::visit(
-            [&operation](auto& scene) -> decltype(auto) {
-                return operation(*scene);
-            },
-            model);
-    }
-
-    template <class Operation>
-    decltype(auto) apply(Operation&& operation) const {
-        return std::visit(
-            [&operation](const auto& scene) -> decltype(auto) {
-                return operation(*scene);
-            },
-            model);
-    }
-
-    static Model create(Plot_Frame_Mode mode) {
-        switch (mode) {
-        case Plot_Frame_Mode::Manual:
-            return std::make_unique<Manual_Plot_Scene>();
-        case Plot_Frame_Mode::Low_Latency:
-            return std::make_unique<Low_Latency_Plot_Scene>();
-        case Plot_Frame_Mode::Playback:
-            return std::make_unique<Playback_Plot_Scene>();
-        }
-        ::renderive::error::unexpected<std::invalid_argument>("unknown Plot_Scene frame mode");
-    }
-
-    Plot_Frame_Mode mode;
-    Model model;
-};
-
-Plot_Scene::Plot_Scene(Plot_Scene_Options options)
-    : impl_(std::make_unique<Impl>(options.frame_mode)) {}
-
-Plot_Scene::~Plot_Scene() = default;
-
-void Plot_Scene::init() { impl_->apply([](auto& scene) { scene.init(); }); }
-
-renderive_Owner<Renderable> Plot_Scene::root_renderable() const {
-    return impl_->apply([](const auto& scene) { return scene.root_renderable(); });
-}
-
-Scene_2D_Base::Attach_Builder Plot_Scene::attach_builder() {
-    return static_cast<Scene_2D_Base&>(render_scene()).attach_builder();
-}
-
-Scene_Base::Edit_Operation Plot_Scene::edit_renderables(Scene_2D_Base::Renderable_Edit edit) {
-    return static_cast<Scene_2D_Base&>(render_scene()).edit_renderables(std::move(edit));
-}
-
-Scene_Base& Plot_Scene::render_scene() noexcept {
-    return impl_->apply([](auto& scene) -> Scene_Base& { return scene; });
-}
-
-const Scene_Base& Plot_Scene::render_scene() const noexcept {
-    return impl_->apply([](const auto& scene) -> const Scene_Base& { return scene; });
-}
-
-void Plot_Scene::set_background_color(Color color) {
-    impl_->apply([color](auto& scene) { scene.set_background_color(color); });
-}
-
-Color Plot_Scene::background_color() const {
-    return impl_->apply([](const auto& scene) { return scene.background_color(); });
-}
-
-void Plot_Scene::set_viewport_size(Size size) {
-    impl_->apply([size](auto& scene) { scene.set_viewport_size(size); });
-}
-
-Size Plot_Scene::viewport_size() const {
-    return impl_->apply([](const auto& scene) { return scene.viewport_size(); });
-}
-
-void Plot_Scene::dispatch_event(const Event& event) {
-    impl_->apply([&event](auto& scene) { scene.dispatch_event(event); });
-}
-
-tl::expected<void, Plot_Prepare_Frame_Error> Plot_Scene::prepare_frame() {
-    return impl_->apply([](auto& scene) { return scene.prepare_frame(); });
-}
-
-tl::expected<void, Plot_Refresh_Manual_Frame_Error> Plot_Scene::refresh_manual_frame() {
-    return impl_->apply([](auto& scene) { return scene.refresh_manual_frame(); });
-}
-
-tl::expected<void, Plot_Render_Prepared_Frame_Error> Plot_Scene::render_prepared_frame() {
-    return impl_->apply([](auto& scene) { return scene.render_prepared_frame(); });
-}
-
-bool Plot_Scene::discard_pending_frame() {
-    return impl_->apply([](auto& scene) { return scene.discard_pending_frame(); });
-}
-
-tl::expected<Plot_Render_Status, Plot_Render_Frame_Error>
-Plot_Scene::render_frame(bool force) {
-    return impl_->apply([force](auto& scene) { return scene.render_frame(force); });
-}
-
-void Plot_Scene::with_frame(const std::function<void(Image_View)>& consumer) {
-    impl_->apply([&consumer](auto& scene) { scene.with_frame(consumer); });
-}
-
-void Plot_Scene::activate_view() {
-    impl_->apply([](auto& scene) { scene.activate_view(); });
-}
-
-void Plot_Scene::deactivate_view() noexcept {
-    impl_->apply([](auto& scene) { scene.deactivate_view(); });
-}
-
-bool Plot_Scene::view_active() const noexcept {
-    return impl_->apply([](const auto& scene) { return scene.view_active(); });
-}
-
-void Plot_Scene::request_redraw() noexcept { render_scene().notify_model_dirty(); }
-
-tl::expected<void, Plot_Set_Max_Render_Fps_Error>
-Plot_Scene::set_max_render_fps(double fps) {
-    return impl_->apply([fps](auto& scene) { return scene.set_max_render_fps(fps); });
-}
-tl::expected<void, Plot_Clear_Max_Render_Fps_Error>
-Plot_Scene::clear_max_render_fps() {
-    return impl_->apply([](auto& scene) { return scene.clear_max_render_fps(); });
-}
-
-double Plot_Scene::max_render_fps() const {
-    return impl_->apply([](const auto& scene) { return scene.max_render_fps(); });
-}
-
-tl::expected<void, Plot_Set_Consumer_Feedback_Error>
-Plot_Scene::set_consumer_feedback(Frame_Consumer_Feedback feedback) {
-    return impl_->apply([feedback](auto& scene) { return scene.set_consumer_feedback(feedback); });
-}
-tl::expected<void, Plot_Clear_Consumer_Feedback_Error>
-Plot_Scene::clear_consumer_feedback() {
-    return impl_->apply([](auto& scene) { return scene.clear_consumer_feedback(); });
-}
-
-Plot_Frame_Mode Plot_Scene::frame_mode() const noexcept { return impl_->mode; }
-
-Plot_Frame_Status Plot_Scene::frame_status() const {
-    return impl_->apply([](const auto& scene) { return scene.frame_status(); });
-}
-
-Low_Latency_Diagnostics Plot_Scene::diagnostics() const {
-    return impl_->apply([](const auto& scene) { return scene.diagnostics(); });
-}
-
-Refresh_Control_Snapshot Plot_Scene::refresh_feedback_snapshot() const {
-    return impl_->apply(
-        [](const auto& scene) { return scene.refresh_feedback_snapshot(); });
-}
-
-void Plot_Scene::set_presentation_sink(std::weak_ptr<Presentation_Sink> sink) {
-    impl_->apply([&sink](auto& scene) { scene.set_presentation_sink(std::move(sink)); });
-}
-
-std::shared_ptr<Performance_Overlay> Plot_Scene::performance_overlay() const {
-    return impl_->apply([](const auto& scene) { return scene.performance_overlay(); });
-}
-
-void Plot_Scene::set_performance_overlay(
-    std::shared_ptr<Performance_Overlay> overlay) {
-    impl_->apply([&overlay](auto& scene) {
-        scene.set_performance_overlay(std::move(overlay));
-    });
-}
-
-} // namespace renderive

render_2D/render_2D/scene/Render_Scene_2D.cpp

@@ -0,0 +1,222 @@
+#include <renderive/error/Error_Policy.hpp>
+#include "Render_Scene_2D.h"
+#include "detail/Plot_Scene_Model.hpp"
+#include "../plottable/Performance_Overlay.h"
+#include "../renderable/Renderable.h"
+#include <renderive/scene/base/Scene_Base.hpp>
+#include <stdexcept>
+#include <variant>
+namespace renderive::detail {
+void record_performance_frame(Performance_Overlay& overlay, double duration_ms, const Low_Latency_Diagnostics& diagnostics, std::size_t renderable_count, Size viewport) {
+    overlay.record_frame(duration_ms, diagnostics, renderable_count, viewport);
+}
+}
+namespace renderive {
+namespace {
+using Manual_Plot_Scene = Plot_Scene_Model<detail::Manual_Frame_Control>;
+using Low_Latency_Plot_Scene = Plot_Scene_Model<detail::Low_Latency_Frame_Control>;
+using Playback_Plot_Scene = Plot_Scene_Model<detail::Playback_Frame_Control>;
+}
+struct Render_Scene_2D::Impl {
+    using Model = std::variant<std::unique_ptr<Manual_Plot_Scene>,
+                               std::unique_ptr<Low_Latency_Plot_Scene>,
+                               std::unique_ptr<Playback_Plot_Scene>>;
+    explicit Impl(Plot_Frame_Mode mode) : mode(mode), model(create(mode)) {}
+    template <class Operation>
+    decltype(auto) apply(Operation&& operation) {
+        return std::visit(
+            [&operation](auto& scene) -> decltype(auto) {
+                return operation(*scene);
+            },
+            model);
+    }
+    template <class Operation>
+    decltype(auto) apply(Operation&& operation) const {
+        return std::visit(
+            [&operation](const auto& scene) -> decltype(auto) {
+                return operation(*scene);
+            },
+            model);
+    }
+    static Model create(Plot_Frame_Mode mode) {
+        switch (mode) {
+        case Plot_Frame_Mode::Manual:
+            return std::make_unique<Manual_Plot_Scene>();
+        case Plot_Frame_Mode::Low_Latency:
+            return std::make_unique<Low_Latency_Plot_Scene>();
+        case Plot_Frame_Mode::Playback:
+            return std::make_unique<Playback_Plot_Scene>();
+        }
+        ::renderive::error::unexpected<std::invalid_argument>("unknown Plot_Scene frame mode");
+    }
+    Plot_Frame_Mode mode;
+    Model model;
+};
+Render_Scene_2D::Render_Scene_2D(Plot_Scene_Options options)
+    : impl_(std::make_unique<Impl>(options.frame_mode)) {}
+Render_Scene_2D::~Render_Scene_2D() = default;
+void Render_Scene_2D::init() {
+    impl_->apply([](auto& scene) {
+        scene.init();
+    });
+}
+renderive_Owner<Renderable> Render_Scene_2D::root_renderable() const {
+    return impl_->apply([](const auto& scene) {
+        return scene.root_renderable();
+    });
+}
+Scene_2D_Base::Attach_Builder Render_Scene_2D::attach_builder() {
+    return static_cast<Scene_2D_Base&>(render_scene()).attach_builder();
+}
+Scene_Base::Edit_Operation Render_Scene_2D::edit_renderables(Scene_2D_Base::Renderable_Edit edit) {
+    return static_cast<Scene_2D_Base&>(render_scene()).edit_renderables(std::move(edit));
+}
+Scene_Base& Render_Scene_2D::render_scene() noexcept {
+    return impl_->apply([](auto& scene) -> Scene_Base& {
+        return scene;
+    });
+}
+const Scene_Base& Render_Scene_2D::render_scene() const noexcept {
+    return impl_->apply([](const auto& scene) -> const Scene_Base& {
+        return scene;
+    });
+}
+void Render_Scene_2D::set_background_color(Color color) {
+    impl_->apply([color](auto& scene) {
+        scene.set_background_color(color);
+    });
+}
+Color Render_Scene_2D::background_color() const {
+    return impl_->apply([](const auto& scene) {
+        return scene.background_color();
+    });
+}
+void Render_Scene_2D::set_viewport_size(Size size) {
+    impl_->apply([size](auto& scene) {
+        scene.set_viewport_size(size);
+    });
+}
+Size Render_Scene_2D::viewport_size() const {
+    return impl_->apply([](const auto& scene) {
+        return scene.viewport_size();
+    });
+}
+void Render_Scene_2D::dispatch_event(const Event& event) {
+    impl_->apply([&event](auto& scene) {
+        scene.dispatch_event(event);
+    });
+}
+tl::expected<void, Plot_Prepare_Frame_Error> Render_Scene_2D::prepare_frame() {
+    return impl_->apply([](auto& scene) {
+        return scene.prepare_frame();
+    });
+}
+tl::expected<void, Plot_Refresh_Manual_Frame_Error> Render_Scene_2D::refresh_manual_frame() {
+    return impl_->apply([](auto& scene) {
+        return scene.refresh_manual_frame();
+    });
+}
+tl::expected<void, Plot_Render_Prepared_Frame_Error> Render_Scene_2D::render_prepared_frame() {
+    return impl_->apply([](auto& scene) {
+        return scene.render_prepared_frame();
+    });
+}
+bool Render_Scene_2D::discard_pending_frame() {
+    return impl_->apply([](auto& scene) {
+        return scene.discard_pending_frame();
+    });
+}
+tl::expected<Plot_Render_Status, Plot_Render_Frame_Error>
+Render_Scene_2D::render_frame(bool force) {
+    return impl_->apply([force](auto& scene) {
+        return scene.render_frame(force);
+    });
+}
+void Render_Scene_2D::with_frame(const std::function<void(Image_View)>& consumer) {
+    impl_->apply([&consumer](auto& scene) {
+        scene.with_frame(consumer);
+    });
+}
+void Render_Scene_2D::activate_view() {
+    impl_->apply([](auto& scene) {
+        scene.activate_view();
+    });
+}
+void Render_Scene_2D::deactivate_view() noexcept {
+    impl_->apply([](auto& scene) {
+        scene.deactivate_view();
+    });
+}
+bool Render_Scene_2D::view_active() const noexcept {
+    return impl_->apply([](const auto& scene) {
+        return scene.view_active();
+    });
+}
+void Render_Scene_2D::request_redraw() noexcept {
+    render_scene().notify_model_dirty();
+}
+tl::expected<void, Plot_Set_Max_Render_Fps_Error>
+Render_Scene_2D::set_max_render_fps(double fps) {
+    return impl_->apply([fps](auto& scene) {
+        return scene.set_max_render_fps(fps);
+    });
+}
+tl::expected<void, Plot_Clear_Max_Render_Fps_Error>
+Render_Scene_2D::clear_max_render_fps() {
+    return impl_->apply([](auto& scene) {
+        return scene.clear_max_render_fps();
+    });
+}
+double Render_Scene_2D::max_render_fps() const {
+    return impl_->apply([](const auto& scene) {
+        return scene.max_render_fps();
+    });
+}
+tl::expected<void, Plot_Set_Consumer_Feedback_Error>
+Render_Scene_2D::set_consumer_feedback(Frame_Consumer_Feedback feedback) {
+    return impl_->apply([feedback](auto& scene) {
+        return scene.set_consumer_feedback(feedback);
+    });
+}
+tl::expected<void, Plot_Clear_Consumer_Feedback_Error>
+Render_Scene_2D::clear_consumer_feedback() {
+    return impl_->apply([](auto& scene) {
+        return scene.clear_consumer_feedback();
+    });
+}
+Plot_Frame_Mode Render_Scene_2D::frame_mode() const noexcept {
+    return impl_->mode;
+}
+Plot_Frame_Status Render_Scene_2D::frame_status() const {
+    return impl_->apply([](const auto& scene) {
+        return scene.frame_status();
+    });
+}
+Low_Latency_Diagnostics Render_Scene_2D::diagnostics() const {
+    return impl_->apply([](const auto& scene) {
+        return scene.diagnostics();
+    });
+}
+Refresh_Control_Snapshot Render_Scene_2D::refresh_feedback_snapshot() const {
+    return impl_->apply(
+        [](const auto& scene) {
+            return scene.refresh_feedback_snapshot();
+        });
+}
+void Render_Scene_2D::set_presentation_sink(std::weak_ptr<Presentation_Sink> sink) {
+    impl_->apply([&sink](auto& scene) {
+        scene.set_presentation_sink(std::move(sink));
+    });
+}
+std::shared_ptr<Performance_Overlay> Render_Scene_2D::performance_overlay() const {
+    return impl_->apply([](const auto& scene) {
+        return scene.performance_overlay();
+    });
+}
+void Render_Scene_2D::set_performance_overlay(
+    std::shared_ptr<Performance_Overlay> overlay) {
+    impl_->apply([&overlay](auto& scene) {
+        scene.set_performance_overlay(std::move(overlay));
+    });
+}
+} // namespace renderive

render_2D/render_2D/scene/Render_Scene_2D.h

@@ -1,24 +1,17 @@
 #pragma once
-
 #include "../base/Types.h"
 #include "../event/Event.h"
 #include "../renderable/Renderable.h"
 #include "Plot_Frame_Status.h"
-
 #include <renderive/frame_control/Frame_Consumer_Feedback.hpp>
 #include <renderive/renderable/base/Renderive_Owner.hpp>
 #include <renderive/scene/base/Scene_Base.hpp>
-
 #include <functional>
 #include <tl/expected.hpp>
 #include <memory>
-
 class Scene_Base;
-
 namespace renderive {
-
 struct Performance_Overlay;
-
 struct Plot_Scene_Options {
     Plot_Frame_Mode frame_mode{Plot_Frame_Mode::Low_Latency};
 };
@@ -66,35 +59,29 @@ enum class Plot_Set_Consumer_Feedback_Error : std::uint8_t {
 enum class Plot_Clear_Consumer_Feedback_Error : std::uint8_t {
     unsupported_frame_mode
 };
-
 struct Presentation_Sink {
     virtual ~Presentation_Sink() = default;
     virtual void request_present(Rect dirty_rect) = 0;
 };
-
+class LIB_DECL Render_Scene_2D final {
-class LIB_DECL Plot_Scene final {
 public:
-    explicit Plot_Scene(Plot_Scene_Options options = {});
+    explicit Render_Scene_2D(Plot_Scene_Options options = {});
-    ~Plot_Scene();
+    ~Render_Scene_2D();
-
+    Render_Scene_2D(const Render_Scene_2D&) = delete;
-    Plot_Scene(const Plot_Scene&) = delete;
+    Render_Scene_2D& operator=(const Render_Scene_2D&) = delete;
-    Plot_Scene& operator=(const Plot_Scene&) = delete;
+    Render_Scene_2D(Render_Scene_2D&&) = delete;
-    Plot_Scene(Plot_Scene&&) = delete;
+    Render_Scene_2D& operator=(Render_Scene_2D&&) = delete;
-    Plot_Scene& operator=(Plot_Scene&&) = delete;
-
     void init();
     [[nodiscard]] ::renderive_Owner<Renderable> root_renderable() const;
     [[nodiscard]] Scene_2D_Base::Attach_Builder attach_builder();
     [[nodiscard]] Scene_Base::Edit_Operation edit_renderables(Scene_2D_Base::Renderable_Edit edit);
     [[nodiscard]] Scene_Base& render_scene() noexcept;
     [[nodiscard]] const Scene_Base& render_scene() const noexcept;
-
     void set_background_color(Color color);
     [[nodiscard]] Color background_color() const;
     void set_viewport_size(Size size);
     [[nodiscard]] Size viewport_size() const;
     void dispatch_event(const Event& event);
-
     [[nodiscard]] tl::expected<void, Plot_Prepare_Frame_Error> prepare_frame();
     [[nodiscard]] tl::expected<void, Plot_Refresh_Manual_Frame_Error> refresh_manual_frame();
     [[nodiscard]] tl::expected<void, Plot_Render_Prepared_Frame_Error> render_prepared_frame();
@@ -102,12 +89,10 @@ public:
     [[nodiscard]] tl::expected<Plot_Render_Status, Plot_Render_Frame_Error>
     render_frame(bool force = false);
     void with_frame(const std::function<void(Image_View)>& consumer);
-
     void activate_view();
     void deactivate_view() noexcept;
     [[nodiscard]] bool view_active() const noexcept;
     void request_redraw() noexcept;
-
     [[nodiscard]] tl::expected<void, Plot_Set_Max_Render_Fps_Error>
     set_max_render_fps(double fps);
     [[nodiscard]] tl::expected<void, Plot_Clear_Max_Render_Fps_Error> clear_max_render_fps();
@@ -116,19 +101,15 @@ public:
     set_consumer_feedback(Frame_Consumer_Feedback feedback);
     [[nodiscard]] tl::expected<void, Plot_Clear_Consumer_Feedback_Error>
     clear_consumer_feedback();
-
     [[nodiscard]] Plot_Frame_Mode frame_mode() const noexcept;
     [[nodiscard]] Plot_Frame_Status frame_status() const;
     [[nodiscard]] Low_Latency_Diagnostics diagnostics() const;
     [[nodiscard]] Refresh_Control_Snapshot refresh_feedback_snapshot() const;
-
     void set_presentation_sink(std::weak_ptr<Presentation_Sink> sink);
     [[nodiscard]] std::shared_ptr<Performance_Overlay> performance_overlay() const;
     void set_performance_overlay(std::shared_ptr<Performance_Overlay> overlay);
-
 private:
     struct Impl;
     std::unique_ptr<Impl> impl_;
 };
-
 } // namespace renderive

render_2D/render_2D/scene/detail/Plot_Scene_Model.hpp

@@ -1,6 +1,6 @@
 #pragma once
 #include <renderive/error/Error_Policy.hpp>
-#include "../Plot_Scene.h"
+#include "../Render_Scene_2D.h"
 #include "../../render/Blend2D_Cache.h"
 #include <renderive/base/observer/Observer.hpp>
 #include <renderive/frame_control/Frame_Consumer_Feedback.hpp>

render_2D/tests/render_2D_Frame_Pipeline_Tests.cpp

@@ -6,7 +6,7 @@
 namespace renderive {
 namespace {
 TEST(Renderive_Core2_Frame_Pipeline, ManualLifecycleSeparatesPrepareRefreshAndRender) {
-    Plot_Scene plot({.frame_mode = Plot_Frame_Mode::Manual});
+    Render_Scene_2D plot({.frame_mode = Plot_Frame_Mode::Manual});
     plot.init();
     plot.set_viewport_size({96, 54});
     ASSERT_TRUE(plot.prepare_frame());
@@ -35,7 +35,7 @@ TEST(Renderive_Core2_Frame_Pipeline, ManualLifecycleSeparatesPrepareRefreshAndRe
     EXPECT_EQ(plot.diagnostics().refresh.frame_count, 1u);
 }
 TEST(Renderive_Core2_Frame_Pipeline, HighFrequencyLowLatencyLifecycleExposesKernelTiming) {
-    Plot_Scene plot;
+    Render_Scene_2D plot;
     plot.init();
     plot.set_viewport_size({96, 54});
     EXPECT_TRUE(plot.set_max_render_fps(1'000'000'000.0));
@@ -68,7 +68,7 @@ TEST(Renderive_Core2_Frame_Pipeline, HighFrequencyLowLatencyLifecycleExposesKern
     EXPECT_EQ(refresh.next_refresh_interval_ns, snapshot.next_refresh_interval_ns);
 }
 TEST(Renderive_Core2_Frame_Pipeline, LowLatencyConsumerFeedbackFlowsThroughCore2IntoKernelScheduling) {
-    Plot_Scene plot;
+    Render_Scene_2D plot;
     plot.init();
     plot.set_viewport_size({96, 54});
     EXPECT_TRUE(plot.set_max_render_fps(100.0));
@@ -89,7 +89,7 @@ TEST(Renderive_Core2_Frame_Pipeline, LowLatencyConsumerFeedbackFlowsThroughCore2
     EXPECT_EQ(plot.refresh_feedback_snapshot().next_refresh_interval_ns, 40'000'000u);
 }
 TEST(Renderive_Core2_Frame_Pipeline, LowLatencyLimitsCanBeClearedIndependently) {
-    Plot_Scene plot;
+    Render_Scene_2D plot;
     plot.init();
     plot.set_viewport_size({96, 54});
     EXPECT_TRUE(plot.set_max_render_fps(100.0));
@@ -107,7 +107,7 @@ TEST(Renderive_Core2_Frame_Pipeline, LowLatencyLimitsCanBeClearedIndependently)
     EXPECT_TRUE(snapshot.limit_state == "paint_limited" || snapshot.limit_state == "render_limited");
 }
 TEST(Renderive_Core2_Frame_Pipeline, LowLatencyReplacementRetiresOldFrameWithoutPhantomPendingFrame) {
-    Plot_Scene plot;
+    Render_Scene_2D plot;
     plot.init();
     plot.set_viewport_size({64, 40});
     ASSERT_TRUE(plot.prepare_frame());
@@ -128,7 +128,7 @@ TEST(Renderive_Core2_Frame_Pipeline, LowLatencyReplacementRetiresOldFrameWithout
     EXPECT_EQ(snapshot.latest_sequence, 2u);
 }
 TEST(Renderive_Core2_Frame_Pipeline, LowLatencyDiscardAndEmptyRenderRemainObservable) {
-    Plot_Scene plot;
+    Render_Scene_2D plot;
     plot.init();
     plot.set_viewport_size({64, 40});
     ASSERT_TRUE(plot.prepare_frame());
@@ -151,7 +151,7 @@ TEST(Renderive_Core2_Frame_Pipeline, LowLatencyDiscardAndEmptyRenderRemainObserv
     EXPECT_EQ(snapshot.latest_sequence, 1u);
 }
 TEST(Renderive_Core2_Frame_Pipeline, ManualDiscardAndFailedRefreshUpdateObserverState) {
-    Plot_Scene plot({.frame_mode = Plot_Frame_Mode::Manual});
+    Render_Scene_2D plot({.frame_mode = Plot_Frame_Mode::Manual});
     plot.init();
     plot.set_viewport_size({64, 40});
     ASSERT_TRUE(plot.prepare_frame());
@@ -175,7 +175,7 @@ TEST(Renderive_Core2_Frame_Pipeline, ManualDiscardAndFailedRefreshUpdateObserver
     EXPECT_EQ(snapshot.paint_duration_ns, last_paint_duration_ns);
 }
 TEST(Renderive_Core2_Frame_Pipeline, PlaybackPreservesQueueDepthAndEmptyAcquireFailure) {
-    Plot_Scene plot({.frame_mode = Plot_Frame_Mode::Playback});
+    Render_Scene_2D plot({.frame_mode = Plot_Frame_Mode::Playback});
     plot.init();
     plot.set_viewport_size({64, 40});
     ASSERT_TRUE(plot.prepare_frame());
@@ -207,7 +207,7 @@ TEST(Renderive_Core2_Frame_Pipeline, PlaybackPreservesQueueDepthAndEmptyAcquireF
     EXPECT_EQ(snapshot.queue_wait_ns, last_queue_wait_ns);
 }
 TEST(Renderive_Core2_Frame_Pipeline, PlaybackFullCyclePreservesPreviouslyQueuedFrames) {
-    Plot_Scene plot({.frame_mode = Plot_Frame_Mode::Playback});
+    Render_Scene_2D plot({.frame_mode = Plot_Frame_Mode::Playback});
     plot.init();
     plot.set_viewport_size({96, 54});
     ASSERT_TRUE(plot.prepare_frame());
@@ -230,7 +230,7 @@ TEST(Renderive_Core2_Frame_Pipeline, PlaybackFullCyclePreservesPreviouslyQueuedF
 }
 TEST(Renderive_Core2_Frame_Pipeline, EveryModeHonorsActiveDirtyAndForceRenderGates) {
     const auto verify = [](Plot_Frame_Mode mode) {
-        Plot_Scene scene({.frame_mode = mode});
+        Render_Scene_2D scene({.frame_mode = mode});
         scene.init();
         scene.set_viewport_size({80, 45});
         EXPECT_FALSE(scene.view_active());
@@ -254,7 +254,7 @@ TEST(Renderive_Core2_Frame_Pipeline, EveryModeHonorsActiveDirtyAndForceRenderGat
     verify(Plot_Frame_Mode::Playback);
 }
 TEST(Renderive_Core2_Frame_Pipeline, FrequencyConfigurationRejectsInvalidValuesAndWrongModes) {
-    Plot_Scene low_latency;
+    Render_Scene_2D low_latency;
     EXPECT_EQ(low_latency.set_max_render_fps(0.0).error(), Plot_Set_Max_Render_Fps_Error::invalid_fps);
     EXPECT_EQ(low_latency.set_max_render_fps(-1.0).error(), Plot_Set_Max_Render_Fps_Error::invalid_fps);
     EXPECT_EQ(low_latency.set_max_render_fps(std::numeric_limits<double>::quiet_NaN()).error(),
@@ -263,8 +263,8 @@ TEST(Renderive_Core2_Frame_Pipeline, FrequencyConfigurationRejectsInvalidValuesA
               Plot_Set_Max_Render_Fps_Error::invalid_fps);
     EXPECT_TRUE(low_latency.set_max_render_fps(1'000.0));
     EXPECT_DOUBLE_EQ(low_latency.max_render_fps(), 1'000.0);
-    Plot_Scene manual({.frame_mode = Plot_Frame_Mode::Manual});
+    Render_Scene_2D manual({.frame_mode = Plot_Frame_Mode::Manual});
-    Plot_Scene playback({.frame_mode = Plot_Frame_Mode::Playback});
+    Render_Scene_2D playback({.frame_mode = Plot_Frame_Mode::Playback});
     EXPECT_EQ(manual.set_max_render_fps(60.0).error(), Plot_Set_Max_Render_Fps_Error::unsupported_frame_mode);
     EXPECT_EQ(playback.set_max_render_fps(60.0).error(), Plot_Set_Max_Render_Fps_Error::unsupported_frame_mode);
     const auto unsupported_refresh = playback.refresh_manual_frame();

render_2D/tests/render_2D_Integration_Tests.cpp

@@ -53,7 +53,7 @@ static_assert(!Legacy_Axis_Property_Api<Time_Axis>);
 static_assert(!Legacy_Time_Axis_Property_Api<Time_Axis>);
 
 TEST(Renderive_Core2, RootIdentityAndRefreshDiagnosticsComeFromKernelState) {
-    Plot_Scene plot;
+    Render_Scene_2D plot;
     plot.init();
     const auto root = plot.root_renderable();
     ASSERT_TRUE(root);
@@ -157,7 +157,7 @@ TEST(Renderive_Core2, BicubicHeatmapUsesRealCubicResampling) {
     EXPECT_NE(bilinear, bicubic);
 }
 TEST(Renderive_Core2, KernelSceneRendersBusinessObjectsIntoBlend2DFrame) {
-    Plot_Scene plot;
+    Render_Scene_2D plot;
     plot.init();
     plot.set_viewport_size({320, 180});
     plot.activate_view();
@@ -238,7 +238,7 @@ TEST(Renderive_Core2, KernelSceneRendersBusinessObjectsIntoBlend2DFrame) {
     EXPECT_NE(plot.render_frame().value(), Plot_Render_Status::rendered);
 }
 TEST(Renderive_Core2, StandaloneRenderableBuilderJoinsSceneOnlyInsideRuntimeEditor) {
-    Plot_Scene plot;
+    Render_Scene_2D plot;
     plot.init();
     const auto root = plot.root_renderable();
     const auto [frequency, power] = build_initial(plot, [&](auto& attach) {
@@ -274,7 +274,7 @@ TEST(Renderive_Core2, StandaloneRenderableBuilderJoinsSceneOnlyInsideRuntimeEdit
         }));
 }
 TEST(Renderive_Core2, TimeAxisUsesOneFontStateAndFormatsConfiguredLabels) {
-    Plot_Scene plot;
+    Render_Scene_2D plot;
     plot.init();
     const auto root = plot.root_renderable();
     auto axis = build_initial(plot, [&](auto& attach) {
@@ -292,7 +292,7 @@ TEST(Renderive_Core2, TimeAxisUsesOneFontStateAndFormatsConfiguredLabels) {
     EXPECT_EQ(axis->get<&Time_Axis::Properties::tick_label_spacing_px>(), 17);
 }
 TEST(Renderive_Core2, PerformanceOverlayConsumesKernelFrameDiagnostics) {
-    Plot_Scene plot;
+    Render_Scene_2D plot;
     plot.init();
     plot.set_viewport_size({160, 90});
     plot.activate_view();
@@ -313,7 +313,7 @@ TEST(Renderive_Core2, PerformanceOverlayConsumesKernelFrameDiagnostics) {
     EXPECT_DOUBLE_EQ(plot.max_render_fps(), 120.0);
 }
 TEST(Renderive_Core2, AllFrameControlModesUseKernelStrategiesAndExposeObservers) {
-    Plot_Scene manual({.frame_mode = Plot_Frame_Mode::Manual});
+    Render_Scene_2D manual({.frame_mode = Plot_Frame_Mode::Manual});
     manual.init();
     manual.set_viewport_size({64, 40});
     EXPECT_EQ(manual.frame_mode(), Plot_Frame_Mode::Manual);
@@ -326,7 +326,7 @@ TEST(Renderive_Core2, AllFrameControlModesUseKernelStrategiesAndExposeObservers)
     manual_observer = manual.frame_status();
     EXPECT_EQ(manual_observer.last_event, "rendered");
     EXPECT_EQ(manual_observer.consumed_frame_count, 1u);
-    Plot_Scene low_latency;
+    Render_Scene_2D low_latency;
     low_latency.init();
     low_latency.set_viewport_size({64, 40});
     low_latency.activate_view();
@@ -335,7 +335,7 @@ TEST(Renderive_Core2, AllFrameControlModesUseKernelStrategiesAndExposeObservers)
     EXPECT_EQ(low_latency.frame_mode(), Plot_Frame_Mode::Low_Latency);
     EXPECT_EQ(low_observer.last_event, "lifecycle_completed");
     EXPECT_EQ(low_observer.consumed_frame_count, 1u);
-    Plot_Scene playback({.frame_mode = Plot_Frame_Mode::Playback});
+    Render_Scene_2D playback({.frame_mode = Plot_Frame_Mode::Playback});
     playback.init();
     playback.set_viewport_size({64, 40});
     ASSERT_TRUE(playback.prepare_frame());
@@ -352,7 +352,7 @@ TEST(Renderive_Core2, AllFrameControlModesUseKernelStrategiesAndExposeObservers)
     EXPECT_EQ(playback_observer.consumed_frame_count, 1u);
 }
 TEST(Renderive_Core2, RetainedAxisAndTimeAxisApisRoundTripWithoutWebAdapters) {
-    Plot_Scene plot;
+    Render_Scene_2D plot;
     plot.init();
     const auto root = plot.root_renderable();
     ASSERT_TRUE(root);
@@ -434,7 +434,7 @@ TEST(Renderive_Core2, RetainedAxisAndTimeAxisApisRoundTripWithoutWebAdapters) {
     EXPECT_EQ(time_axis->tick_label(first), "01:02:03.004");
 }
 TEST(Renderive_Core2, RetainedSpectrumApisRoundTripAndMarkersRemainObservable) {
-    Plot_Scene plot;
+    Render_Scene_2D plot;
     plot.init();
     plot.set_viewport_size({360, 240});
     plot.activate_view();
@@ -523,7 +523,7 @@ TEST(Renderive_Core2, RetainedSpectrumApisRoundTripAndMarkersRemainObservable) {
     EXPECT_EQ(plot.render_frame(true).value(), Plot_Render_Status::rendered);
 }
 TEST(Renderive_Core2, RetainedHeatmapSweepAndTraceApisPreserveDataShapes) {
-    Plot_Scene plot;
+    Render_Scene_2D plot;
     plot.init();
     plot.set_viewport_size({420, 280});
     plot.activate_view();
@@ -637,7 +637,7 @@ TEST(Renderive_Core2, RetainedHeatmapSweepAndTraceApisPreserveDataShapes) {
     EXPECT_EQ(plot.render_frame(true).value(), Plot_Render_Status::rendered);
 }
 TEST(Renderive_Core2, RetainedSelectionAndConstellationApisDriveInteractionAndLayout) {
-    Plot_Scene plot;
+    Render_Scene_2D plot;
     plot.init();
     plot.set_viewport_size({360, 260});
     plot.activate_view();
@@ -716,7 +716,7 @@ TEST(Renderive_Core2, RetainedSelectionAndConstellationApisDriveInteractionAndLa
     EXPECT_EQ(plot.render_frame(true).value(), Plot_Render_Status::rendered);
 }
 TEST(Renderive_Core2, PlottablePropertiesPublishOnlyAtFrameBoundary) {
-    Plot_Scene plot;
+    Render_Scene_2D plot;
     plot.init();
     const auto root = plot.root_renderable();
     const auto [frequency, power, spectrum] = build_initial(plot, [&](auto& attach) {
@@ -746,7 +746,7 @@ TEST(Renderive_Core2, PlottablePropertiesPublishOnlyAtFrameBoundary) {
     ASSERT_TRUE(plot.render_prepared_frame());
 }
 TEST(Renderive_Core2, EveryStatefulRenderableOwnsItsStateObserver) {
-    Plot_Scene plot;
+    Render_Scene_2D plot;
     plot.init();
     const auto root = plot.root_renderable();
     const auto [frequency, power, spectrum] = build_initial(plot, [&](auto& attach) {
@@ -797,7 +797,7 @@ TEST(Renderive_Core2, EveryStatefulRenderableOwnsItsStateObserver) {
     EXPECT_EQ(spectrum->observation().event, Renderable_Observer_Event::Published);
 }
 TEST(Renderive_Core2, PlottableDataUpdatesReachKernelRealTimeDataStrategy) {
-    Plot_Scene plot;
+    Render_Scene_2D plot;
     plot.init();
     const auto root = plot.root_renderable();
     const auto [frequency, power, spectrum] = build_initial(plot, [&](auto& attach) {
@@ -871,7 +871,7 @@ TEST(Renderive_Core2, AxisRasterLayoutCoversAxisSwapAndEveryReversal) {
     EXPECT_DOUBLE_EQ(points.back().y, 30.0);
 }
 TEST(Renderive_Core2, PartitionedPlotsBuildPropertyDrivenRenderGraphs) {
-    Plot_Scene plot;
+    Render_Scene_2D plot;
     plot.init();
     plot.set_viewport_size({320, 180});
     const auto root = plot.root_renderable();
@@ -989,7 +989,7 @@ TEST(Renderive_Core2, AutomaticPartitioningSplitsOnlyForMeasuredBottlenecks) {
 }
 
 TEST(Renderive_Core2, DynamicWaterfallCaptureStressPreservesPlansSlotsAndExactSessions) {
-    Plot_Scene plot;
+    Render_Scene_2D plot;
     plot.init();
     plot.set_viewport_size({640, 360});
     const auto root = plot.root_renderable();
@@ -1053,7 +1053,7 @@ TEST(Renderive_Core2, DynamicWaterfallCaptureStressPreservesPlansSlotsAndExactSe
 }
 
 TEST(Renderive_Core2, PaintOnlyStyleChangesPreservePrepareCache) {
-    Plot_Scene plot;
+    Render_Scene_2D plot;
     plot.init();
     plot.set_viewport_size({320, 180});
     const auto root = plot.root_renderable();
@@ -1115,7 +1115,7 @@ TEST(Renderive_Core2, PaintOnlyStyleChangesPreservePrepareCache) {
         }));
 }
 TEST(Renderive_Core2, PlottableAxesAreDataDependenciesAndPaintOverlays) {
-    Plot_Scene plot;
+    Render_Scene_2D plot;
     plot.init();
     const auto root = plot.root_renderable();
     const auto [frequency, power, spectrum] = build_initial(plot, [&](auto& attach) {
@@ -1156,7 +1156,7 @@ TEST(Renderive_Core2, PlottableAxesAreDataDependenciesAndPaintOverlays) {
     EXPECT_LT(spectrum_position, power_position);
 }
 TEST(Renderive_Core2, InteractionOverlayPaintsAboveItsAxes) {
-    Plot_Scene plot;
+    Render_Scene_2D plot;
     plot.init();
     const auto root = plot.root_renderable();
     const auto [horizontal, vertical, selection] = build_initial(plot, [&](auto& attach) {

render_3D/render_3D/Render_Scene_3D.cpp

@@ -1,5 +1,5 @@
 #include <renderive/error/Error_Policy.hpp>
-#include "Point_Scene.h"
+#include "Render_Scene_3D.h"
 #include "Scene_Context.hpp"
 
 #include "detail/Datoviz_Visual_Backend.h"
@@ -609,7 +609,7 @@ std::unique_ptr<Scene_Model> make_scene_model(
 
 } // namespace
 
-struct Point_Scene::Impl {
+struct Render_Scene_3D::Impl {
     explicit Impl(const Scene_Options& options,
                   std::shared_ptr<Point_Visual> visual)
         : model(make_scene_model(options, std::move(visual))) {}
@@ -617,7 +617,7 @@ struct Point_Scene::Impl {
     std::unique_ptr<Scene_Model> model;
 };
 
-Point_Scene::Point_Scene(Scene_Options options,
+Render_Scene_3D::Render_Scene_3D(Scene_Options options,
                          std::shared_ptr<Point_Visual> visual) {
     if (!valid(options.viewport))
         ::renderive::error::unexpected<std::invalid_argument>("Point_Scene viewport must be nonempty");
@@ -630,26 +630,26 @@ Point_Scene::Point_Scene(Scene_Options options,
     impl_ = std::make_unique<Impl>(options, std::move(visual));
 }
 
-Point_Scene::~Point_Scene() = default;
+Render_Scene_3D::~Render_Scene_3D() = default;
 
-Scene_Control_Error Point_Scene::resize(Extent extent) {
+Scene_Control_Error Render_Scene_3D::resize(Extent extent) {
     if (!valid(extent))
         return Scene_Control_Error::empty_viewport;
     impl_->model->resize(extent);
     return Scene_Control_Error::none;
 }
-Scene_Control_Error Point_Scene::set_clear_color(Clear_Color color) {
+Scene_Control_Error Render_Scene_3D::set_clear_color(Clear_Color color) {
     if (!valid(color))
         return Scene_Control_Error::invalid_clear_color;
     impl_->model->set_clear_color(color);
     return Scene_Control_Error::none;
 }
 
-Scene_Control_Error Point_Scene::dispatch(const ::renderive::Event&) {
+Scene_Control_Error Render_Scene_3D::dispatch(const ::renderive::Event&) {
     return Scene_Control_Error::none;
 }
 
-Scene_Control_Error Point_Scene::dispatch_pointer(
+Scene_Control_Error Render_Scene_3D::dispatch_pointer(
     ::renderive::Event_Type type, float x, float y,
     ::renderive::Mouse_Button button, ::renderive::Mouse_Button_Mask,
     ::renderive::Keyboard_Modifier modifiers) {
@@ -662,7 +662,7 @@ Scene_Control_Error Point_Scene::dispatch_pointer(
     return impl_->model->dispatch_pointer(type, x, y, button, modifiers);
 }
 
-Scene_Control_Error Point_Scene::dispatch_wheel(
+Scene_Control_Error Render_Scene_3D::dispatch_wheel(
     float x, float y, float pixel_delta_x, float pixel_delta_y,
     float angle_delta_x, float angle_delta_y,
     ::renderive::Keyboard_Modifier modifiers) {
@@ -675,39 +675,39 @@ Scene_Control_Error Point_Scene::dispatch_wheel(
         datoviz_wheel_step(pixel_delta_y, angle_delta_y), modifiers);
 }
 
-Scene_Control_Error Point_Scene::dispatch(const ::renderive::Key_Event& event) {
+Scene_Control_Error Render_Scene_3D::dispatch(const ::renderive::Key_Event& event) {
     return impl_->model->dispatch_key(event);
 }
 
-Frame_Request_Result Point_Scene::prepare_frame() { return impl_->model->prepare_frame(); }
+Frame_Request_Result Render_Scene_3D::prepare_frame() { return impl_->model->prepare_frame(); }
-Frame_Request_Result Point_Scene::refresh_manual_frame() {
+Frame_Request_Result Render_Scene_3D::refresh_manual_frame() {
     return impl_->model->refresh_manual_frame();
 }
-bool Point_Scene::discard_pending_frame() {
+bool Render_Scene_3D::discard_pending_frame() {
     return impl_->model->discard_pending_frame();
 }
-Frame_Request_Result Point_Scene::render_prepared_frame() {
+Frame_Request_Result Render_Scene_3D::render_prepared_frame() {
     return impl_->model->render_prepared_frame();
 }
-Frame_Request_Result Point_Scene::request_frame() { return impl_->model->request_frame(); }
+Frame_Request_Result Render_Scene_3D::request_frame() { return impl_->model->request_frame(); }
 
-std::shared_ptr<const Pixel_Frame> Point_Scene::latest_frame() const {
+std::shared_ptr<const Pixel_Frame> Render_Scene_3D::latest_frame() const {
     return impl_->model->latest_frame();
 }
 
-Frame_Status Point_Scene::frame_status() const {
+Frame_Status Render_Scene_3D::frame_status() const {
     return impl_->model->frame_status();
 }
 
-Runtime_Statistics Point_Scene::runtime_statistics() const noexcept {
+Runtime_Statistics Render_Scene_3D::runtime_statistics() const noexcept {
     return impl_->model->runtime_statistics();
 }
 
-Scene_Base& Point_Scene::render_scene() noexcept {
+Scene_Base& Render_Scene_3D::render_scene() noexcept {
     return impl_->model->scene();
 }
 
-const Scene_Base& Point_Scene::render_scene() const noexcept {
+const Scene_Base& Render_Scene_3D::render_scene() const noexcept {
     return impl_->model->scene();
 }
 

render_3D/render_3D/Render_Scene_3D.h

@@ -1,25 +1,20 @@
 #pragma once
-
 #include "Point_Visual.h"
-
 #include <renderive/event/Event.hpp>
-
 #include <cstddef>
 #include <cstdint>
 #include <memory>
 #include <vector>
-
 class Scene_Base;
-
 namespace renderive::render_3d {
-
 struct Extent {
     std::uint32_t width{};
     std::uint32_t height{};
-    [[nodiscard]] constexpr bool empty() const noexcept { return width == 0 || height == 0; }
+    [[nodiscard]] constexpr bool empty() const noexcept {
+        return width == 0 || height == 0;
+    }
     bool operator==(const Extent&) const = default;
 };
-
 struct Clear_Color {
     float red{0.035F};
     float green{0.045F};
@@ -45,13 +40,11 @@ enum class Frame_Request_Result : std::uint8_t {
     external_failure,
     scene_shutting_down
 };
-
 enum class Frame_Mode : std::uint8_t {
     Manual,
     Low_Latency,
     Playback,
 };
-
 enum struct Visual_Family : std::uint8_t {
     Point,
     Splat,
@@ -69,7 +62,6 @@ enum struct Visual_Family : std::uint8_t {
     Text,
     Volume,
 };
-
 struct Scene_Options {
     Extent viewport{560, 320};
     Clear_Color clear_color;
@@ -79,13 +71,11 @@ struct Scene_Options {
     bool validation_enabled{};
     Visual_Family visual_family{Visual_Family::Point};
 };
-
 struct Pixel_Frame {
     Extent extent;
     std::uint64_t sequence{};
     std::vector<std::byte> rgba8;
 };
-
 struct Runtime_Admission_Statistics {
     std::size_t capacity{};
     std::size_t active{};
@@ -95,14 +85,12 @@ struct Runtime_Admission_Statistics {
     std::uint64_t backpressure_count{};
     std::uint64_t backpressure_wait_ns{};
 };
-
 struct Runtime_Statistics {
     Runtime_Admission_Statistics render_domain;
     Runtime_Admission_Statistics gpu_completion;
     std::uint64_t gpu_completion_fault_count{};
     std::uint64_t gpu_completion_abandoned_count{};
 };
-
 struct Frame_Status {
     Frame_Mode mode{Frame_Mode::Low_Latency};
     double frequency_hz{};
@@ -114,22 +102,18 @@ struct Frame_Status {
     std::uint64_t latest_sequence{};
     std::uint64_t next_refresh_interval_ns{};
 };
-
 // Owns frame scheduling and the single Datoviz mutation/render domain.
-class Point_Scene final {
+class Render_Scene_3D final {
 public:
-    Point_Scene(Scene_Options options, std::shared_ptr<Point_Visual> visual);
+    Render_Scene_3D(Scene_Options options, std::shared_ptr<Point_Visual> visual);
-    ~Point_Scene();
+    ~Render_Scene_3D();
-
+    Render_Scene_3D(const Render_Scene_3D&) = delete;
-    Point_Scene(const Point_Scene&) = delete;
+    Render_Scene_3D& operator=(const Render_Scene_3D&) = delete;
-    Point_Scene& operator=(const Point_Scene&) = delete;
+    Render_Scene_3D(Render_Scene_3D&&) = delete;
-    Point_Scene(Point_Scene&&) = delete;
+    Render_Scene_3D& operator=(Render_Scene_3D&&) = delete;
-    Point_Scene& operator=(Point_Scene&&) = delete;
-
     [[nodiscard]] Scene_Control_Error resize(Extent extent);
     [[nodiscard]] Scene_Control_Error set_clear_color(Clear_Color color);
     [[nodiscard]] Scene_Control_Error dispatch(const ::renderive::Event& event);
-
     template <::renderive::Event_Point Point_Type>
     [[nodiscard]] Scene_Control_Error dispatch(
         const ::renderive::Basic_Pointer_Event<Point_Type>& event) {
@@ -137,7 +121,6 @@ public:
                                 static_cast<float>(event.position.y), event.button,
                                 event.buttons, event.modifiers);
     }
-
     template <::renderive::Event_Point Point_Type>
     [[nodiscard]] Scene_Control_Error dispatch(
         const ::renderive::Basic_Wheel_Event<Point_Type>& event) {
@@ -148,34 +131,28 @@ public:
                               static_cast<float>(event.angle_delta_x),
                               static_cast<float>(event.angle_delta_y), event.modifiers);
     }
-
     [[nodiscard]] Scene_Control_Error dispatch(const ::renderive::Key_Event& event);
-
     // Frame strategy operations. request_frame() is the complete low-latency path.
     [[nodiscard]] Frame_Request_Result prepare_frame();
     [[nodiscard]] Frame_Request_Result refresh_manual_frame();
     [[nodiscard]] bool discard_pending_frame();
     [[nodiscard]] Frame_Request_Result render_prepared_frame();
     [[nodiscard]] Frame_Request_Result request_frame();
-
     [[nodiscard]] std::shared_ptr<const Pixel_Frame> latest_frame() const;
     [[nodiscard]] Frame_Status frame_status() const;
     [[nodiscard]] Runtime_Statistics runtime_statistics() const noexcept;
     [[nodiscard]] Scene_Base& render_scene() noexcept;
     [[nodiscard]] const Scene_Base& render_scene() const noexcept;
-
 private:
     [[nodiscard]] Scene_Control_Error dispatch_pointer(::renderive::Event_Type type, float x, float y,
-                          ::renderive::Mouse_Button button,
+                                                       ::renderive::Mouse_Button button,
-                          ::renderive::Mouse_Button_Mask buttons,
+                                                       ::renderive::Mouse_Button_Mask buttons,
-                          ::renderive::Keyboard_Modifier modifiers);
+                                                       ::renderive::Keyboard_Modifier modifiers);
     [[nodiscard]] Scene_Control_Error dispatch_wheel(float x, float y, float pixel_delta_x,
-                        float pixel_delta_y, float angle_delta_x,
+                                                     float pixel_delta_y, float angle_delta_x,
-                        float angle_delta_y,
+                                                     float angle_delta_y,
-                        ::renderive::Keyboard_Modifier modifiers);
+                                                     ::renderive::Keyboard_Modifier modifiers);
-
     struct Impl;
     std::unique_ptr<Impl> impl_;
 };
-
 } // namespace renderive::render_3d

render_3D/render_3D/detail/Point_Core.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "render_3D/Point_Scene.h"
+#include "render_3D/Render_Scene_3D.h"
 
 #include <array>
 #include <cstdint>

render_3D/tests/Point_Render_Integration_Tests.cpp

@@ -1,4 +1,4 @@
-#include "render_3D/Point_Scene.h"
+#include "render_3D/Render_Scene_3D.h"
 
 #include <renderive/scene/base/Scene_Base.hpp>
 
@@ -17,7 +17,7 @@ namespace {
 
 struct Test_Point_Scene {
     std::shared_ptr<Point_Visual> visual;
-    std::unique_ptr<Point_Scene> scene;
+    std::unique_ptr<Render_Scene_3D> scene;
 };
 
 Test_Point_Scene make_test_scene(Scene_Options options) {
@@ -31,7 +31,7 @@ Test_Point_Scene make_test_scene(Scene_Options options) {
     Point_State state;
     state.style = {{12, 16, 24, 255}, 2.0F, Point_Aspect::Outline};
     auto visual = Point_Visual::Builder{state}.build(std::move(points));
-    auto scene = std::make_unique<Point_Scene>(options, visual);
+    auto scene = std::make_unique<Render_Scene_3D>(options, visual);
     return {std::move(visual), std::move(scene)};
 }
 

web_server/app/Gallery_Observer_Adminive.h

@@ -3,7 +3,7 @@
 
 #include "Gallery_Enum.h"
 #include "common/Gallery_Performance_Types.h"
-#include "render_2D/scene/Plot_Scene.h"
+#include "render_2D/scene/Render_Scene_2D.h"
 #include "render_2D/renderable/Renderable.h"
 
 #include "adminive/adminive.hpp"

web_server/app/Gallery_Protocol.cpp

@@ -87,13 +87,13 @@ void append_session_actions(Gallery_Frame_Mode frame_mode,
                             std::vector<Action_Model>& result) {
     switch (frame_mode) {
     case Gallery_Frame_Mode::Manual:
-        append_gallery_actions<Gallery_Session_Control<Plot_Scene>>(result);
+        append_gallery_actions<Gallery_Session_Control<Render_Scene_2D>>(result);
         return;
     case Gallery_Frame_Mode::Low_Latency:
-        append_gallery_actions<Gallery_Session_Control<Plot_Scene>>(result);
+        append_gallery_actions<Gallery_Session_Control<Render_Scene_2D>>(result);
         return;
     case Gallery_Frame_Mode::Playback:
-        append_gallery_actions<Gallery_Session_Control<Plot_Scene>>(result);
+        append_gallery_actions<Gallery_Session_Control<Render_Scene_2D>>(result);
         return;
     }
     ::renderive::error::unexpected<std::invalid_argument>("unknown gallery frame mode");
@@ -103,11 +103,11 @@ std::size_t session_control_count(std::string_view case_id, Gallery_Frame_Mode f
         return 0;
     switch (frame_mode) {
     case Gallery_Frame_Mode::Manual:
-        return gallery_control_count<Gallery_Session_Control<Plot_Scene>>();
+        return gallery_control_count<Gallery_Session_Control<Render_Scene_2D>>();
     case Gallery_Frame_Mode::Low_Latency:
-        return gallery_control_count<Gallery_Session_Control<Plot_Scene>>();
+        return gallery_control_count<Gallery_Session_Control<Render_Scene_2D>>();
     case Gallery_Frame_Mode::Playback:
-        return gallery_control_count<Gallery_Session_Control<Plot_Scene>>();
+        return gallery_control_count<Gallery_Session_Control<Render_Scene_2D>>();
     }
     ::renderive::error::unexpected<std::invalid_argument>("unknown gallery frame mode");
 }

web_server/app/Gallery_Session_Control.h

@@ -1,7 +1,7 @@
 #pragma once
 #include "render_2D/plottable/Performance_Overlay.h"
 #include "render_2D/renderable/Renderable.h"
-#include "render_2D/scene/Plot_Scene.h"
+#include "render_2D/scene/Render_Scene_2D.h"
 #include <memory>
 #include <string>
 namespace adminive {

web_server/app/Web_Plot_Session.cpp

@@ -51,7 +51,7 @@ double gaussian(double x, double center, double width) {
 }
 } // namespace
 struct Web_Plot_Session::Impl {
-    Plot_Scene plot;
+    Render_Scene_2D plot;
     renderive_Owner<Frequency_Axis> spectrum_frequency_axis;
     renderive_Owner<Axis> spectrum_power_axis;
     renderive_Owner<Frequency_Axis> waterfall_frequency_axis;

web_server/app/render_2D/Gallery_Scene2D.cpp

@@ -218,7 +218,7 @@ public:
         }
         attach_performance_overlay(plot_);
         apply_layout();
-        session_control_ = std::make_unique<Gallery_Session_Control<Plot_Scene>>(
+        session_control_ = std::make_unique<Gallery_Session_Control<Render_Scene_2D>>(
             plot_, *primary_, feedback_policy_);
         register_controls();
         set_performance_plot_name(plot_, case_id_ + "/" + gallery_enum_id(frame_mode_));
@@ -1420,9 +1420,9 @@ private:
     std::string case_id_;
     Gallery_Frame_Mode frame_mode_ = Gallery_Frame_Mode::Low_Latency;
     bool automatic_low_latency_{};
-    Plot_Scene plot_;
+    Render_Scene_2D plot_;
     Gallery_Feedback_Policy feedback_policy_;
-    std::unique_ptr<Gallery_Session_Control<Plot_Scene>> session_control_;
+    std::unique_ptr<Gallery_Session_Control<Render_Scene_2D>> session_control_;
     Gallery_Controls controls_;
     std::chrono::steady_clock::time_point performance_started_;
     std::chrono::steady_clock::time_point last_performance_log_;

web_server/app/render_3D/Gallery_Scene3D.cpp

@@ -5,7 +5,7 @@
 #include "../Gallery_Enum.h"
 #include "../common/Gallery_Scheduler_Adminive.h"
 #include "../common/Pixel_Frame.h"
-#include <render_3D/Point_Scene.h>
+#include <render_3D/Render_Scene_3D.h>
 
 #include "adminive/adminive.hpp"
 #include "adminive/adapters/nlohmann_json.hpp"
@@ -681,7 +681,7 @@ private:
     bool automatic_low_latency_{};
     bool active_{true};
     std::shared_ptr<Point_Visual> visual_;
-    Point_Scene scene_;
+    Render_Scene_3D scene_;
     Gallery_Client_Performance client_performance_;
     float blue_offset_{};
     float projection_scale_{1.0F};