refactor(srp): bind managed fullscreen auxiliary inputs through render graph

engine/src/Rendering/Passes/BuiltinVectorFullscreenPass.cpp

@@ -2,10 +2,11 @@
 
 #include "Core/Asset/ResourceManager.h"
 #include "Debug/Logger.h"
-#include <XCEngine/Rendering/RenderPassGraphContract.h>
+#include "Rendering/Builtin/BuiltinPassLayoutUtils.h"
 #include "Rendering/Internal/RenderSurfacePipelineUtils.h"
 #include "Rendering/Internal/ShaderVariantUtils.h"
 #include "Rendering/RenderSurface.h"
+#include <XCEngine/Rendering/RenderPassGraphContract.h>
 #include "Resources/BuiltinResources.h"
 #include "RHI/RHICommandList.h"
 #include "RHI/RHIDescriptorPool.h"
@@ -16,7 +17,9 @@
 #include "RHI/RHIResourceView.h"
 #include "RHI/RHISampler.h"
 
+#include <algorithm>
 #include <utility>
+#include <vector>
 
 namespace XCEngine {
 namespace Rendering {
@@ -45,7 +48,8 @@ const Resources::ShaderPass* FindCompatiblePass(
         return nullptr;
     }
 
-    const Resources::ShaderPass* colorScalePass = shader.FindPass("ColorScale");
+    const Resources::ShaderPass* colorScalePass =
+        shader.FindPass("ColorScale");
     if (colorScalePass != nullptr &&
         ::XCEngine::Rendering::Internal::ShaderPassHasGraphicsVariants(
             shader,
@@ -55,13 +59,87 @@ const Resources::ShaderPass* FindCompatiblePass(
     }
 
     if (shader.GetPassCount() > 0 &&
-        ::XCEngine::Rendering::Internal::ShaderPassHasGraphicsVariants(shader, shader.GetPasses()[0].name, backend)) {
+        ::XCEngine::Rendering::Internal::ShaderPassHasGraphicsVariants(
+            shader,
+            shader.GetPasses()[0].name,
+            backend)) {
         return &shader.GetPasses()[0];
     }
 
     return nullptr;
 }
 
+bool UsesContiguousDescriptorSets(
+    const BuiltinPassResourceBindingPlan& bindingPlan) {
+    if (bindingPlan.bindings.Empty()) {
+        return true;
+    }
+
+    std::vector<bool> usedSets(
+        static_cast<size_t>(bindingPlan.maxSetIndex) + 1u,
+        false);
+    Core::uint32 minSet = UINT32_MAX;
+    Core::uint32 maxSet = 0u;
+    for (const BuiltinPassResourceBindingDesc& binding :
+         bindingPlan.bindings) {
+        usedSets[binding.location.set] = true;
+        minSet = std::min(minSet, binding.location.set);
+        maxSet = std::max(maxSet, binding.location.set);
+    }
+
+    for (Core::uint32 setIndex = minSet;
+         setIndex <= maxSet;
+         ++setIndex) {
+        if (!usedSets[setIndex]) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+bool IsSupportedFullscreenBindingPlan(
+    const BuiltinPassResourceBindingPlan& bindingPlan) {
+    if (!UsesContiguousDescriptorSets(bindingPlan)) {
+        return false;
+    }
+
+    for (const BuiltinPassResourceBindingDesc& binding :
+         bindingPlan.bindings) {
+        switch (binding.semantic) {
+        case BuiltinPassResourceSemantic::PassConstants:
+        case BuiltinPassResourceSemantic::SourceColorTexture:
+        case BuiltinPassResourceSemantic::MaterialTexture:
+        case BuiltinPassResourceSemantic::LinearClampSampler:
+            break;
+        default:
+            return false;
+        }
+    }
+
+    return true;
+}
+
+const RenderPassContext::TextureBindingView* FindTextureBindingView(
+    const RenderPassContext& context,
+    const BuiltinPassResourceBindingDesc& bindingDesc) {
+    auto matchesName =
+        [&bindingDesc](
+            const RenderPassContext::TextureBindingView& bindingView) {
+            return bindingView.resourceName ==
+                   bindingDesc.name;
+        };
+
+    const auto it =
+        std::find_if(
+            context.textureBindings.begin(),
+            context.textureBindings.end(),
+            matchesName);
+    return it != context.textureBindings.end()
+        ? &(*it)
+        : nullptr;
+}
+
 RHI::GraphicsPipelineDesc CreatePipelineDesc(
     RHI::RHIType backendType,
     RHI::RHIPipelineLayout* pipelineLayout,
@@ -70,34 +148,54 @@ RHI::GraphicsPipelineDesc CreatePipelineDesc(
     const RenderSurface& surface) {
     RHI::GraphicsPipelineDesc pipelineDesc = {};
     pipelineDesc.pipelineLayout = pipelineLayout;
-    pipelineDesc.topologyType = static_cast<uint32_t>(RHI::PrimitiveTopologyType::Triangle);
-    ::XCEngine::Rendering::Internal::ApplySingleColorAttachmentPropertiesToGraphicsPipelineDesc(
-        surface,
-        pipelineDesc);
-    pipelineDesc.depthStencilFormat = static_cast<uint32_t>(RHI::Format::Unknown);
+    pipelineDesc.topologyType = static_cast<uint32_t>(
+        RHI::PrimitiveTopologyType::Triangle);
+    ::XCEngine::Rendering::Internal::
+        ApplySingleColorAttachmentPropertiesToGraphicsPipelineDesc(
+            surface,
+            pipelineDesc);
+    pipelineDesc.depthStencilFormat = static_cast<uint32_t>(
+        RHI::Format::Unknown);
 
-    pipelineDesc.rasterizerState.fillMode = static_cast<uint32_t>(RHI::FillMode::Solid);
-    pipelineDesc.rasterizerState.cullMode = static_cast<uint32_t>(RHI::CullMode::None);
-    pipelineDesc.rasterizerState.frontFace = static_cast<uint32_t>(RHI::FrontFace::CounterClockwise);
+    pipelineDesc.rasterizerState.fillMode = static_cast<uint32_t>(
+        RHI::FillMode::Solid);
+    pipelineDesc.rasterizerState.cullMode = static_cast<uint32_t>(
+        RHI::CullMode::None);
+    pipelineDesc.rasterizerState.frontFace =
+        static_cast<uint32_t>(RHI::FrontFace::CounterClockwise);
     pipelineDesc.rasterizerState.depthClipEnable = true;
 
     pipelineDesc.blendState.blendEnable = false;
-    pipelineDesc.blendState.srcBlend = static_cast<uint32_t>(RHI::BlendFactor::One);
-    pipelineDesc.blendState.dstBlend = static_cast<uint32_t>(RHI::BlendFactor::Zero);
-    pipelineDesc.blendState.srcBlendAlpha = static_cast<uint32_t>(RHI::BlendFactor::One);
-    pipelineDesc.blendState.dstBlendAlpha = static_cast<uint32_t>(RHI::BlendFactor::Zero);
-    pipelineDesc.blendState.blendOp = static_cast<uint32_t>(RHI::BlendOp::Add);
-    pipelineDesc.blendState.blendOpAlpha = static_cast<uint32_t>(RHI::BlendOp::Add);
-    pipelineDesc.blendState.colorWriteMask = static_cast<uint8_t>(RHI::ColorWriteMask::All);
+    pipelineDesc.blendState.srcBlend = static_cast<uint32_t>(
+        RHI::BlendFactor::One);
+    pipelineDesc.blendState.dstBlend = static_cast<uint32_t>(
+        RHI::BlendFactor::Zero);
+    pipelineDesc.blendState.srcBlendAlpha =
+        static_cast<uint32_t>(RHI::BlendFactor::One);
+    pipelineDesc.blendState.dstBlendAlpha =
+        static_cast<uint32_t>(RHI::BlendFactor::Zero);
+    pipelineDesc.blendState.blendOp = static_cast<uint32_t>(
+        RHI::BlendOp::Add);
+    pipelineDesc.blendState.blendOpAlpha = static_cast<uint32_t>(
+        RHI::BlendOp::Add);
+    pipelineDesc.blendState.colorWriteMask =
+        static_cast<uint8_t>(RHI::ColorWriteMask::All);
 
     pipelineDesc.depthStencilState.depthTestEnable = false;
     pipelineDesc.depthStencilState.depthWriteEnable = false;
-    pipelineDesc.depthStencilState.depthFunc = static_cast<uint32_t>(RHI::ComparisonFunc::Always);
+    pipelineDesc.depthStencilState.depthFunc = static_cast<uint32_t>(
+        RHI::ComparisonFunc::Always);
 
-    const Resources::ShaderPass* shaderPass = shader.FindPass(passName);
-    const Resources::ShaderBackend backend = ::XCEngine::Rendering::Internal::ToShaderBackend(backendType);
+    const Resources::ShaderPass* shaderPass =
+        shader.FindPass(passName);
+    const Resources::ShaderBackend backend =
+        ::XCEngine::Rendering::Internal::ToShaderBackend(
+            backendType);
     if (const Resources::ShaderStageVariant* vertexVariant =
-            shader.FindVariant(passName, Resources::ShaderType::Vertex, backend)) {
+            shader.FindVariant(
+                passName,
+                Resources::ShaderType::Vertex,
+                backend)) {
         if (shaderPass != nullptr) {
             ::XCEngine::Rendering::Internal::ApplyShaderStageVariant(
                 shader.GetPath(),
@@ -108,7 +206,10 @@ RHI::GraphicsPipelineDesc CreatePipelineDesc(
         }
     }
     if (const Resources::ShaderStageVariant* fragmentVariant =
-            shader.FindVariant(passName, Resources::ShaderType::Fragment, backend)) {
+            shader.FindVariant(
+                passName,
+                Resources::ShaderType::Fragment,
+                backend)) {
         if (shaderPass != nullptr) {
             ::XCEngine::Rendering::Internal::ApplyShaderStageVariant(
                 shader.GetPath(),
@@ -132,7 +233,8 @@ BuiltinVectorFullscreenPass::BuiltinVectorFullscreenPass(
     , m_preferredPassName(std::move(preferredPassName))
     , m_vectorPayload(vectorPayload) {
     if (m_shaderPath.Empty()) {
-        m_shaderPath = Resources::GetBuiltinColorScalePostProcessShaderPath();
+        m_shaderPath =
+            Resources::GetBuiltinColorScalePostProcessShaderPath();
     }
 }
 
@@ -155,44 +257,56 @@ bool BuiltinVectorFullscreenPass::RecordRenderGraph(
         context);
 }
 
-bool BuiltinVectorFullscreenPass::Execute(const RenderPassContext& context) {
+bool BuiltinVectorFullscreenPass::Execute(
+    const RenderPassContext& context) {
     if (!context.renderContext.IsValid() ||
-        context.sourceSurface == nullptr ||
-        context.sourceColorView == nullptr) {
-        return false;
-    }
-    if (!::XCEngine::Rendering::Internal::HasSingleColorAttachment(*context.sourceSurface)) {
+        !::XCEngine::Rendering::Internal::HasSingleColorAttachment(
+            context.surface)) {
         return false;
     }
 
-    const std::vector<RHI::RHIResourceView*>& colorAttachments = context.surface.GetColorAttachments();
-    if (!::XCEngine::Rendering::Internal::HasSingleColorAttachment(context.surface) ||
-        colorAttachments.empty() ||
+    const std::vector<RHI::RHIResourceView*>& colorAttachments =
+        context.surface.GetColorAttachments();
+    if (colorAttachments.empty() ||
         colorAttachments[0] == nullptr) {
         return false;
     }
 
-    const Math::RectInt renderArea = context.surface.GetRenderArea();
-    if (renderArea.width <= 0 || renderArea.height <= 0) {
+    const Math::RectInt renderArea =
+        context.surface.GetRenderArea();
+    if (renderArea.width <= 0 ||
+        renderArea.height <= 0) {
         return false;
     }
 
-    if (!EnsureInitialized(context.renderContext, context.surface)) {
+    if (!EnsureInitialized(
+            context.renderContext,
+            context.surface)) {
         return false;
     }
 
-    PostProcessConstants constants = {};
-    constants.vectorPayload = m_vectorPayload;
-    m_constantsSet.set->WriteConstant(0, &constants, sizeof(constants));
-
-    if (m_boundSourceColorView != context.sourceColorView) {
-        m_textureSet.set->Update(0, context.sourceColorView);
-        m_boundSourceColorView = context.sourceColorView;
+    if (m_passLayout.sourceColorTexture.IsValid() &&
+        (context.sourceSurface == nullptr ||
+         context.sourceColorView == nullptr)) {
+        return false;
     }
 
-    RHI::RHICommandList* commandList = context.renderContext.commandList;
-    RHI::RHIResourceView* renderTarget = colorAttachments[0];
-    const bool autoTransitionSource = context.sourceSurface->IsAutoTransitionEnabled();
+    if (!UpdateDescriptorSets(context)) {
+        return false;
+    }
+
+    RHI::RHICommandList* commandList =
+        context.renderContext.commandList;
+    if (commandList == nullptr) {
+        return false;
+    }
+
+    RHI::RHIResourceView* renderTarget =
+        colorAttachments[0];
+    const bool autoTransitionSource =
+        m_passLayout.sourceColorTexture.IsValid() &&
+        context.sourceSurface != nullptr &&
+        context.sourceSurface->IsAutoTransitionEnabled();
 
     if (context.surface.IsAutoTransitionEnabled()) {
         commandList->TransitionBarrier(
@@ -200,13 +314,16 @@ bool BuiltinVectorFullscreenPass::Execute(const RenderPassContext& context) {
             context.surface.GetColorStateBefore(),
             RHI::ResourceStates::RenderTarget);
     }
-    if (autoTransitionSource) {
-        commandList->TransitionBarrier(
-            context.sourceColorView,
-            context.sourceColorState,
-            RHI::ResourceStates::PixelShaderResource);
-    } else if (context.sourceColorState != RHI::ResourceStates::PixelShaderResource) {
-        return false;
+    if (m_passLayout.sourceColorTexture.IsValid()) {
+        if (autoTransitionSource) {
+            commandList->TransitionBarrier(
+                context.sourceColorView,
+                context.sourceColorState,
+                RHI::ResourceStates::PixelShaderResource);
+        } else if (context.sourceColorState !=
+                   RHI::ResourceStates::PixelShaderResource) {
+            return false;
+        }
     }
 
     commandList->SetRenderTargets(1, &renderTarget, nullptr);
@@ -228,15 +345,38 @@ bool BuiltinVectorFullscreenPass::Execute(const RenderPassContext& context) {
 
     commandList->SetViewport(viewport);
     commandList->SetScissorRect(scissorRect);
-    commandList->SetPrimitiveTopology(RHI::PrimitiveTopology::TriangleList);
+    commandList->SetPrimitiveTopology(
+        RHI::PrimitiveTopology::TriangleList);
     commandList->SetPipelineState(m_pipelineState);
 
-    RHI::RHIDescriptorSet* descriptorSets[] = {
-        m_constantsSet.set,
-        m_textureSet.set,
-        m_samplerSet.set
-    };
-    commandList->SetGraphicsDescriptorSets(0, 3, descriptorSets, m_pipelineLayout);
+    if (m_passLayout.descriptorSetCount > 0u) {
+        std::vector<RHI::RHIDescriptorSet*> descriptorSets(
+            m_passLayout.descriptorSetCount,
+            nullptr);
+        for (Core::uint32 descriptorOffset = 0u;
+             descriptorOffset < m_passLayout.descriptorSetCount;
+             ++descriptorOffset) {
+            const Core::uint32 setIndex =
+                m_passLayout.firstDescriptorSet +
+                descriptorOffset;
+            if (setIndex >=
+                    m_passLayout.descriptorSets.size() ||
+                m_passLayout.descriptorSets[setIndex].set ==
+                    nullptr) {
+                return false;
+            }
+
+            descriptorSets[descriptorOffset] =
+                m_passLayout.descriptorSets[setIndex].set;
+        }
+
+        commandList->SetGraphicsDescriptorSets(
+            m_passLayout.firstDescriptorSet,
+            m_passLayout.descriptorSetCount,
+            descriptorSets.data(),
+            m_passLayout.pipelineLayout);
+    }
+
     commandList->Draw(3, 1, 0, 0);
     commandList->EndRenderPass();
 
@@ -246,7 +386,8 @@ bool BuiltinVectorFullscreenPass::Execute(const RenderPassContext& context) {
             RHI::ResourceStates::RenderTarget,
             context.surface.GetColorStateAfter());
     }
-    if (autoTransitionSource) {
+    if (m_passLayout.sourceColorTexture.IsValid() &&
+        autoTransitionSource) {
         commandList->TransitionBarrier(
             context.sourceColorView,
             RHI::ResourceStates::PixelShaderResource,
@@ -260,7 +401,8 @@ void BuiltinVectorFullscreenPass::Shutdown() {
     DestroyResources();
 }
 
-void BuiltinVectorFullscreenPass::SetVectorPayload(const Math::Vector4& vectorPayload) {
+void BuiltinVectorFullscreenPass::SetVectorPayload(
+    const Math::Vector4& vectorPayload) {
     m_vectorPayload = vectorPayload;
 }
 
@@ -268,7 +410,8 @@ const Math::Vector4& BuiltinVectorFullscreenPass::GetVectorPayload() const {
     return m_vectorPayload;
 }
 
-void BuiltinVectorFullscreenPass::SetShaderPath(const Containers::String& shaderPath) {
+void BuiltinVectorFullscreenPass::SetShaderPath(
+    const Containers::String& shaderPath) {
     if (m_shaderPath == shaderPath) {
         return;
     }
@@ -291,7 +434,8 @@ void BuiltinVectorFullscreenPass::SetPreferredPassName(
     m_preferredPassName = preferredPassName;
 }
 
-const Containers::String& BuiltinVectorFullscreenPass::GetPreferredPassName() const {
+const Containers::String&
+BuiltinVectorFullscreenPass::GetPreferredPassName() const {
     return m_preferredPassName;
 }
 
@@ -299,22 +443,25 @@ bool BuiltinVectorFullscreenPass::EnsureInitialized(
     const RenderContext& renderContext,
     const RenderSurface& surface) {
     const RHI::Format renderTargetFormat =
-        ::XCEngine::Rendering::Internal::ResolveSurfaceColorFormat(surface, 0u);
+        ::XCEngine::Rendering::Internal::ResolveSurfaceColorFormat(
+            surface,
+            0u);
     const uint32_t renderTargetSampleCount =
-        ::XCEngine::Rendering::Internal::ResolveSurfaceSampleCount(surface);
+        ::XCEngine::Rendering::Internal::ResolveSurfaceSampleCount(
+            surface);
     const uint32_t renderTargetSampleQuality =
-        ::XCEngine::Rendering::Internal::ResolveSurfaceSampleQuality(surface);
+        ::XCEngine::Rendering::Internal::ResolveSurfaceSampleQuality(
+            surface);
     if (m_device == renderContext.device &&
         m_backendType == renderContext.backendType &&
         m_renderTargetFormat == renderTargetFormat &&
-        m_renderTargetSampleCount == renderTargetSampleCount &&
-        m_renderTargetSampleQuality == renderTargetSampleQuality &&
-        m_pipelineLayout != nullptr &&
+        m_renderTargetSampleCount ==
+            renderTargetSampleCount &&
+        m_renderTargetSampleQuality ==
+            renderTargetSampleQuality &&
+        m_passLayout.pipelineLayout != nullptr &&
         m_pipelineState != nullptr &&
-        m_sampler != nullptr &&
-        m_constantsSet.set != nullptr &&
-        m_textureSet.set != nullptr &&
-        m_samplerSet.set != nullptr) {
+        m_sampler != nullptr) {
         return true;
     }
 
@@ -330,38 +477,98 @@ bool BuiltinVectorFullscreenPass::CreateResources(
     }
 
     RHI::Format renderTargetFormat = RHI::Format::Unknown;
-    if (!::XCEngine::Rendering::Internal::TryResolveSingleColorAttachmentFormat(surface, renderTargetFormat)) {
+    if (!::XCEngine::Rendering::Internal::
+            TryResolveSingleColorAttachmentFormat(
+                surface,
+                renderTargetFormat)) {
         Debug::Logger::Get().Error(
             Debug::LogCategory::Rendering,
-            "BuiltinVectorFullscreenPass requires exactly one valid destination color attachment");
+            "BuiltinVectorFullscreenPass requires exactly one "
+            "valid destination color attachment");
         return false;
     }
 
     if (m_shaderPath.Empty()) {
         Debug::Logger::Get().Error(
             Debug::LogCategory::Rendering,
-            "BuiltinVectorFullscreenPass requires a shader path before resource creation");
+            "BuiltinVectorFullscreenPass requires a shader path "
+            "before resource creation");
         return false;
     }
 
-    m_shader = Resources::ResourceManager::Get().Load<Resources::Shader>(m_shaderPath);
+    m_shader =
+        Resources::ResourceManager::Get().Load<Resources::Shader>(
+            m_shaderPath);
     if (!m_shader.IsValid()) {
         Debug::Logger::Get().Error(
             Debug::LogCategory::Rendering,
-            "BuiltinVectorFullscreenPass failed to load configured fullscreen shader resource");
+            "BuiltinVectorFullscreenPass failed to load "
+            "configured fullscreen shader resource");
         DestroyResources();
         return false;
     }
 
-    const Resources::ShaderBackend backend = ::XCEngine::Rendering::Internal::ToShaderBackend(renderContext.backendType);
+    const Resources::ShaderBackend backend =
+        ::XCEngine::Rendering::Internal::ToShaderBackend(
+            renderContext.backendType);
     const Resources::ShaderPass* selectedPass =
-        FindCompatiblePass(*m_shader.Get(), backend, m_preferredPassName);
+        FindCompatiblePass(
+            *m_shader.Get(),
+            backend,
+            m_preferredPassName);
     if (selectedPass == nullptr) {
         Debug::Logger::Get().Error(
             Debug::LogCategory::Rendering,
             m_preferredPassName.Empty()
-                ? "BuiltinVectorFullscreenPass could not resolve a compatible fullscreen shader pass"
-                : "BuiltinVectorFullscreenPass could not resolve the configured fullscreen shader pass");
+                ? "BuiltinVectorFullscreenPass could not resolve "
+                  "a compatible fullscreen shader pass"
+                : "BuiltinVectorFullscreenPass could not resolve "
+                  "the configured fullscreen shader pass");
+        DestroyResources();
+        return false;
+    }
+
+    BuiltinPassResourceBindingPlan bindingPlan = {};
+    Containers::String bindingPlanError;
+    if (!TryBuildBuiltinPassResourceBindingPlan(
+            *selectedPass,
+            bindingPlan,
+            &bindingPlanError)) {
+        Debug::Logger::Get().Error(
+            Debug::LogCategory::Rendering,
+            (Containers::String(
+                 "BuiltinVectorFullscreenPass failed to "
+                 "resolve shader resource bindings: ") +
+             bindingPlanError)
+                .CStr());
+        DestroyResources();
+        return false;
+    }
+
+    if (!IsSupportedFullscreenBindingPlan(bindingPlan)) {
+        Debug::Logger::Get().Error(
+            Debug::LogCategory::Rendering,
+            "BuiltinVectorFullscreenPass only supports "
+            "PassConstants, SourceColorTexture, "
+            "MaterialTexture, and LinearClampSampler "
+            "resource semantics");
+        DestroyResources();
+        return false;
+    }
+
+    std::vector<BuiltinPassSetLayoutMetadata> setLayouts;
+    Containers::String setLayoutError;
+    if (!TryBuildBuiltinPassSetLayouts(
+            bindingPlan,
+            setLayouts,
+            &setLayoutError)) {
+        Debug::Logger::Get().Error(
+            Debug::LogCategory::Rendering,
+            (Containers::String(
+                 "BuiltinVectorFullscreenPass failed to build "
+                 "descriptor set layouts: ") +
+             setLayoutError)
+                .CStr());
         DestroyResources();
         return false;
     }
@@ -369,62 +576,64 @@ bool BuiltinVectorFullscreenPass::CreateResources(
     m_device = renderContext.device;
     m_backendType = renderContext.backendType;
     m_renderTargetFormat = renderTargetFormat;
-    m_renderTargetSampleCount = ::XCEngine::Rendering::Internal::ResolveSurfaceSampleCount(surface);
-    m_renderTargetSampleQuality = ::XCEngine::Rendering::Internal::ResolveSurfaceSampleQuality(surface);
+    m_renderTargetSampleCount =
+        ::XCEngine::Rendering::Internal::ResolveSurfaceSampleCount(
+            surface);
+    m_renderTargetSampleQuality =
+        ::XCEngine::Rendering::Internal::
+            ResolveSurfaceSampleQuality(surface);
 
-    RHI::DescriptorSetLayoutBinding constantBinding = {};
-    constantBinding.binding = 0;
-    constantBinding.type = static_cast<uint32_t>(RHI::DescriptorType::CBV);
-    constantBinding.count = 1;
-    constantBinding.visibility = static_cast<uint32_t>(RHI::ShaderVisibility::All);
+    m_passLayout.setLayouts = std::move(setLayouts);
+    m_passLayout.descriptorSets.resize(
+        m_passLayout.setLayouts.size());
+    m_passLayout.boundSetStates.resize(
+        m_passLayout.setLayouts.size());
+    m_passLayout.passConstants = bindingPlan.passConstants;
+    m_passLayout.sourceColorTexture =
+        bindingPlan.sourceColorTexture;
+    m_passLayout.linearClampSampler =
+        bindingPlan.linearClampSampler;
+    m_passLayout.firstDescriptorSet =
+        bindingPlan.firstDescriptorSet;
+    m_passLayout.descriptorSetCount =
+        bindingPlan.descriptorSetCount;
 
-    RHI::DescriptorSetLayoutBinding textureBinding = {};
-    textureBinding.binding = 0;
-    textureBinding.type = static_cast<uint32_t>(RHI::DescriptorType::SRV);
-    textureBinding.count = 1;
-    textureBinding.visibility = static_cast<uint32_t>(RHI::ShaderVisibility::All);
-
-    RHI::DescriptorSetLayoutBinding samplerBinding = {};
-    samplerBinding.binding = 0;
-    samplerBinding.type = static_cast<uint32_t>(RHI::DescriptorType::Sampler);
-    samplerBinding.count = 1;
-    samplerBinding.visibility = static_cast<uint32_t>(RHI::ShaderVisibility::All);
-
-    RHI::DescriptorSetLayoutDesc constantLayout = {};
-    constantLayout.bindings = &constantBinding;
-    constantLayout.bindingCount = 1;
-
-    RHI::DescriptorSetLayoutDesc textureLayout = {};
-    textureLayout.bindings = &textureBinding;
-    textureLayout.bindingCount = 1;
-
-    RHI::DescriptorSetLayoutDesc samplerLayout = {};
-    samplerLayout.bindings = &samplerBinding;
-    samplerLayout.bindingCount = 1;
-
-    RHI::DescriptorSetLayoutDesc setLayouts[] = {
-        constantLayout,
-        textureLayout,
-        samplerLayout
-    };
+    std::vector<RHI::DescriptorSetLayoutDesc> nativeSetLayouts(
+        m_passLayout.setLayouts.size());
+    for (size_t setIndex = 0u;
+         setIndex < m_passLayout.setLayouts.size();
+         ++setIndex) {
+        nativeSetLayouts[setIndex] =
+            m_passLayout.setLayouts[setIndex].layout;
+    }
 
     RHI::RHIPipelineLayoutDesc pipelineLayoutDesc = {};
-    pipelineLayoutDesc.setLayouts = setLayouts;
-    pipelineLayoutDesc.setLayoutCount = 3;
-    m_pipelineLayout = m_device->CreatePipelineLayout(pipelineLayoutDesc);
-    if (m_pipelineLayout == nullptr) {
+    pipelineLayoutDesc.setLayouts =
+        nativeSetLayouts.empty()
+            ? nullptr
+            : nativeSetLayouts.data();
+    pipelineLayoutDesc.setLayoutCount =
+        static_cast<uint32_t>(nativeSetLayouts.size());
+    m_passLayout.pipelineLayout =
+        m_device->CreatePipelineLayout(pipelineLayoutDesc);
+    if (m_passLayout.pipelineLayout == nullptr) {
         DestroyResources();
         return false;
     }
 
     RHI::SamplerDesc samplerDesc = {};
-    samplerDesc.filter = static_cast<uint32_t>(RHI::FilterMode::Linear);
-    samplerDesc.addressU = static_cast<uint32_t>(RHI::TextureAddressMode::Clamp);
-    samplerDesc.addressV = static_cast<uint32_t>(RHI::TextureAddressMode::Clamp);
-    samplerDesc.addressW = static_cast<uint32_t>(RHI::TextureAddressMode::Clamp);
+    samplerDesc.filter =
+        static_cast<uint32_t>(RHI::FilterMode::Linear);
+    samplerDesc.addressU = static_cast<uint32_t>(
+        RHI::TextureAddressMode::Clamp);
+    samplerDesc.addressV = static_cast<uint32_t>(
+        RHI::TextureAddressMode::Clamp);
+    samplerDesc.addressW = static_cast<uint32_t>(
+        RHI::TextureAddressMode::Clamp);
     samplerDesc.mipLodBias = 0.0f;
     samplerDesc.maxAnisotropy = 1;
-    samplerDesc.comparisonFunc = static_cast<uint32_t>(RHI::ComparisonFunc::Always);
+    samplerDesc.comparisonFunc = static_cast<uint32_t>(
+        RHI::ComparisonFunc::Always);
     samplerDesc.minLod = 0.0f;
     samplerDesc.maxLod = 1000.0f;
     m_sampler = m_device->CreateSampler(samplerDesc);
@@ -433,58 +642,47 @@ bool BuiltinVectorFullscreenPass::CreateResources(
         return false;
     }
 
-    auto createOwnedDescriptorSet =
-        [this](const RHI::DescriptorSetLayoutDesc& layout,
-               RHI::DescriptorHeapType heapType,
-               bool shaderVisible,
-               OwnedDescriptorSet& ownedSet) -> bool {
-            RHI::DescriptorPoolDesc poolDesc = {};
-            poolDesc.type = heapType;
-            poolDesc.descriptorCount = 1;
-            poolDesc.shaderVisible = shaderVisible;
-            ownedSet.pool = m_device->CreateDescriptorPool(poolDesc);
-            if (ownedSet.pool == nullptr) {
+    for (size_t setIndex = 0u;
+         setIndex < m_passLayout.setLayouts.size();
+         ++setIndex) {
+        const BuiltinPassSetLayoutMetadata& setLayout =
+            m_passLayout.setLayouts[setIndex];
+        if (setLayout.bindings.empty()) {
+            continue;
+        }
+
+        if (!CreateOwnedDescriptorSet(
+                setLayout,
+                m_passLayout.descriptorSets[setIndex])) {
+            DestroyResources();
+            return false;
+        }
+
+        if (setLayout.usesSampler) {
+            if (!setLayout.usesLinearClampSampler ||
+                !m_passLayout.linearClampSampler.IsValid() ||
+                m_passLayout.linearClampSampler.set !=
+                    setIndex) {
+                DestroyResources();
                 return false;
             }
 
-            ownedSet.set = ownedSet.pool->AllocateSet(layout);
-            if (ownedSet.set == nullptr) {
-                DestroyOwnedDescriptorSet(ownedSet);
-                return false;
-            }
-
-            return true;
-        };
-
-    if (!createOwnedDescriptorSet(
-            constantLayout,
-            RHI::DescriptorHeapType::CBV_SRV_UAV,
-            false,
-            m_constantsSet) ||
-        !createOwnedDescriptorSet(
-            textureLayout,
-            RHI::DescriptorHeapType::CBV_SRV_UAV,
-            true,
-            m_textureSet) ||
-        !createOwnedDescriptorSet(
-            samplerLayout,
-            RHI::DescriptorHeapType::Sampler,
-            true,
-            m_samplerSet)) {
-        DestroyResources();
-        return false;
+            m_passLayout.descriptorSets[setIndex]
+                .set->UpdateSampler(
+                    m_passLayout.linearClampSampler.binding,
+                    m_sampler);
+        }
     }
 
-    m_samplerSet.set->UpdateSampler(0, m_sampler);
-
     m_pipelineState = m_device->CreatePipelineState(
         CreatePipelineDesc(
             m_backendType,
-            m_pipelineLayout,
+            m_passLayout.pipelineLayout,
             *m_shader.Get(),
             selectedPass->name,
             surface));
-    if (m_pipelineState == nullptr || !m_pipelineState->IsValid()) {
+    if (m_pipelineState == nullptr ||
+        !m_pipelineState->IsValid()) {
         DestroyResources();
         return false;
     }
@@ -492,24 +690,149 @@ bool BuiltinVectorFullscreenPass::CreateResources(
     return true;
 }
 
-void BuiltinVectorFullscreenPass::DestroyResources() {
-    m_boundSourceColorView = nullptr;
+bool BuiltinVectorFullscreenPass::CreateOwnedDescriptorSet(
+    const BuiltinPassSetLayoutMetadata& setLayout,
+    OwnedDescriptorSet& descriptorSet) {
+    RHI::DescriptorPoolDesc poolDesc = {};
+    poolDesc.type = setLayout.heapType;
+    poolDesc.descriptorCount =
+        CountBuiltinPassHeapDescriptors(
+            setLayout.heapType,
+            setLayout.bindings);
+    poolDesc.shaderVisible = setLayout.shaderVisible;
 
+    descriptorSet.pool =
+        m_device->CreateDescriptorPool(poolDesc);
+    if (descriptorSet.pool == nullptr) {
+        return false;
+    }
+
+    descriptorSet.set =
+        descriptorSet.pool->AllocateSet(setLayout.layout);
+    if (descriptorSet.set == nullptr) {
+        DestroyOwnedDescriptorSet(descriptorSet);
+        return false;
+    }
+
+    return true;
+}
+
+bool BuiltinVectorFullscreenPass::UpdateDescriptorSets(
+    const RenderPassContext& context) {
+    for (size_t setIndex = 0u;
+         setIndex < m_passLayout.setLayouts.size();
+         ++setIndex) {
+        const BuiltinPassSetLayoutMetadata& setLayout =
+            m_passLayout.setLayouts[setIndex];
+        if (setLayout.bindings.empty()) {
+            continue;
+        }
+
+        OwnedDescriptorSet& descriptorSet =
+            m_passLayout.descriptorSets[setIndex];
+        BoundSetState& boundSetState =
+            m_passLayout.boundSetStates[setIndex];
+        if (descriptorSet.set == nullptr) {
+            return false;
+        }
+
+        if (setLayout.usesPassConstants) {
+            if (!m_passLayout.passConstants.IsValid() ||
+                m_passLayout.passConstants.set != setIndex) {
+                return false;
+            }
+
+            const PostProcessConstants constants = {
+                m_vectorPayload
+            };
+            descriptorSet.set->WriteConstant(
+                m_passLayout.passConstants.binding,
+                &constants,
+                sizeof(constants));
+        }
+
+        if (setLayout.usesSourceColorTexture) {
+            if (context.sourceColorView == nullptr ||
+                !m_passLayout.sourceColorTexture.IsValid() ||
+                m_passLayout.sourceColorTexture.set !=
+                    setIndex) {
+                return false;
+            }
+
+            if (boundSetState.sourceColorTextureView !=
+                context.sourceColorView) {
+                descriptorSet.set->Update(
+                    m_passLayout.sourceColorTexture.binding,
+                    context.sourceColorView);
+                boundSetState.sourceColorTextureView =
+                    context.sourceColorView;
+            }
+        }
+
+        if (setLayout.usesMaterialTextures) {
+            if (boundSetState.materialTextureViews.size() !=
+                setLayout.materialTextureBindings.size()) {
+                boundSetState.materialTextureViews.assign(
+                    setLayout.materialTextureBindings.size(),
+                    nullptr);
+            }
+
+            for (size_t bindingIndex = 0u;
+                 bindingIndex <
+                 setLayout.materialTextureBindings.size();
+                 ++bindingIndex) {
+                const BuiltinPassResourceBindingDesc&
+                    textureBinding =
+                        setLayout.materialTextureBindings
+                            [bindingIndex];
+                RHI::RHIResourceView* resolvedTextureView =
+                    ResolveExtraTextureView(
+                        context,
+                        textureBinding);
+                if (resolvedTextureView == nullptr) {
+                    return false;
+                }
+
+                if (boundSetState.materialTextureViews
+                        [bindingIndex] !=
+                    resolvedTextureView) {
+                    descriptorSet.set->Update(
+                        textureBinding.location.binding,
+                        resolvedTextureView);
+                    boundSetState.materialTextureViews
+                        [bindingIndex] = resolvedTextureView;
+                }
+            }
+        } else if (!boundSetState.materialTextureViews
+                        .empty()) {
+            boundSetState.materialTextureViews.clear();
+        }
+    }
+
+    return true;
+}
+
+RHI::RHIResourceView*
+BuiltinVectorFullscreenPass::ResolveExtraTextureView(
+    const RenderPassContext& context,
+    const BuiltinPassResourceBindingDesc& bindingDesc) const {
+    const RenderPassContext::TextureBindingView* bindingView =
+        FindTextureBindingView(
+            context,
+            bindingDesc);
+    return bindingView != nullptr
+        ? bindingView->resourceView
+        : nullptr;
+}
+
+void BuiltinVectorFullscreenPass::DestroyResources() {
     if (m_pipelineState != nullptr) {
         m_pipelineState->Shutdown();
         delete m_pipelineState;
         m_pipelineState = nullptr;
     }
 
-    DestroyOwnedDescriptorSet(m_samplerSet);
-    DestroyOwnedDescriptorSet(m_textureSet);
-    DestroyOwnedDescriptorSet(m_constantsSet);
-
-    if (m_pipelineLayout != nullptr) {
-        m_pipelineLayout->Shutdown();
-        delete m_pipelineLayout;
-        m_pipelineLayout = nullptr;
-    }
+    DestroyPassResourceLayout();
 
     if (m_sampler != nullptr) {
         m_sampler->Shutdown();
@@ -525,7 +848,30 @@ void BuiltinVectorFullscreenPass::DestroyResources() {
     m_renderTargetSampleQuality = 0u;
 }
 
-void BuiltinVectorFullscreenPass::DestroyOwnedDescriptorSet(OwnedDescriptorSet& descriptorSet) {
+void BuiltinVectorFullscreenPass::DestroyPassResourceLayout() {
+    for (OwnedDescriptorSet& descriptorSet :
+         m_passLayout.descriptorSets) {
+        DestroyOwnedDescriptorSet(descriptorSet);
+    }
+    m_passLayout.descriptorSets.clear();
+    m_passLayout.boundSetStates.clear();
+    m_passLayout.setLayouts.clear();
+
+    if (m_passLayout.pipelineLayout != nullptr) {
+        m_passLayout.pipelineLayout->Shutdown();
+        delete m_passLayout.pipelineLayout;
+        m_passLayout.pipelineLayout = nullptr;
+    }
+
+    m_passLayout.passConstants = {};
+    m_passLayout.sourceColorTexture = {};
+    m_passLayout.linearClampSampler = {};
+    m_passLayout.firstDescriptorSet = 0u;
+    m_passLayout.descriptorSetCount = 0u;
+}
+
+void BuiltinVectorFullscreenPass::DestroyOwnedDescriptorSet(
+    OwnedDescriptorSet& descriptorSet) {
     if (descriptorSet.set != nullptr) {
         descriptorSet.set->Shutdown();
         delete descriptorSet.set;