Add rendering pass sequence scaffolding

engine/src/Rendering/Pipelines/BuiltinForwardPipeline.cpp

@@ -16,6 +16,35 @@
 namespace XCEngine {
 namespace Rendering {
 namespace Pipelines {
+namespace Detail {
+
+class BuiltinForwardOpaquePass final : public RenderPass {
+public:
+    explicit BuiltinForwardOpaquePass(BuiltinForwardPipeline& pipeline)
+        : m_pipeline(pipeline) {
+    }
+
+    const char* GetName() const override {
+        return "BuiltinForwardOpaquePass";
+    }
+
+    bool Initialize(const RenderContext& context) override {
+        return m_pipeline.EnsureInitialized(context);
+    }
+
+    void Shutdown() override {
+        m_pipeline.DestroyPipelineResources();
+    }
+
+    bool Execute(const RenderPassContext& context) override {
+        return m_pipeline.ExecuteForwardOpaquePass(context);
+    }
+
+private:
+    BuiltinForwardPipeline& m_pipeline;
+};
+
+} // namespace Detail
 
 namespace {
 
@@ -101,21 +130,7 @@ RHI::GraphicsPipelineDesc CreatePipelineDesc(
     pipelineDesc.sampleCount = 1;
     ApplyMaterialRenderState(material, pipelineDesc);
 
-    RHI::InputElementDesc position = {};
-    position.semanticName = "POSITION";
-    position.semanticIndex = 0;
-    position.format = static_cast<uint32_t>(RHI::Format::R32G32B32A32_Float);
-    position.inputSlot = 0;
-    position.alignedByteOffset = 0;
-    pipelineDesc.inputLayout.elements.push_back(position);
-
-    RHI::InputElementDesc texcoord = {};
-    texcoord.semanticName = "TEXCOORD";
-    texcoord.semanticIndex = 0;
-    texcoord.format = static_cast<uint32_t>(RHI::Format::R32G32_Float);
-    texcoord.inputSlot = 0;
-    texcoord.alignedByteOffset = static_cast<uint32_t>(offsetof(Resources::StaticMeshVertex, uv0));
-    pipelineDesc.inputLayout.elements.push_back(texcoord);
+    pipelineDesc.inputLayout = BuiltinForwardPipeline::BuildInputLayout();
 
     if (backendType == RHI::RHIType::D3D12) {
         pipelineDesc.vertexShader.source.assign(
@@ -170,26 +185,66 @@ const Resources::Texture* FindMaterialTexture(const Resources::Material& materia
 
 } // namespace
 
+BuiltinForwardPipeline::BuiltinForwardPipeline() {
+    m_passSequence.AddPass(std::make_unique<Detail::BuiltinForwardOpaquePass>(*this));
+}
+
 BuiltinForwardPipeline::~BuiltinForwardPipeline() {
     Shutdown();
 }
 
+RHI::InputLayoutDesc BuiltinForwardPipeline::BuildInputLayout() {
+    RHI::InputLayoutDesc inputLayout = {};
+
+    RHI::InputElementDesc position = {};
+    position.semanticName = "POSITION";
+    position.semanticIndex = 0;
+    position.format = static_cast<uint32_t>(RHI::Format::R32G32B32_Float);
+    position.inputSlot = 0;
+    position.alignedByteOffset = 0;
+    inputLayout.elements.push_back(position);
+
+    RHI::InputElementDesc texcoord = {};
+    texcoord.semanticName = "TEXCOORD";
+    texcoord.semanticIndex = 0;
+    texcoord.format = static_cast<uint32_t>(RHI::Format::R32G32_Float);
+    texcoord.inputSlot = 0;
+    texcoord.alignedByteOffset = static_cast<uint32_t>(offsetof(Resources::StaticMeshVertex, uv0));
+    inputLayout.elements.push_back(texcoord);
+
+    return inputLayout;
+}
+
 bool BuiltinForwardPipeline::Initialize(const RenderContext& context) {
-    return EnsureInitialized(context);
+    return m_passSequence.Initialize(context);
 }
 
 void BuiltinForwardPipeline::Shutdown() {
-    DestroyPipelineResources();
+    m_passSequence.Shutdown();
 }
 
 bool BuiltinForwardPipeline::Render(
     const RenderContext& context,
     const RenderSurface& surface,
     const RenderSceneData& sceneData) {
-    if (!EnsureInitialized(context)) {
+    if (!Initialize(context)) {
         return false;
     }
 
+    const RenderPassContext passContext = {
+        context,
+        surface,
+        sceneData
+    };
+
+    return m_passSequence.Execute(passContext);
+}
+
+bool BuiltinForwardPipeline::ExecuteForwardOpaquePass(const RenderPassContext& passContext) {
+    const RenderContext& context = passContext.renderContext;
+    const RenderSurface& surface = passContext.surface;
+    const RenderSceneData& sceneData = passContext.sceneData;
+
     const std::vector<RHI::RHIResourceView*>& colorAttachments = surface.GetColorAttachments();
     if (colorAttachments.empty()) {
         return false;