仍然闪烁

Core/render/Render_Frame_Snapshot.cpp

@@ -1,4 +1,5 @@
 #include "Render_Frame_Snapshot.h"
+#include "../architecture/Renderable.h"
 #include "../architecture/Timeline_Stream.h"
 #include <algorithm>
 
@@ -8,6 +9,28 @@ bool Render_Frame_Snapshot::destroying() const {
     return !destroying_token || destroying_token->load(std::memory_order_acquire);
 }
 
+const Renderable_Frame_Node* Render_Frame_Snapshot::frame_node_for(const Renderable* renderable) const {
+    if (!renderable || !frame_tree)
+        return nullptr;
+    if (const auto* node = find_node(renderable->node_id()))
+        return node;
+    for (const auto& node : *frame_tree) {
+        if (node.renderable.get() == renderable)
+            return &node;
+    }
+    return nullptr;
+}
+
+const Renderable_Frame_Node* Render_Frame_Snapshot::find_node(Renderable_Id id) const {
+    if (!id || !frame_tree)
+        return nullptr;
+    for (const auto& node : *frame_tree) {
+        if (node.node_id == id)
+            return &node;
+    }
+    return nullptr;
+}
+
 std::shared_ptr<const Timeline_Stream_Snapshot> Render_Frame_Snapshot::timeline_snapshot(
     const std::shared_ptr<Timeline_Stream>& stream,
     int time_point_size,

Core/render/Render_Frame_Snapshot.h

@@ -2,6 +2,7 @@
 #include "../architecture/Update_Completion.h"
 #include "../base/Color.h"
 #include "../base/Geometry.h"
+#include "Renderable_Frame_Node.h"
 #include <atomic>
 #include <cstdint>
 #include <memory>
@@ -32,9 +33,12 @@ struct Render_Frame_Snapshot {
     std::uint64_t previous_frame_time_ns{};
     Frame_Lifecycle_Record* frame_metadata{};
     std::pmr::vector<std::shared_ptr<Update_State>>* frame_update_states{};
+    const Renderable_Frame_Tree* frame_tree{};
     mutable std::shared_ptr<Timeline_Stream_Frame_Cache> timeline_cache = std::make_shared<Timeline_Stream_Frame_Cache>();
 
     [[nodiscard]] bool destroying() const;
+    [[nodiscard]] const Renderable_Frame_Node* find_node(Renderable_Id id) const;
+    [[nodiscard]] const Renderable_Frame_Node* frame_node_for(const Renderable* renderable) const;
 
     [[nodiscard]] std::shared_ptr<const Timeline_Stream_Snapshot> timeline_snapshot(
         const std::shared_ptr<Timeline_Stream>& stream,

Core/render/Renderable_Frame_Node.h

@@ -1,4 +1,5 @@
 #pragma once
+#include "../architecture/Render_Data.h"
 #include <cstddef>
 #include <cstdint>
 #include <memory>
@@ -8,18 +9,27 @@
 namespace renderive {
 
 class Renderable;
+using Renderable_Id = std::uint64_t;
 
 struct Renderable_Frame_Node {
+    Renderable_Frame_Node() = default;
+    Renderable_Frame_Node(const Renderable_Frame_Node&) = delete;
+    Renderable_Frame_Node& operator=(const Renderable_Frame_Node&) = delete;
+    Renderable_Frame_Node(Renderable_Frame_Node&&) noexcept = default;
+    Renderable_Frame_Node& operator=(Renderable_Frame_Node&&) noexcept = default;
+    ~Renderable_Frame_Node() = default;
+
     std::shared_ptr<Renderable> renderable;
     std::size_t subtree_end{};
-    std::uint64_t node_id{};
-    std::uint64_t parent_node_id{};
+    Renderable_Id node_id{};
+    Renderable_Id parent_node_id{};
     std::string parent_object_name;
     int render_tree_depth{};
     std::string object_name;
-    std::uint64_t cache_parent_node_id{};
+    Renderable_Id cache_parent_node_id{};
     std::string cache_parent_object_name;
     int cache_tree_depth{};
+    Renderable_Frame_View frame_view;
 };
 
 using Renderable_Frame_Tree = std::vector<Renderable_Frame_Node>;