核心模板架构

Kernel/tests/renderive/scene/Scene2D_Context_Test.cpp

@@ -0,0 +1,36 @@
+#include <gtest/gtest.h>
+#include <atomic>
+#include <memory>
+#include <thread>
+#include "renderive/renderable/Renderable.hpp"
+#include "renderive/scene/Scene.hpp"
+struct Scene2D_Context_Test_Renderable : Renderable_Base {
+    explicit Scene2D_Context_Test_Renderable(Scene_Base& scene) : Renderable_Base(scene, {.cache_enabled = false}) {}
+    void render(const Scene_Render_Context& context) override {
+        ++render_count;
+        scene_is_2d = dynamic_cast<Scene_2D_Base*>(context.scene) != nullptr;
+        render_thread = std::this_thread::get_id();
+    }
+    std::atomic<int> render_count{};
+    bool scene_is_2d{};
+    std::thread::id render_thread;
+};
+TEST(scene2d_context_test, swaps_renderable_cache_and_renders_in_background) {
+    Scene2D_Context<> scene;
+    const auto caller_thread = std::this_thread::get_id();
+    auto first = std::make_shared<Scene2D_Context_Test_Renderable>(scene);
+    auto second = std::make_shared<Scene2D_Context_Test_Renderable>(scene);
+    scene.attach_renderable(first);
+    scene.render();
+    scene.wait_for_render();
+    EXPECT_EQ(first->render_count.load(), 1);
+    EXPECT_TRUE(first->scene_is_2d);
+    EXPECT_NE(first->render_thread, caller_thread);
+    scene.detach_renderable(*first);
+    scene.attach_renderable(second);
+    scene.render();
+    scene.wait_for_render();
+    EXPECT_EQ(first->render_count.load(), 1);
+    EXPECT_EQ(second->render_count.load(), 1);
+    EXPECT_EQ(scene.frame_control_strategy->frame_control_state().publish_revision, 2);
+}

Kernel/tests/renderive/scene/Scene2D_Render_Order_Test.cpp

@@ -0,0 +1,33 @@
+#include <gtest/gtest.h>
+#include <cstdint>
+#include <memory>
+#include <vector>
+#include "renderive/renderable/Renderable.hpp"
+#include "renderive/scene/Scene.hpp"
+struct Scene2D_Render_Order_State {
+    std::vector<std::uint64_t> render_order;
+};
+struct Scene2D_Render_Order_Renderable : Renderable_Base {
+    Scene2D_Render_Order_Renderable(Scene_Base& scene, Scene2D_Render_Order_State& state, std::uint64_t id)
+        : Renderable_Base(scene, {.cache_enabled = false}), state(&state), id(id) {}
+    void render(const Scene_Render_Context& context) override {
+        state->render_order.push_back(id);
+        dynamic_cast<Recording_Color_Cache&>(*context.color_cache).append(id);
+    }
+    Scene2D_Render_Order_State* state;
+    std::uint64_t id;
+};
+TEST(scene2d_render_order_test, separates_dependency_order_from_display_order) {
+    Scene2D_Context<> scene;
+    Scene2D_Render_Order_State state;
+    auto spectrum = std::make_shared<Scene2D_Render_Order_Renderable>(scene, state, 2);
+    auto axis = std::make_shared<Scene2D_Render_Order_Renderable>(scene, state, 1);
+    scene.attach_renderable(spectrum);
+    scene.attach_renderable(axis);
+    axis->dependency_node.append_child(spectrum->dependency_node);
+    spectrum->layer_node.append_child(axis->layer_node);
+    scene.render();
+    scene.wait_for_render();
+    EXPECT_EQ(state.render_order, (std::vector<std::uint64_t>{1, 2}));
+    EXPECT_EQ(scene.final_color_cache.values, (std::vector<std::uint64_t>{2, 1}));
+}

Kernel/tests/renderive/scene/Scene3D_Context_Test.cpp

@@ -0,0 +1,23 @@
+#include <gtest/gtest.h>
+#include <atomic>
+#include <memory>
+#include "renderive/renderable/Renderable.hpp"
+#include "renderive/scene/Scene.hpp"
+struct Scene3D_Context_Test_Renderable : Renderable_Base {
+    explicit Scene3D_Context_Test_Renderable(Scene_Base& scene) : Renderable_Base(scene) {}
+    void render(const Scene_Render_Context& context) override {
+        scene_is_3d = dynamic_cast<Scene_3D_Base*>(context.scene) != nullptr;
+        ++render_count;
+    }
+    std::atomic<int> render_count{};
+    bool scene_is_3d{};
+};
+TEST(scene3d_context_test, uses_scene_3d_base_contract) {
+    Scene3D_Context<> scene;
+    auto renderable = std::make_shared<Scene3D_Context_Test_Renderable>(scene);
+    scene.attach_renderable(renderable);
+    scene.render();
+    scene.wait_for_render();
+    EXPECT_EQ(renderable->render_count.load(), 1);
+    EXPECT_TRUE(renderable->scene_is_3d);
+}

