3D快照删除

render_3D/render_3D/Render_Scene_3D.cpp

@@ -6,7 +6,7 @@
 #include "detail/Point_Core.h"
 #include "detail/Render_Domain.h"
 #include "frame_control/Point_Frame_Control.h"
-#include <renderive/state/Render_Acquired_State_Storage.hpp>
+#include <renderive/state/Published_State_Storage.hpp>
 #include <algorithm>
 #include <atomic>
 #include <chrono>
@@ -122,7 +122,7 @@ struct detail::Render_Scene_3D::Impl
   Scene_Base::Impl::Frame_Control_Capability,
   Scene_Base::Impl::Scene_State_Capability,
   Scene_Base::Impl::Renderer {
-    using State_Storage = Render_Acquired_State_Storage<
+    using State_Storage = Published_State_Storage<
         State, Atomic_Spin_Mutex, Observer_State<>>;
     using Observer = detail::Render_Scene_3D::Observer;
     static_assert(::renderive::inheritance::Inherits_Chain_Parent<
@@ -190,9 +190,6 @@ struct detail::Render_Scene_3D::Impl
         std::lock_guard lock(backend->frame_mutex);
         return backend->latest;
     }
-    [[nodiscard]] State render_state_snapshot() const {
-        return scene_state.render_state_snapshot();
-    }
     Node_Execution_Result render_scene(
         const Scene_Render_Context& context) {
         if (!backend_state->backend_available())
@@ -395,7 +392,7 @@ struct detail::Render_Scene_3D::Impl
             [](const State& value) {
                 return value;
             });
-        const auto published = scene_state.published_state_snapshot();
+        const auto published = scene_state.published_state();
         if (pending.viewport != published.viewport) invalidate_renderables();
         else if (pending != published) scene().notify_model_dirty();
     }
@@ -413,11 +410,11 @@ struct detail::Render_Scene_3D::Impl
         frame_control->replace(std::move(strategy));
     }
     std::uint64_t acquire_scene_state() override {
-        return scene_state.acquire_render_state();
+        return scene_state.state_revision();
     }
     void capture_scene_state(
         Frame_Render_Snapshot& snapshot) const override {
-        snapshot.set_scene_state(render_state_snapshot());
+        snapshot.set_scene_state(scene_state.published_state());
     }
     State_Storage scene_state;
     std::unique_ptr<detail::Point_Frame_Control> frame_control;
@@ -470,7 +467,7 @@ detail::Render_Scene_3D::Observer detail::Render_Scene_3D::capture_observation()
     const auto& impl = d_func<Impl>();
     const auto runtime = impl.frame_control->runtime();
     Observer result;
-    result.state = impl.scene_state.published_state_snapshot();
+    result.state = impl.scene_state.published_state();
     result.renderable_count = Scene_Base::renderable_count();
     result.point_count = impl.visual->point_count();
     result.frequency_hz = runtime->frequency_hz();

render_3D/render_3D/frame_control/Point_Frame_Control.cpp

@@ -2,7 +2,6 @@
 #include <renderive/base/adapter/Enum.hpp>
 #include <renderive/error/Error_Policy.hpp>
 #include <renderive/frame_control/Frame_Control.hpp>
-#include <atomic>
 #include <stdexcept>
 #include <utility>
 namespace renderive::render_3d::detail {
@@ -32,7 +31,7 @@ decltype(auto) visit(const Frame_Control_Strategy_Base& strategy,
 }
 } // namespace
 struct Point_Frame_Control::Impl {
-    std::atomic<std::shared_ptr<Frame_Control_Strategy_Base>> strategy;
+    std::shared_ptr<Frame_Control_Strategy_Base> strategy;
 };
 Point_Frame_Control::Point_Frame_Control(
     std::shared_ptr<Frame_Control_Strategy_Base> strategy) : impl_(std::make_unique<Impl>()) {
@@ -40,22 +39,21 @@ Point_Frame_Control::Point_Frame_Control(
 }
 Point_Frame_Control::~Point_Frame_Control() = default;
 std::shared_ptr<Frame_Control_Strategy_Base> Point_Frame_Control::runtime() {
-    return impl_->strategy.load(std::memory_order_acquire);
+    return impl_->strategy;
 }
 std::shared_ptr<const Frame_Control_Strategy_Base> Point_Frame_Control::runtime() const {
-    return impl_->strategy.load(std::memory_order_acquire);
+    return impl_->strategy;
 }
 Frame_Request_Result Point_Frame_Control::request(Render_Scene_3D& scene) {
-    const auto current = runtime();
-    const auto prepared = visit(*current, [&scene](auto& strategy) {
+    const auto prepared = visit(*impl_->strategy, [&scene](auto& strategy) {
         auto frame = strategy.acquire_painter();
         if (!frame) return false;
         scene.publish_frame_state(*frame);
         return true;
     });
     if (!prepared) return Frame_Request_Result::painter_unavailable;
-    if (auto* strategy = dynamic_cast<Manual_Strategy*>(current.get()); strategy && strategy->refresh() != Manual_Refresh_Result::none) return Frame_Request_Result::no_pending_frame;
-    return visit(*current, [&scene](auto& strategy) {
+    if (auto* strategy = dynamic_cast<Manual_Strategy*>(impl_->strategy.get()); strategy && strategy->refresh() != Manual_Refresh_Result::none) return Frame_Request_Result::no_pending_frame;
+    return visit(*impl_->strategy, [&scene](auto& strategy) {
         auto frame = strategy.acquire_renderer();
         if (!frame) return Frame_Request_Result::renderer_unavailable;
         const auto result = scene.Scene_Base::render(*frame);
@@ -73,6 +71,6 @@ void Point_Frame_Control::replace(
         ::renderive::error::unexpected<std::invalid_argument>(
             "Point_Scene requires a frame strategy");
     visit(*strategy, [](const auto&) {});
-    impl_->strategy.store(std::move(strategy), std::memory_order_release);
+    impl_->strategy = std::move(strategy);
 }
 } // namespace renderive::render_3d::detail