Add rendering pass sequence scaffolding

tests/Rendering/unit/test_render_pass.cpp

@@ -0,0 +1,125 @@
+#include <gtest/gtest.h>
+
+#include <XCEngine/Rendering/RenderPass.h>
+#include <XCEngine/Rendering/RenderSceneExtractor.h>
+#include <XCEngine/Rendering/RenderSurface.h>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+using namespace XCEngine::Rendering;
+
+namespace {
+
+struct TrackingPassState {
+    std::vector<std::string> initializeOrder;
+    std::vector<std::string> executeOrder;
+    std::vector<std::string> shutdownOrder;
+};
+
+class TrackingPass final : public RenderPass {
+public:
+    TrackingPass(
+        std::string name,
+        TrackingPassState& state,
+        bool initializeResult = true,
+        bool executeResult = true)
+        : m_name(std::move(name))
+        , m_state(state)
+        , m_initializeResult(initializeResult)
+        , m_executeResult(executeResult) {
+    }
+
+    const char* GetName() const override {
+        return m_name.c_str();
+    }
+
+    bool Initialize(const RenderContext&) override {
+        m_state.initializeOrder.push_back(m_name);
+        return m_initializeResult;
+    }
+
+    void Shutdown() override {
+        m_state.shutdownOrder.push_back(m_name);
+    }
+
+    bool Execute(const RenderPassContext&) override {
+        m_state.executeOrder.push_back(m_name);
+        return m_executeResult;
+    }
+
+private:
+    std::string m_name;
+    TrackingPassState& m_state;
+    bool m_initializeResult = true;
+    bool m_executeResult = true;
+};
+
+RenderContext CreateValidContext() {
+    RenderContext context;
+    context.device = reinterpret_cast<XCEngine::RHI::RHIDevice*>(1);
+    context.commandList = reinterpret_cast<XCEngine::RHI::RHICommandList*>(1);
+    context.commandQueue = reinterpret_cast<XCEngine::RHI::RHICommandQueue*>(1);
+    return context;
+}
+
+} // namespace
+
+TEST(RenderPassSequence_Test, InitializesAndExecutesInInsertionOrderThenShutsDownInReverse) {
+    TrackingPassState state;
+    RenderPassSequence sequence;
+    sequence.AddPass(std::make_unique<TrackingPass>("SceneColor", state));
+    sequence.AddPass(std::make_unique<TrackingPass>("GridOverlay", state));
+    sequence.AddPass(std::make_unique<TrackingPass>("Outline", state));
+
+    ASSERT_EQ(sequence.GetPassCount(), 3u);
+
+    const RenderContext context = CreateValidContext();
+    ASSERT_TRUE(sequence.Initialize(context));
+
+    RenderSceneData sceneData;
+    const RenderSurface surface(1280, 720);
+    const RenderPassContext passContext = {
+        context,
+        surface,
+        sceneData
+    };
+
+    ASSERT_TRUE(sequence.Execute(passContext));
+    sequence.Shutdown();
+
+    EXPECT_EQ(
+        state.initializeOrder,
+        (std::vector<std::string>{ "SceneColor", "GridOverlay", "Outline" }));
+    EXPECT_EQ(
+        state.executeOrder,
+        (std::vector<std::string>{ "SceneColor", "GridOverlay", "Outline" }));
+    EXPECT_EQ(
+        state.shutdownOrder,
+        (std::vector<std::string>{ "Outline", "GridOverlay", "SceneColor" }));
+}
+
+TEST(RenderPassSequence_Test, StopsExecutingWhenAPassFails) {
+    TrackingPassState state;
+    RenderPassSequence sequence;
+    sequence.AddPass(std::make_unique<TrackingPass>("SceneColor", state));
+    sequence.AddPass(std::make_unique<TrackingPass>("SelectionMask", state, true, false));
+    sequence.AddPass(std::make_unique<TrackingPass>("Outline", state));
+
+    const RenderContext context = CreateValidContext();
+    ASSERT_TRUE(sequence.Initialize(context));
+
+    RenderSceneData sceneData;
+    const RenderSurface surface(640, 360);
+    const RenderPassContext passContext = {
+        context,
+        surface,
+        sceneData
+    };
+
+    EXPECT_FALSE(sequence.Execute(passContext));
+    EXPECT_EQ(
+        state.executeOrder,
+        (std::vector<std::string>{ "SceneColor", "SelectionMask" }));
+}