Kernel/tests/renderive/scene/Scene_State_Observer_Test.cpp

@@ -0,0 +1,36 @@
+#include <gtest/gtest.h>
+#include <cstdint>
+#include <memory>
+#include <vector>
+#include "renderive/scene/Scene.hpp"
+struct Scene_State_Observer_Test_State {
+    int value{};
+};
+struct Scene_State_Observer_Test_Time_Source {
+    std::uint64_t now_ns() const noexcept {
+        return 100;
+    }
+};
+struct Scene_State_Observer_Test_Data {
+    std::vector<Scene_Base::Observation_Event> events;
+};
+struct Scene_State_Observer_Test_Recorder {
+    static constexpr bool enabled = true;
+    std::shared_ptr<Scene_State_Observer_Test_Data> data{std::make_shared<Scene_State_Observer_Test_Data>()};
+    void observe(const Scene_Base::Observation& observation) noexcept {
+        data->events.push_back(observation.event);
+    }
+};
+using Scene_State_Observer_Test_Scene_Observer = Observer_State<Scene_State_Observer_Test_Recorder, Scene_State_Observer_Test_Time_Source>;
+using Scene_State_Observer_Test_State_Observer = Observer_State<>;
+TEST(scene_state_observer_test, scene_uses_triple_state_and_observes_lifecycle) {
+    Scene_State_Observer_Test_Recorder recorder;
+    using Scene = Scene2D_Context<Low_Latency_Strategy<Scene2D_Frame_Data>, Recording_Color_Cache, Scene_State_Observer_Test_State, Scene_State_Observer_Test_State_Observer, Scene_State_Observer_Test_Scene_Observer>;
+    Scene scene(With_Observer(Scene_State_Observer_Test_State_Observer{}), With_Observer(Scene_State_Observer_Test_Scene_Observer(recorder, Scene_State_Observer_Test_Time_Source{})));
+    scene.Scene_State_Strategy::set<&Scene_State_Observer_Test_State::value>(9);
+    scene.Scene_State_Strategy::publish();
+    scene.render();
+    scene.wait_for_render();
+    EXPECT_EQ(scene.Scene_State_Strategy::render_use_state().value, 9);
+    EXPECT_EQ(recorder.data->events, (std::vector<Scene_Base::Observation_Event>{Scene_Base::Observation_Event::render_submitted, Scene_Base::Observation_Event::render_started, Scene_Base::Observation_Event::render_completed}));
+}

Kernel/tests/renderive/scene/base/Scene_Base_Test.cpp

@@ -0,0 +1,23 @@
+#include <gtest/gtest.h>
+#include <memory>
+#include "renderive/renderable/Renderable.hpp"
+#include "renderive/scene/Scene.hpp"
+struct Scene_Base_Test_Renderable : Renderable_Base {
+    explicit Scene_Base_Test_Renderable(Scene_Base& scene) : Renderable_Base(scene) {}
+    void render(const Scene_Render_Context& context) override {
+        render_sequence = context.render_sequence;
+        ++render_count;
+    }
+    std::uint64_t render_sequence{};
+    int render_count{};
+};
+TEST(scene_base_test, publishes_renderable_collection_before_background_render) {
+    Scene2D_Context<> scene;
+    auto renderable = std::make_shared<Scene_Base_Test_Renderable>(scene);
+    scene.attach_renderable(renderable);
+    scene.render();
+    scene.wait_for_render();
+    EXPECT_EQ(renderable->render_count, 1);
+    EXPECT_EQ(renderable->render_sequence, 1);
+    EXPECT_EQ(scene.renderable_count(), 1);
+}

Kernel/tests/renderive/scene/concept/Scene_Test.cpp

@@ -0,0 +1,10 @@
+#include <gtest/gtest.h>
+#include "renderive/scene/Scene.hpp"
+static_assert(Scene<Scene2D_Context<>>);
+static_assert(Scene<Scene3D_Context<>>);
+static_assert(Scene_2D<Scene2D_Context<>>);
+static_assert(Scene_3D<Scene3D_Context<>>);
+static_assert(!Scene_3D<Scene2D_Context<>>);
+TEST(scene_concept_test, accepts_2d_and_3d_contexts) {
+    SUCCEED();
+}