Method ConvertToFilterable

Components/src/ShadowMapManager.cpp:530–594

}

void ShadowMapManager::ConvertToFilterable(IDeviceContext* pCtx, const ShadowMapAttribs& ShadowAttribs)
{
    if (m_ShadowMode == SHADOW_MODE_VSM || m_ShadowMode == SHADOW_MODE_EVSM2 || m_ShadowMode == SHADOW_MODE_EVSM4)
    {
        auto&       Tech          = m_ConversionTech[m_ShadowMode];
        const auto& ShadowMapDesc = m_pShadowMapSRV->GetTexture()->GetDesc();
        VERIFY(static_cast<int>(ShadowMapDesc.ArraySize) == ShadowAttribs.iNumCascades, "Inconsistent number of cascades");
        const auto& FilterableSMDesc = m_pFilterableShadowMapSRV->GetTexture()->GetDesc();
        VERIFY(ShadowAttribs.bIs32BitEVSM == (FilterableSMDesc.Format == TEX_FORMAT_RGBA32_FLOAT || FilterableSMDesc.Format == TEX_FORMAT_RG32_FLOAT),
               "Incorrect 32-bit VSM flag");
        (void)FilterableSMDesc;

        int  iFilterRadius = (ShadowAttribs.iFixedFilterSize - 1) / 2;
        bool bSkipBlur     = ShadowAttribs.iFixedFilterSize == 2;
        for (Uint32 i = 0; i < ShadowMapDesc.ArraySize; ++i)
        {
            ITextureView* pRTVs[] = {bSkipBlur ? m_pFilterableShadowMapRTVs[i] : m_pIntermediateRTV};
            pCtx->SetRenderTargets(1, pRTVs, nullptr, RESOURCE_STATE_TRANSITION_MODE_TRANSITION);
            {
                struct ConversionAttribs //
                {
                    int   iCascade;
                    float fHorzFilterRadius;
                    float fVertFilterRadius;
                    float fEVSMPositiveExponent;

                    float fEVSMNegativeExponent;
                    int   Is32BitEVSM;
                };
                MapHelper<ConversionAttribs> pAttribs(pCtx, m_pConversionAttribsBuffer, MAP_WRITE, MAP_FLAG_DISCARD);
                pAttribs->iCascade = i;
                if (ShadowAttribs.iFixedFilterSize > 0)
                {
                    pAttribs->fHorzFilterRadius = static_cast<float>(iFilterRadius);
                    pAttribs->fVertFilterRadius = static_cast<float>(iFilterRadius);
                }
                else
                {
                    const auto& Cascade         = ShadowAttribs.Cascades[i];
                    float       fNDCtoUVScale   = 0.5f;
                    float       fFilterWidth    = ShadowAttribs.fFilterWorldSize * Cascade.f4LightSpaceScale.x * fNDCtoUVScale;
                    float       fFilterHeight   = ShadowAttribs.fFilterWorldSize * Cascade.f4LightSpaceScale.y * fNDCtoUVScale;
                    pAttribs->fHorzFilterRadius = fFilterWidth / 2.f * static_cast<float>(ShadowMapDesc.Width);
                    pAttribs->fVertFilterRadius = fFilterHeight / 2.f * static_cast<float>(ShadowMapDesc.Height);
                }
                pAttribs->fEVSMPositiveExponent = ShadowAttribs.fEVSMPositiveExponent;
                pAttribs->fEVSMNegativeExponent = ShadowAttribs.fEVSMNegativeExponent;
                pAttribs->Is32BitEVSM           = ShadowAttribs.bIs32BitEVSM;
            }
            pCtx->SetPipelineState(Tech.PSO);
            pCtx->CommitShaderResources(Tech.SRB, RESOURCE_STATE_TRANSITION_MODE_TRANSITION);
            DrawAttribs drawAttribs{3, DRAW_FLAG_VERIFY_ALL};
            pCtx->Draw(drawAttribs);

            if (!bSkipBlur)
            {
                pRTVs[0] = m_pFilterableShadowMapRTVs[i];
                pCtx->SetRenderTargets(1, pRTVs, nullptr, RESOURCE_STATE_TRANSITION_MODE_TRANSITION);