升级

render_2D/render_2D/plottable/Performance_Overlay.h

@@ -72,7 +72,6 @@ inline std::shared_ptr<Performance_Overlay> attach_performance_overlay(Render_Sc
 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();
         return existing;
     }
     auto overlay = std::make_shared<Performance_Overlay>(options);
@@ -83,13 +82,11 @@ 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(Render_Scene_2D& scene, bool enabled) {
     auto overlay = scene.performance_overlay();
     if (!overlay && !enabled) return;
     if (!overlay) overlay = attach_performance_overlay(scene);
     overlay->set_enabled(enabled);
-    scene.request_redraw();
 }
 } // namespace renderive

render_2D/render_2D/scene/Render_Scene_2D.cpp

@@ -80,7 +80,6 @@ struct detail::Render_Scene_2D::Impl
             });
         const auto published = scene_state.published_state();
         if (pending.viewport != published.viewport) invalidate_renderables();
-        else if (pending != published) scene().notify_model_dirty();
     }
     void swap_scene_state() override {
         scene_state.publish();
@@ -154,17 +153,15 @@ void detail::Render_Scene_2D::dispatch_event(const Event& event) {
         }
     }
 }
-auto detail::Render_Scene_2D::render_frame(bool force) -> Expected<Plot_Render_Status, Plot_Render_Frame_Error> {
-    if (!view_active() && !force) return Plot_Render_Status::view_inactive;
+auto detail::Render_Scene_2D::render_frame() -> Expected<Plot_Render_Status, Plot_Render_Frame_Error> {
+    if (!view_active()) return Plot_Render_Status::view_inactive;
     const Size viewport = get<&State::viewport>();
     if (viewport.empty()) return Plot_Render_Status::empty_viewport;
-    if (!d_func<Impl>().consume_model_dirty() && !force) return Plot_Render_Status::model_unchanged;
     const auto started = std::chrono::steady_clock::now();
     try {
         if (const auto result = d_func<Impl>().frame_control->request(*this); !result) return unexpected(result.error());
     }
     catch (...) {
-        notify_model_dirty();
         ::renderive::error::unexpected(
             "rolling back plot frame preparation",
             std::current_exception());
@@ -205,7 +202,6 @@ void detail::Render_Scene_2D::with_frame(
 }
 void detail::Render_Scene_2D::activate_view() {
     d_func<Impl>().active.store(true, std::memory_order_release);
-    notify_model_dirty();
 }
 void detail::Render_Scene_2D::deactivate_view() noexcept {
     d_func<Impl>().active.store(false, std::memory_order_release);
@@ -213,9 +209,6 @@ void detail::Render_Scene_2D::deactivate_view() noexcept {
 bool detail::Render_Scene_2D::view_active() const noexcept {
     return d_func<Impl>().active.load(std::memory_order_acquire);
 }
-void detail::Render_Scene_2D::request_redraw() noexcept {
-    notify_model_dirty();
-}
 void detail::Render_Scene_2D::set_presentation_sink(
     std::weak_ptr<Presentation_Sink> sink) {
     auto& impl = d_func<Impl>();
@@ -229,11 +222,8 @@ std::shared_ptr<Performance_Overlay> detail::Render_Scene_2D::performance_overla
 }
 void detail::Render_Scene_2D::set_performance_overlay(
     std::shared_ptr<Performance_Overlay> overlay) {
-    {
-        auto& impl = d_func<Impl>();
-        std::lock_guard lock(impl.control_mutex);
-        impl.performance = std::move(overlay);
-    }
-    notify_model_dirty();
+    auto& impl = d_func<Impl>();
+    std::lock_guard lock(impl.control_mutex);
+    impl.performance = std::move(overlay);
 }
 } // namespace renderive

render_2D/render_2D/scene/Render_Scene_2D.h

@@ -17,7 +17,6 @@ enum class Plot_Render_Status : std::uint8_t {
     rendered,
     view_inactive,
     empty_viewport,
-    model_unchanged
 };
 enum class Plot_Render_Frame_Error : std::uint8_t {
     painter_unavailable,
@@ -108,12 +107,11 @@ public:
     struct Observer : Base::template next_Observer<Observer>, Observer_Fields {};
     [[nodiscard]] ::renderive_Owner<::renderive::Renderable> root_renderable() const;
     void dispatch_event(const Event& event);
-    [[nodiscard]] auto render_frame(bool force = false) -> Expected<Plot_Render_Status, Plot_Render_Frame_Error>;
+    [[nodiscard]] auto render_frame() -> Expected<Plot_Render_Status, Plot_Render_Frame_Error>;
     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;
     void set_presentation_sink(std::weak_ptr<Presentation_Sink> sink);
     [[nodiscard]] std::shared_ptr<Performance_Overlay> performance_overlay() const;
     void set_performance_overlay(

render_2D/tests/render_2D_Frame_Pipeline_Tests.cpp

@@ -21,7 +21,7 @@ TEST(RenderScene2DFramePipeline, BuilderOwnsConstructionAndState) {
     EXPECT_EQ(scene->root_renderable()->object_name(), "root");
 }
 
-TEST(RenderScene2DFramePipeline, ActiveDirtyAndForceGatesAreOrthogonal) {
+TEST(RenderScene2DFramePipeline, SceneValidityDoesNotGateStrategyProgress) {
     Render_Scene_2D::State state;
     state.viewport = {80, 45};
     auto scene = make_scene(state);
@@ -30,8 +30,7 @@ TEST(RenderScene2DFramePipeline, ActiveDirtyAndForceGatesAreOrthogonal) {
     EXPECT_EQ(scene->render_frame().value(), Plot_Render_Status::view_inactive);
     scene->activate_view();
     EXPECT_EQ(scene->render_frame().value(), Plot_Render_Status::rendered);
-    EXPECT_EQ(scene->render_frame().value(), Plot_Render_Status::model_unchanged);
-    EXPECT_EQ(scene->render_frame(true).value(), Plot_Render_Status::rendered);
+    EXPECT_EQ(scene->render_frame().value(), Plot_Render_Status::rendered);
     EXPECT_EQ(scene->wait_for_render(), Scene_Render_Result::none);
 }
 
@@ -40,7 +39,7 @@ TEST(RenderScene2DFramePipeline, ObserverReadsPublishedDoubleBufferedState) {
     state.viewport = {32, 24};
     auto scene = make_scene(state);
     scene->activate_view();
-    ASSERT_EQ(scene->render_frame(true).value(), Plot_Render_Status::rendered);
+    ASSERT_EQ(scene->render_frame().value(), Plot_Render_Status::rendered);
     ASSERT_EQ(scene->wait_for_render(), Scene_Render_Result::none);
     const auto observation = scene->observer();
     EXPECT_EQ(observation.state, state);

render_2D/tests/render_2D_Integration_Tests.cpp

@@ -11,7 +11,7 @@ TEST(RenderScene2DIntegration, BuilderStatePublishesAtFrameBoundary) {
     auto scene = Render_Scene_2D::Builder{initial}.build(
         std::make_shared<Manual_Render_Scene_2D_Strategy>());
     scene->activate_view();
-    ASSERT_EQ(scene->render_frame(true).value(), Plot_Render_Status::rendered);
+    ASSERT_EQ(scene->render_frame().value(), Plot_Render_Status::rendered);
     ASSERT_EQ(scene->wait_for_render(), Scene_Render_Result::none);
     EXPECT_EQ(scene->observer().state, initial);
 }
@@ -22,7 +22,7 @@ TEST(RenderScene2DIntegration, FrameImageMatchesConfiguredViewport) {
     auto scene = Render_Scene_2D::Builder{state}.build(
         std::make_shared<Low_Latency_Render_Scene_2D_Strategy>());
     scene->activate_view();
-    ASSERT_EQ(scene->render_frame(true).value(), Plot_Render_Status::rendered);
+    ASSERT_EQ(scene->render_frame().value(), Plot_Render_Status::rendered);
     ASSERT_EQ(scene->wait_for_render(), Scene_Render_Result::none);
     scene->with_frame([](Image_View image) {
         EXPECT_EQ(image.width, 48);