From 8073e183188b4d3876c2bbc669d2c4876bca66b7 Mon Sep 17 00:00:00 2001 From: wyc <1104749580@qq.com> Date: Sun, 16 Aug 2026 21:50:12 +0800 Subject: [PATCH] =?UTF-8?q?=E6=94=B9=E5=90=8D?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Qt/bridge/Qt_Presentation_Sink.h | 2 +- Qt/plot/Plot.cpp | 4 +- Qt/plot/Plot.h | 2 +- Qt/plot/Plot_p.h | 2 +- render_2D/render_2D/export.h | 2 +- .../render_2D/plottable/Performance_Overlay.h | 18 +- render_2D/render_2D/scene/Plot_Scene.cpp | 203 ---------------- render_2D/render_2D/scene/Render_Scene_2D.cpp | 222 ++++++++++++++++++ .../scene/{Plot_Scene.h => Render_Scene_2D.h} | 33 +-- .../scene/detail/Plot_Scene_Model.hpp | 2 +- .../tests/render_2D_Frame_Pipeline_Tests.cpp | 26 +- .../tests/render_2D_Integration_Tests.cpp | 40 ++-- .../{Point_Scene.cpp => Render_Scene_3D.cpp} | 40 ++-- .../{Point_Scene.h => Render_Scene_3D.h} | 55 ++--- render_3D/render_3D/detail/Point_Core.h | 2 +- .../tests/Point_Render_Integration_Tests.cpp | 6 +- web_server/app/Gallery_Observer_Adminive.h | 2 +- web_server/app/Gallery_Protocol.cpp | 12 +- web_server/app/Gallery_Session_Control.h | 2 +- web_server/app/Web_Plot_Session.cpp | 2 +- web_server/app/render_2D/Gallery_Scene2D.cpp | 6 +- web_server/app/render_3D/Gallery_Scene3D.cpp | 4 +- 22 files changed, 332 insertions(+), 355 deletions(-) delete mode 100644 render_2D/render_2D/scene/Plot_Scene.cpp create mode 100644 render_2D/render_2D/scene/Render_Scene_2D.cpp rename render_2D/render_2D/scene/{Plot_Scene.h => Render_Scene_2D.h} (92%) rename render_3D/render_3D/{Point_Scene.cpp => Render_Scene_3D.cpp} (96%) rename render_3D/render_3D/{Point_Scene.h => Render_Scene_3D.h} (82%) diff --git a/Qt/bridge/Qt_Presentation_Sink.h b/Qt/bridge/Qt_Presentation_Sink.h index 6c30a56..c15b5a2 100644 --- a/Qt/bridge/Qt_Presentation_Sink.h +++ b/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 #include class QWidget; diff --git a/Qt/plot/Plot.cpp b/Qt/plot/Plot.cpp index 59a0e4c..d537da4 100644 --- a/Qt/plot/Plot.cpp +++ b/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()), continuous(continuous_rendering) {} + : scene(std::make_unique()), 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; } diff --git a/Qt/plot/Plot.h b/Qt/plot/Plot.h index c498fa0..3199634 100644 --- a/Qt/plot/Plot.h +++ b/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 root_renderable() const; void set_background_color(const QColor& color); ~Abs_Plot() override; diff --git a/Qt/plot/Plot_p.h b/Qt/plot/Plot_p.h index d984232..92fba51 100644 --- a/Qt/plot/Plot_p.h +++ b/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 scene; + std::unique_ptr scene; std::shared_ptr presentation_sink; QTimer* timer{}; bool continuous{}; diff --git a/render_2D/render_2D/export.h b/render_2D/render_2D/export.h index 25510fb..5602b3f 100644 --- a/render_2D/render_2D/export.h +++ b/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" diff --git a/render_2D/render_2D/plottable/Performance_Overlay.h b/render_2D/render_2D/plottable/Performance_Overlay.h index bc93631..df95a85 100644 --- a/render_2D/render_2D/plottable/Performance_Overlay.h +++ b/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 #include #include @@ -45,10 +45,10 @@ struct LIB_DECL Performance_Overlay { [[nodiscard]] bool enabled() const noexcept; [[nodiscard]] std::shared_ptr display_snapshot() const; private: - friend std::shared_ptr attach_performance_overlay(Plot_Scene&); - friend std::shared_ptr attach_performance_overlay(Plot_Scene&, const Performance_Overlay_Options&); - friend void set_performance_plot_name(Plot_Scene&, std::string); - friend void set_performance_overlay_enabled(Plot_Scene&, bool); + friend std::shared_ptr attach_performance_overlay(Render_Scene_2D&); + friend std::shared_ptr attach_performance_overlay(Render_Scene_2D&, const Performance_Overlay_Options&); + friend void set_performance_plot_name(Render_Scene_2D&, std::string); + friend void set_performance_overlay_enabled(Render_Scene_2D&, bool); struct Impl; std::unique_ptr impl_; void set_enabled(bool enabled); @@ -60,14 +60,14 @@ private: std::size_t renderable_count, Size viewport); }; -inline std::shared_ptr attach_performance_overlay(Plot_Scene& scene) { +inline std::shared_ptr attach_performance_overlay(Render_Scene_2D& scene) { if (auto existing = scene.performance_overlay()) return existing; auto overlay = std::make_shared(); scene.set_performance_overlay(overlay); return overlay; } -inline std::shared_ptr attach_performance_overlay(Plot_Scene& scene, const Performance_Overlay_Options& options) { +inline std::shared_ptr 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 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; diff --git a/render_2D/render_2D/scene/Plot_Scene.cpp b/render_2D/render_2D/scene/Plot_Scene.cpp deleted file mode 100644 index 6f093de..0000000 --- a/render_2D/render_2D/scene/Plot_Scene.cpp +++ /dev/null @@ -1,203 +0,0 @@ -#include -#include "Plot_Scene.h" -#include "detail/Plot_Scene_Model.hpp" -#include "../plottable/Performance_Overlay.h" -#include "../renderable/Renderable.h" -#include - -#include -#include - -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; -using Low_Latency_Plot_Scene = Plot_Scene_Model; -using Playback_Plot_Scene = Plot_Scene_Model; -} - -struct Plot_Scene::Impl { - using Model = std::variant, - std::unique_ptr, - std::unique_ptr>; - - explicit Impl(Plot_Frame_Mode mode) : mode(mode), model(create(mode)) {} - - template - decltype(auto) apply(Operation&& operation) { - return std::visit( - [&operation](auto& scene) -> decltype(auto) { - return operation(*scene); - }, - model); - } - - template - 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(); - case Plot_Frame_Mode::Low_Latency: - return std::make_unique(); - case Plot_Frame_Mode::Playback: - return std::make_unique(); - } - ::renderive::error::unexpected("unknown Plot_Scene frame mode"); - } - - Plot_Frame_Mode mode; - Model model; -}; - -Plot_Scene::Plot_Scene(Plot_Scene_Options options) - : impl_(std::make_unique(options.frame_mode)) {} - -Plot_Scene::~Plot_Scene() = default; - -void Plot_Scene::init() { impl_->apply([](auto& scene) { scene.init(); }); } - -renderive_Owner 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(render_scene()).attach_builder(); -} - -Scene_Base::Edit_Operation Plot_Scene::edit_renderables(Scene_2D_Base::Renderable_Edit edit) { - return static_cast(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 Plot_Scene::prepare_frame() { - return impl_->apply([](auto& scene) { return scene.prepare_frame(); }); -} - -tl::expected Plot_Scene::refresh_manual_frame() { - return impl_->apply([](auto& scene) { return scene.refresh_manual_frame(); }); -} - -tl::expected 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_Scene::render_frame(bool force) { - return impl_->apply([force](auto& scene) { return scene.render_frame(force); }); -} - -void Plot_Scene::with_frame(const std::function& 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 -Plot_Scene::set_max_render_fps(double fps) { - return impl_->apply([fps](auto& scene) { return scene.set_max_render_fps(fps); }); -} -tl::expected -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 -Plot_Scene::set_consumer_feedback(Frame_Consumer_Feedback feedback) { - return impl_->apply([feedback](auto& scene) { return scene.set_consumer_feedback(feedback); }); -} -tl::expected -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 sink) { - impl_->apply([&sink](auto& scene) { scene.set_presentation_sink(std::move(sink)); }); -} - -std::shared_ptr Plot_Scene::performance_overlay() const { - return impl_->apply([](const auto& scene) { return scene.performance_overlay(); }); -} - -void Plot_Scene::set_performance_overlay( - std::shared_ptr overlay) { - impl_->apply([&overlay](auto& scene) { - scene.set_performance_overlay(std::move(overlay)); - }); -} - -} // namespace renderive diff --git a/render_2D/render_2D/scene/Render_Scene_2D.cpp b/render_2D/render_2D/scene/Render_Scene_2D.cpp new file mode 100644 index 0000000..7ec6d62 --- /dev/null +++ b/render_2D/render_2D/scene/Render_Scene_2D.cpp @@ -0,0 +1,222 @@ +#include +#include "Render_Scene_2D.h" +#include "detail/Plot_Scene_Model.hpp" +#include "../plottable/Performance_Overlay.h" +#include "../renderable/Renderable.h" +#include +#include +#include +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; +using Low_Latency_Plot_Scene = Plot_Scene_Model; +using Playback_Plot_Scene = Plot_Scene_Model; +} +struct Render_Scene_2D::Impl { + using Model = std::variant, + std::unique_ptr, + std::unique_ptr>; + explicit Impl(Plot_Frame_Mode mode) : mode(mode), model(create(mode)) {} + template + decltype(auto) apply(Operation&& operation) { + return std::visit( + [&operation](auto& scene) -> decltype(auto) { + return operation(*scene); + }, + model); + } + template + 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(); + case Plot_Frame_Mode::Low_Latency: + return std::make_unique(); + case Plot_Frame_Mode::Playback: + return std::make_unique(); + } + ::renderive::error::unexpected("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(options.frame_mode)) {} +Render_Scene_2D::~Render_Scene_2D() = default; +void Render_Scene_2D::init() { + impl_->apply([](auto& scene) { + scene.init(); + }); +} +renderive_Owner 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(render_scene()).attach_builder(); +} +Scene_Base::Edit_Operation Render_Scene_2D::edit_renderables(Scene_2D_Base::Renderable_Edit edit) { + return static_cast(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 Render_Scene_2D::prepare_frame() { + return impl_->apply([](auto& scene) { + return scene.prepare_frame(); + }); +} +tl::expected Render_Scene_2D::refresh_manual_frame() { + return impl_->apply([](auto& scene) { + return scene.refresh_manual_frame(); + }); +} +tl::expected 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 +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& 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 +Render_Scene_2D::set_max_render_fps(double fps) { + return impl_->apply([fps](auto& scene) { + return scene.set_max_render_fps(fps); + }); +} +tl::expected +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 +Render_Scene_2D::set_consumer_feedback(Frame_Consumer_Feedback feedback) { + return impl_->apply([feedback](auto& scene) { + return scene.set_consumer_feedback(feedback); + }); +} +tl::expected +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 sink) { + impl_->apply([&sink](auto& scene) { + scene.set_presentation_sink(std::move(sink)); + }); +} +std::shared_ptr 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 overlay) { + impl_->apply([&overlay](auto& scene) { + scene.set_performance_overlay(std::move(overlay)); + }); +} +} // namespace renderive diff --git a/render_2D/render_2D/scene/Plot_Scene.h b/render_2D/render_2D/scene/Render_Scene_2D.h similarity index 92% rename from render_2D/render_2D/scene/Plot_Scene.h rename to render_2D/render_2D/scene/Render_Scene_2D.h index d2b4b56..d597b45 100644 --- a/render_2D/render_2D/scene/Plot_Scene.h +++ b/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 #include #include - #include #include #include - 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 Plot_Scene final { +class LIB_DECL Render_Scene_2D final { public: - explicit Plot_Scene(Plot_Scene_Options options = {}); - ~Plot_Scene(); - - Plot_Scene(const Plot_Scene&) = delete; - Plot_Scene& operator=(const Plot_Scene&) = delete; - Plot_Scene(Plot_Scene&&) = delete; - Plot_Scene& operator=(Plot_Scene&&) = delete; - + explicit Render_Scene_2D(Plot_Scene_Options options = {}); + ~Render_Scene_2D(); + Render_Scene_2D(const Render_Scene_2D&) = delete; + Render_Scene_2D& operator=(const Render_Scene_2D&) = delete; + Render_Scene_2D(Render_Scene_2D&&) = delete; + Render_Scene_2D& operator=(Render_Scene_2D&&) = delete; void init(); [[nodiscard]] ::renderive_Owner 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 prepare_frame(); [[nodiscard]] tl::expected refresh_manual_frame(); [[nodiscard]] tl::expected render_prepared_frame(); @@ -102,12 +89,10 @@ public: [[nodiscard]] tl::expected render_frame(bool force = false); void with_frame(const std::function& consumer); - void activate_view(); void deactivate_view() noexcept; [[nodiscard]] bool view_active() const noexcept; void request_redraw() noexcept; - [[nodiscard]] tl::expected set_max_render_fps(double fps); [[nodiscard]] tl::expected clear_max_render_fps(); @@ -116,19 +101,15 @@ public: set_consumer_feedback(Frame_Consumer_Feedback feedback); [[nodiscard]] tl::expected 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 sink); [[nodiscard]] std::shared_ptr performance_overlay() const; void set_performance_overlay(std::shared_ptr overlay); - private: struct Impl; std::unique_ptr impl_; }; - } // namespace renderive diff --git a/render_2D/render_2D/scene/detail/Plot_Scene_Model.hpp b/render_2D/render_2D/scene/detail/Plot_Scene_Model.hpp index ed517df..2b16a83 100644 --- a/render_2D/render_2D/scene/detail/Plot_Scene_Model.hpp +++ b/render_2D/render_2D/scene/detail/Plot_Scene_Model.hpp @@ -1,6 +1,6 @@ #pragma once #include -#include "../Plot_Scene.h" +#include "../Render_Scene_2D.h" #include "../../render/Blend2D_Cache.h" #include #include diff --git a/render_2D/tests/render_2D_Frame_Pipeline_Tests.cpp b/render_2D/tests/render_2D_Frame_Pipeline_Tests.cpp index f65c515..467d134 100644 --- a/render_2D/tests/render_2D_Frame_Pipeline_Tests.cpp +++ b/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::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}); - Plot_Scene playback({.frame_mode = Plot_Frame_Mode::Playback}); + Render_Scene_2D manual({.frame_mode = Plot_Frame_Mode::Manual}); + 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(); diff --git a/render_2D/tests/render_2D_Integration_Tests.cpp b/render_2D/tests/render_2D_Integration_Tests.cpp index 8bedb07..930c910 100644 --- a/render_2D/tests/render_2D_Integration_Tests.cpp +++ b/render_2D/tests/render_2D_Integration_Tests.cpp @@ -53,7 +53,7 @@ static_assert(!Legacy_Axis_Property_Api); static_assert(!Legacy_Time_Axis_Property_Api); 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) { diff --git a/render_3D/render_3D/Point_Scene.cpp b/render_3D/render_3D/Render_Scene_3D.cpp similarity index 96% rename from render_3D/render_3D/Point_Scene.cpp rename to render_3D/render_3D/Render_Scene_3D.cpp index 40a328b..ef26d59 100644 --- a/render_3D/render_3D/Point_Scene.cpp +++ b/render_3D/render_3D/Render_Scene_3D.cpp @@ -1,5 +1,5 @@ #include -#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 make_scene_model( } // namespace -struct Point_Scene::Impl { +struct Render_Scene_3D::Impl { explicit Impl(const Scene_Options& options, std::shared_ptr visual) : model(make_scene_model(options, std::move(visual))) {} @@ -617,7 +617,7 @@ struct Point_Scene::Impl { std::unique_ptr model; }; -Point_Scene::Point_Scene(Scene_Options options, +Render_Scene_3D::Render_Scene_3D(Scene_Options options, std::shared_ptr visual) { if (!valid(options.viewport)) ::renderive::error::unexpected("Point_Scene viewport must be nonempty"); @@ -630,26 +630,26 @@ Point_Scene::Point_Scene(Scene_Options options, impl_ = std::make_unique(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 Point_Scene::refresh_manual_frame() { +Frame_Request_Result Render_Scene_3D::prepare_frame() { return impl_->model->prepare_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 Point_Scene::latest_frame() const { +std::shared_ptr 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(); } diff --git a/render_3D/render_3D/Point_Scene.h b/render_3D/render_3D/Render_Scene_3D.h similarity index 82% rename from render_3D/render_3D/Point_Scene.h rename to render_3D/render_3D/Render_Scene_3D.h index 2567ce1..ed07e27 100644 --- a/render_3D/render_3D/Point_Scene.h +++ b/render_3D/render_3D/Render_Scene_3D.h @@ -1,25 +1,20 @@ #pragma once - #include "Point_Visual.h" - #include - #include #include #include #include - 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 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 visual); - ~Point_Scene(); - - Point_Scene(const Point_Scene&) = delete; - Point_Scene& operator=(const Point_Scene&) = delete; - Point_Scene(Point_Scene&&) = delete; - Point_Scene& operator=(Point_Scene&&) = delete; - + Render_Scene_3D(Scene_Options options, std::shared_ptr visual); + ~Render_Scene_3D(); + Render_Scene_3D(const Render_Scene_3D&) = delete; + Render_Scene_3D& operator=(const Render_Scene_3D&) = delete; + Render_Scene_3D(Render_Scene_3D&&) = delete; + Render_Scene_3D& operator=(Render_Scene_3D&&) = 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& event) { @@ -137,7 +121,6 @@ public: static_cast(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& event) { @@ -148,34 +131,28 @@ public: static_cast(event.angle_delta_x), static_cast(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 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_Mask buttons, - ::renderive::Keyboard_Modifier modifiers); + ::renderive::Mouse_Button button, + ::renderive::Mouse_Button_Mask buttons, + ::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 angle_delta_y, - ::renderive::Keyboard_Modifier modifiers); - + float pixel_delta_y, float angle_delta_x, + float angle_delta_y, + ::renderive::Keyboard_Modifier modifiers); struct Impl; std::unique_ptr impl_; }; - } // namespace renderive::render_3d diff --git a/render_3D/render_3D/detail/Point_Core.h b/render_3D/render_3D/detail/Point_Core.h index ef40fda..7f909ae 100644 --- a/render_3D/render_3D/detail/Point_Core.h +++ b/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 #include diff --git a/render_3D/tests/Point_Render_Integration_Tests.cpp b/render_3D/tests/Point_Render_Integration_Tests.cpp index 1446bfc..d87c95f 100644 --- a/render_3D/tests/Point_Render_Integration_Tests.cpp +++ b/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 @@ -17,7 +17,7 @@ namespace { struct Test_Point_Scene { std::shared_ptr visual; - std::unique_ptr scene; + std::unique_ptr 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(options, visual); + auto scene = std::make_unique(options, visual); return {std::move(visual), std::move(scene)}; } diff --git a/web_server/app/Gallery_Observer_Adminive.h b/web_server/app/Gallery_Observer_Adminive.h index a83321d..d1ee071 100644 --- a/web_server/app/Gallery_Observer_Adminive.h +++ b/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" diff --git a/web_server/app/Gallery_Protocol.cpp b/web_server/app/Gallery_Protocol.cpp index 1ff15ca..9dfdd59 100644 --- a/web_server/app/Gallery_Protocol.cpp +++ b/web_server/app/Gallery_Protocol.cpp @@ -87,13 +87,13 @@ void append_session_actions(Gallery_Frame_Mode frame_mode, std::vector& result) { switch (frame_mode) { case Gallery_Frame_Mode::Manual: - append_gallery_actions>(result); + append_gallery_actions>(result); return; case Gallery_Frame_Mode::Low_Latency: - append_gallery_actions>(result); + append_gallery_actions>(result); return; case Gallery_Frame_Mode::Playback: - append_gallery_actions>(result); + append_gallery_actions>(result); return; } ::renderive::error::unexpected("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>(); + return gallery_control_count>(); case Gallery_Frame_Mode::Low_Latency: - return gallery_control_count>(); + return gallery_control_count>(); case Gallery_Frame_Mode::Playback: - return gallery_control_count>(); + return gallery_control_count>(); } ::renderive::error::unexpected("unknown gallery frame mode"); } diff --git a/web_server/app/Gallery_Session_Control.h b/web_server/app/Gallery_Session_Control.h index 859f07f..48870b2 100644 --- a/web_server/app/Gallery_Session_Control.h +++ b/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 #include namespace adminive { diff --git a/web_server/app/Web_Plot_Session.cpp b/web_server/app/Web_Plot_Session.cpp index 6451a47..b8a1552 100644 --- a/web_server/app/Web_Plot_Session.cpp +++ b/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 spectrum_frequency_axis; renderive_Owner spectrum_power_axis; renderive_Owner waterfall_frequency_axis; diff --git a/web_server/app/render_2D/Gallery_Scene2D.cpp b/web_server/app/render_2D/Gallery_Scene2D.cpp index 1536448..7f54efd 100644 --- a/web_server/app/render_2D/Gallery_Scene2D.cpp +++ b/web_server/app/render_2D/Gallery_Scene2D.cpp @@ -218,7 +218,7 @@ public: } attach_performance_overlay(plot_); apply_layout(); - session_control_ = std::make_unique>( + session_control_ = std::make_unique>( 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> session_control_; + std::unique_ptr> session_control_; Gallery_Controls controls_; std::chrono::steady_clock::time_point performance_started_; std::chrono::steady_clock::time_point last_performance_log_; diff --git a/web_server/app/render_3D/Gallery_Scene3D.cpp b/web_server/app/render_3D/Gallery_Scene3D.cpp index bd44328..7543a61 100644 --- a/web_server/app/render_3D/Gallery_Scene3D.cpp +++ b/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 +#include #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 visual_; - Point_Scene scene_; + Render_Scene_3D scene_; Gallery_Client_Performance client_performance_; float blue_offset_{}; float projection_scale_{1.0F};