PSFullscreen.hpp

Go to the documentation of this file.

#pragma once
#include <RenderCore/Renderer.hpp>
namespace Foundation::RenderUtils {
    using namespace RenderCore;
    template<typename FSetup, typename FRecord>
    PassHandle createPSFullscreenPass(
        Renderer* r,
        StringView name,        
        FSetup&& setup,
        FRecord&& record
    ) {
        return r->CreatePass(name, RHIDeviceQueueType::Graphics, 0u,
            [=](PassHandle self, Renderer* r) {
                r->BindBackbufferRTV(self);
                r->BindShader(self, RHIShaderStageBits::Vertex, "vertMain", r->GetApplication()->ResolveRelativePathBase("Data/Shaders/VSFullscreen.spv"));
                setup(self, r);
            },
            [=](PassHandle self, Renderer* r, RHICommandList* cmd)
            {
                auto const& img_wh = r->GetSwapchainExtent();
                r->CmdSetPipeline(self, cmd);
                record(self, r, cmd);
                r->CmdBeginGraphics(self, cmd, img_wh, {{RHIColorAttachmentLoad{RHIAttachmentLoadOp::DontCare}}},
                                    {RHIAttachmentLoadOp::DontCare}); // No clear necessary
                cmd->SetViewport(0, 0, img_wh.x, img_wh.y)
                    .SetScissor(0, 0, img_wh.x, img_wh.y);
                cmd->Draw(3);
                cmd->EndGraphics();
            });        
    }
    template<typename FSetup>
    PassHandle createPSFullscreenPass(
        Renderer* r,
        StringView name,        
        FSetup&& setup)
    {
        return createPSFullscreenPass(r, name, std::forward<FSetup>(setup), FRecordDefault{});
    }
    template<typename FSetup, typename FRecord>
    PassHandle createPSFullscreenPassRTV(
        Renderer* r,
        StringView name,
        ResourceHandle rtvTexture,
        RHITextureViewDesc const& rtvViewDesc,
        RHIExtent2D extent,
        FSetup&& setup,
        FRecord&& record
    ) {
        return r->CreatePass(name, RHIDeviceQueueType::Graphics, 0u,
            [=](PassHandle self, Renderer* r) {
                r->BindTextureRTV(self, rtvTexture, rtvViewDesc);
                r->BindShader(self, RHIShaderStageBits::Vertex, "vertMain", r->GetApplication()->ResolveRelativePathBase("Data/Shaders/VSFullscreen.spv"));
                setup(self, r);
            },
            [=](PassHandle self, Renderer* r, RHICommandList* cmd)
            {
                RHIExtent2D img_wh = extent;
                if (img_wh.x == 0u || img_wh.y == 0u)
                {
                    auto const* rtv = r->DerefResource(rtvTexture).Get<RHITexture*>();
                    img_wh = {rtv->mDesc.extent.x, rtv->mDesc.extent.y};
                }
                r->CmdSetPipeline(self, cmd);
                record(self, r, cmd);
                r->CmdBeginGraphics(self, cmd, img_wh, {{RHIColorAttachmentLoad{RHIAttachmentLoadOp::DontCare}}},
                                    {RHIAttachmentLoadOp::DontCare});
                cmd->SetViewport(0, 0, img_wh.x, img_wh.y)
                    .SetScissor(0, 0, img_wh.x, img_wh.y);
                cmd->Draw(3);
                cmd->EndGraphics();
            });
    }
    template<typename FSetup>
    PassHandle createPSFullscreenPassRTV(
        Renderer* r,
        StringView name,
        ResourceHandle rtvTexture,
        RHITextureViewDesc const& rtvViewDesc,
        FSetup&& setup)
    {
        return createPSFullscreenPassRTV(r, name, rtvTexture, rtvViewDesc, RHIExtent2D{0u, 0u},
                                         std::forward<FSetup>(setup), FRecordDefault{});
    }
    inline PassHandle createPSBackbufferBlitPass(
        Renderer* r,
        StringView name,
        ResourceHandle copy_sampler,
        ResourceHandle copy_source,
        RHIResourceFormat srcFormat = RHIResourceFormat::R8G8B8A8Unorm
    ) {
        return createPSFullscreenPass(
            r,
            name,
            [=](PassHandle self, Renderer*) {
                r->BindTextureSampler(self, copy_sampler, "sampler");
                r->BindTextureSRV(self, copy_source, "srcTexture", RHIPipelineStageBits::FragmentShader, {
                    .format = srcFormat,
                    .range = RHITextureSubresourceRange::Create()
                });
                r->BindShader(self, RHIShaderStageBits::Fragment, "fragMain", r->GetApplication()->ResolveRelativePathBase("Data/Shaders/PSCopy.spv"));
            },
            [](PassHandle, Renderer*, RHICommandList*) {}
        );
    }
    // Color R32 (etc.) -> D32 depth via SV_Depth; CopyImage cannot cross aspects without maintenance8.
    inline PassHandle createPSDepthCopyPass(Renderer* r, StringView name, ResourceHandle srcDepth,
                                            ResourceHandle dstDepth, RHIExtent2D extent,
                                            RHIResourceFormat srcFormat = RHIResourceFormat::R32SignedFloat)
    {
        return r->CreatePass(
            name, RHIDeviceQueueType::Graphics, 0u,
            [=](PassHandle self, Renderer* r)
            {
                r->BindShader(self, RHIShaderStageBits::Vertex, "vertMain",
                              r->GetApplication()->ResolveRelativePathBase("Data/Shaders/VSFullscreen.spv"));
                r->BindShader(self, RHIShaderStageBits::Fragment, "fragMain",
                              r->GetApplication()->ResolveRelativePathBase("Data/Shaders/PSCopyDepth.spv"));
                r->BindTextureSRV(self, srcDepth, "srcDepth", RHIPipelineStageBits::FragmentShader,
                                  RHITextureViewDesc{.format = srcFormat,
                                                     .range = RHITextureSubresourceRange::Create(
                                                         RHITextureAspectFlagBits::Color)});
                r->BindTextureDSV(self, dstDepth,
                                  RHITextureViewDesc{.format = RHIResourceFormat::D32SignedFloat,
                                                     .range = RHITextureSubresourceRange::Create(
                                                         RHITextureAspectFlagBits::Depth)});
                r->PassSetRasterizerFlags(
                    self, {.cullMode = RHIPipelineState::PipelineStateDesc::Rasterizer::CullNone},
                    {.depthTest = true,
                     .depthWrite = true,
                     .depthCompareOp = RHIPipelineState::PipelineStateDesc::DepthStencil::Always});
            },
            [=](PassHandle self, Renderer* r, RHICommandList* cmd)
            {
                r->CmdSetPipeline(self, cmd);
                r->CmdBeginGraphics(self, cmd, extent, {}, {RHIAttachmentLoadOp::DontCare});
                cmd->SetViewport(0, 0, extent.x, extent.y).SetScissor(0, 0, extent.x, extent.y);
                cmd->Draw(3);
                cmd->EndGraphics();
            });
    }
}