内核优化

Kernel/src/renderive/renderable/base/Renderable_Base.cpp

@@ -1,8 +1,11 @@
 #include "Renderable_Base.hpp"
+#include <stdexcept>
 #include "renderive/scene/base/Scene_Base.hpp"
-Renderable_Base::Renderable_Base(Scene_Base& scene, Renderable_Configuration configuration) noexcept
-    : scene(&scene), layer_node(this, scene.memory_resource()), dependency_node(this, scene.memory_resource()), configuration(configuration), memory_resource_(&scene.memory_resource()), task_graph_(*memory_resource_) {}
-Renderable_Base::~Renderable_Base() = default;
+Renderable_Base::Renderable_Base(Scene_Base& scene, Renderable_Configuration configuration)
+    : memory_domain_(scene.memory_domain_), real_time_data_state_(std::allocate_shared<Real_Time_Data_State>(Scene_Memory_Allocator<Real_Time_Data_State>{memory_domain_}, scene.scene_lifetime_)), discard_stale_frame_on_latest_data_update(real_time_data_state_->discard_stale_frame_on_latest_data_update), layer_node_(this, memory_domain_->resource()), dependency_node_(this, memory_domain_->resource()), configuration_(configuration) {}
+Renderable_Base::~Renderable_Base() {
+    real_time_data_state_->renderable_alive.store(false, std::memory_order_release);
+}
 void Renderable_Base::render(const Scene_Render_Context&) {}
 void Renderable_Base::invalidate_cache() noexcept {
     cache_revision_.fetch_add(1, std::memory_order_release);
@@ -14,22 +17,38 @@ std::uint64_t Renderable_Base::rendered_cache_revision() const noexcept {
     return rendered_cache_revision_.load(std::memory_order_acquire);
 }
 bool Renderable_Base::cache_valid() const noexcept {
-    return configuration.cache_enabled && rendered_cache_revision() == cache_revision();
+    return configuration().cache_enabled && rendered_cache_revision() == cache_revision();
 }
 void Renderable_Base::rebuild_task_graph() noexcept {
-    task_graph_ready_.store(false, std::memory_order_release);
+    {
+        std::lock_guard lock(task_graph_mutex_);
+        ++task_graph_revision_;
+    }
     invalidate_cache();
 }
-const Renderable_Task_Graph& Renderable_Base::task_graph() {
-    if (!task_graph_ready_.load(std::memory_order_acquire)) {
-        task_graph_.clear();
-        build_task_graph(task_graph_);
-        task_graph_ready_.store(true, std::memory_order_release);
+std::shared_ptr<const Renderable_Task_Graph> Renderable_Base::task_graph() {
+    std::lock_guard lock(task_graph_mutex_);
+    if (built_task_graph_revision_ != task_graph_revision_) {
+        auto graph = std::allocate_shared<Renderable_Task_Graph>(Scene_Memory_Allocator<Renderable_Task_Graph>{memory_domain_}, memory_domain_->resource());
+        build_task_graph(*graph);
+        task_graph_ = std::move(graph);
+        built_task_graph_revision_ = task_graph_revision_;
     }
     return task_graph_;
 }
 std::pmr::memory_resource& Renderable_Base::memory_resource() const noexcept {
-    return *memory_resource_;
+    return memory_domain_->resource();
+}
+Scene_Base& Renderable_Base::scene() const {
+    auto lease = real_time_data_state_->scene_lifetime->acquire();
+    if (!lease) {
+        throw std::logic_error("renderable scene is no longer alive");
+    }
+    return lease.scene();
+}
+Renderable_Configuration Renderable_Base::configuration() const noexcept {
+    std::lock_guard lock(configuration_mutex_);
+    return configuration_;
 }
 void Renderable_Base::build_task_graph(Renderable_Task_Graph& graph) {
     graph.emplace([this](const Scene_Render_Context& context) {
@@ -37,8 +56,13 @@ void Renderable_Base::build_task_graph(Renderable_Task_Graph& graph) {
     }, "render");
 }
 bool Renderable_Base::requires_render() const noexcept {
-    return !configuration.cache_enabled || !cache_valid();
+    const auto config = configuration();
+    return !config.cache_enabled || rendered_cache_revision() != cache_revision();
 }
-void Renderable_Base::mark_rendered() noexcept {
-    rendered_cache_revision_.store(cache_revision(), std::memory_order_release);
+void Renderable_Base::mark_rendered(std::uint64_t revision) noexcept {
+    rendered_cache_revision_.store(revision, std::memory_order_release);
+}
+void Renderable_Base::set_configuration(Renderable_Configuration configuration) noexcept {
+    std::lock_guard lock(configuration_mutex_);
+    configuration_ = configuration;
 }