接入3D secene taskflow

Kernel/tests/renderive/scene/Scene3D_Context_Test.cpp

@@ -1,6 +1,8 @@
 #include <gtest/gtest.h>
+#include <algorithm>
 #include <atomic>
 #include <memory>
+#include <vector>
 #include "renderive/renderable/Renderable.hpp"
 #include "renderive/renderable/Renderable_Test_Harness.hpp"
 #include "renderive/scene/Scene.hpp"
@@ -23,6 +25,95 @@ TEST(scene3d_context_test, uses_scene_3d_base_contract) {
     EXPECT_EQ(renderable->render_count.load(), 1);
     EXPECT_TRUE(renderable->scene_is_3d);
 }
+
+struct Prepared_Mesh_Count {
+    std::size_t vertex_count{};
+};
+
+struct Scene3D_Prepared_Data_Renderable : Renderable_Test_Harness {
+    void prepare_for_test(const Prepare_Render_Context& context) override {
+        context.publish<Prepared_Mesh_Count>(
+            std::make_shared<const Prepared_Mesh_Count>(
+                Prepared_Mesh_Count{42}));
+    }
+};
+
+struct Scene3D_Render_Node_Test_Scene final
+    : Scene3D_Context<>, Scene_Renderer {
+    void render_scene(const Scene_Render_Context& context) override {
+        prepared = context.prepared<Prepared_Mesh_Count>(owner);
+    }
+
+    Renderable_Id owner{};
+    std::shared_ptr<const Prepared_Mesh_Count> prepared;
+};
+
+TEST(scene3d_context_test,
+     transfers_frame_local_prepared_data_to_single_scene_render_node) {
+    Scene3D_Render_Node_Test_Scene scene;
+    auto renderable = renderive_Owner<Scene3D_Prepared_Data_Renderable>::make();
+    scene.owner = renderable->renderable_id();
+    attach_initial(scene, renderable);
+    scene.render();
+    scene.wait_for_render();
+
+    ASSERT_TRUE(scene.prepared);
+    EXPECT_EQ(scene.prepared->vertex_count, 42U);
+    const auto plan = scene.render_plan_snapshot();
+    ASSERT_TRUE(plan);
+    const auto render_node = std::find_if(
+        plan->graph.nodes.begin(), plan->graph.nodes.end(),
+        [](const Render_Node& node) {
+            return node.kind == Render_Node_Kind::render;
+        });
+    ASSERT_NE(render_node, plan->graph.nodes.end());
+    EXPECT_TRUE(std::any_of(
+        plan->graph.edges.begin(), plan->graph.edges.end(),
+        [&](const Render_Edge& edge) {
+            return edge.to == render_node->node_id;
+        }));
+}
+
+struct Scene3D_Historical_State {
+    int value{};
+};
+
+struct Scene3D_Playback_Snapshot_Test_Scene final
+    : Scene3D_Context<Flow_Refresh_Strategy<Scene3D_Frame_Data>,
+                      Scene3D_Historical_State>,
+      Scene_Renderer {
+    void enqueue(int value) {
+        Scene_State_Strategy::set<&Scene3D_Historical_State::value>(value);
+        auto frame = frame_control.acquire_painter();
+        ASSERT_TRUE(frame);
+        publish_frame_state(*frame);
+    }
+
+    void render_next() {
+        auto frame = frame_control.acquire_renderer();
+        ASSERT_TRUE(frame);
+        render(*frame);
+        wait_for_render();
+    }
+
+    void render_scene(const Scene_Render_Context& context) override {
+        rendered.push_back(
+            context.frame.scene_state<Scene3D_Historical_State>().value);
+    }
+
+    std::vector<int> rendered;
+};
+
+TEST(scene3d_context_test,
+     playback_uses_the_scene_snapshot_captured_at_frame_publication) {
+    Scene3D_Playback_Snapshot_Test_Scene scene;
+    scene.enqueue(11);
+    scene.enqueue(23);
+    scene.render_next();
+    scene.render_next();
+    EXPECT_EQ(scene.rendered, (std::vector<int>{11, 23}));
+}
+
 struct Scene3D_Dependency_Cache_Test_Renderable : Renderable_Test_Harness {
     explicit Scene3D_Dependency_Cache_Test_Renderable()
         : Renderable_Test_Harness({.cache_enabled = true}) {}