clang-formatted Components

1 files changed, 116 insertions, 111 deletions

diff --git a/Components/src/ShadowMapManager.cpp b/Components/src/ShadowMapManager.cpp
index 3210483..57861a1 100644
--- a/Components/src/ShadowMapManager.cpp
+++ b/Components/src/ShadowMapManager.cpp
@@ -33,16 +33,15 @@ namespace Diligent
 
 ShadowMapManager::ShadowMapManager()
 {
-    
 }
 
 void ShadowMapManager::Initialize(IRenderDevice* pDevice, const InitInfo& initInfo)
 {
     VERIFY_EXPR(pDevice != nullptr);
-    VERIFY(initInfo.Format      != TEX_FORMAT_UNKNOWN, "Undefined shadow map format");
+    VERIFY(initInfo.Format != TEX_FORMAT_UNKNOWN, "Undefined shadow map format");
     VERIFY(initInfo.NumCascades != 0, "Number of cascades must not be zero");
-    VERIFY(initInfo.Resolution  != 0, "Shadow map resolution must not be zero");
-    VERIFY(initInfo.ShadowMode  != 0, "Shadow mode is not specified");
+    VERIFY(initInfo.Resolution != 0, "Shadow map resolution must not be zero");
+    VERIFY(initInfo.ShadowMode != 0, "Shadow mode is not specified");
 
     m_pDevice    = pDevice;
     m_ShadowMode = initInfo.ShadowMode;
@@ -57,17 +56,17 @@ void ShadowMapManager::Initialize(IRenderDevice* pDevice, const InitInfo& initIn
     ShadowMapDesc.Format    = initInfo.Format;
     ShadowMapDesc.BindFlags = BIND_SHADER_RESOURCE | BIND_DEPTH_STENCIL;
 
-	RefCntAutoPtr<ITexture> ptex2DShadowMap;
-	pDevice->CreateTexture(ShadowMapDesc, nullptr, &ptex2DShadowMap);
+    RefCntAutoPtr<ITexture> ptex2DShadowMap;
+    pDevice->CreateTexture(ShadowMapDesc, nullptr, &ptex2DShadowMap);
 
     m_pShadowMapSRV.Release();
-    m_pShadowMapSRV = ptex2DShadowMap->GetDefaultView( TEXTURE_VIEW_SHADER_RESOURCE );
+    m_pShadowMapSRV = ptex2DShadowMap->GetDefaultView(TEXTURE_VIEW_SHADER_RESOURCE);
     if (initInfo.pComparisonSampler != nullptr)
         m_pShadowMapSRV->SetSampler(initInfo.pComparisonSampler);
 
     m_pShadowMapDSVs.clear();
     m_pShadowMapDSVs.resize(ShadowMapDesc.ArraySize);
-    for (Uint32 iArrSlice=0; iArrSlice < ShadowMapDesc.ArraySize; iArrSlice++)
+    for (Uint32 iArrSlice = 0; iArrSlice < ShadowMapDesc.ArraySize; iArrSlice++)
     {
         TextureViewDesc ShadowMapDSVDesc;
         ShadowMapDSVDesc.Name            = "Shadow map cascade DSV";
@@ -81,24 +80,24 @@ void ShadowMapManager::Initialize(IRenderDevice* pDevice, const InitInfo& initIn
     m_pFilterableShadowMapRTVs.clear();
     m_pIntermediateSRV.Release();
     m_pIntermediateRTV.Release();
-    if (initInfo.ShadowMode == SHADOW_MODE_VSM   ||
+    if (initInfo.ShadowMode == SHADOW_MODE_VSM ||
         initInfo.ShadowMode == SHADOW_MODE_EVSM2 ||
         initInfo.ShadowMode == SHADOW_MODE_EVSM4)
     {
         ShadowMapDesc.BindFlags = BIND_SHADER_RESOURCE | BIND_RENDER_TARGET;
         if (initInfo.ShadowMode == SHADOW_MODE_VSM)
             ShadowMapDesc.Format = initInfo.Is32BitFilterableFmt ? TEX_FORMAT_RG32_FLOAT : TEX_FORMAT_RG16_UNORM;
-        else if(initInfo.ShadowMode == SHADOW_MODE_EVSM2)
+        else if (initInfo.ShadowMode == SHADOW_MODE_EVSM2)
             ShadowMapDesc.Format = initInfo.Is32BitFilterableFmt ? TEX_FORMAT_RG32_FLOAT : TEX_FORMAT_RG16_FLOAT;
         else if (initInfo.ShadowMode == SHADOW_MODE_EVSM4)
             ShadowMapDesc.Format = initInfo.Is32BitFilterableFmt ? TEX_FORMAT_RGBA32_FLOAT : TEX_FORMAT_RGBA16_FLOAT;
 
-	    RefCntAutoPtr<ITexture> ptex2DFilterableShadowMap;
-	    pDevice->CreateTexture(ShadowMapDesc, nullptr, &ptex2DFilterableShadowMap);
+        RefCntAutoPtr<ITexture> ptex2DFilterableShadowMap;
+        pDevice->CreateTexture(ShadowMapDesc, nullptr, &ptex2DFilterableShadowMap);
         m_pFilterableShadowMapSRV = ptex2DFilterableShadowMap->GetDefaultView(TEXTURE_VIEW_SHADER_RESOURCE);
 
         m_pFilterableShadowMapRTVs.resize(ShadowMapDesc.ArraySize);
-        for (Uint32 iArrSlice=0; iArrSlice < ShadowMapDesc.ArraySize; ++iArrSlice)
+        for (Uint32 iArrSlice = 0; iArrSlice < ShadowMapDesc.ArraySize; ++iArrSlice)
         {
             TextureViewDesc RTVDesc;
             RTVDesc.Name            = "Filterable shadow map cascade RTV";
@@ -107,7 +106,7 @@ void ShadowMapManager::Initialize(IRenderDevice* pDevice, const InitInfo& initIn
             RTVDesc.NumArraySlices  = 1;
             ptex2DFilterableShadowMap->CreateView(RTVDesc, &m_pFilterableShadowMapRTVs[iArrSlice]);
         }
-        
+
         ShadowMapDesc.ArraySize = 1;
         RefCntAutoPtr<ITexture> ptex2DIntermediate;
         pDevice->CreateTexture(ShadowMapDesc, nullptr, &ptex2DIntermediate);
@@ -132,9 +131,11 @@ void ShadowMapManager::DistributeCascades(const DistributeCascadeInfo& Info,
     VERIFY(m_pDevice, "Shadow map manager is not initialized");
 
     const auto& DevCaps = m_pDevice->GetDeviceCaps();
-    const auto IsGL = DevCaps.IsGLDevice();
-    const auto& SMDesc = m_pShadowMapSRV->GetTexture()->GetDesc();
+    const auto  IsGL    = DevCaps.IsGLDevice();
+    const auto& SMDesc  = m_pShadowMapSRV->GetTexture()->GetDesc();
+
     float2 f2ShadowMapSize = float2(static_cast<float>(SMDesc.Width), static_cast<float>(SMDesc.Height));
+
     ShadowAttribs.f4ShadowMapDim.x = f2ShadowMapSize.x;
     ShadowAttribs.f4ShadowMapDim.y = f2ShadowMapSize.y;
     ShadowAttribs.f4ShadowMapDim.z = 1.f / f2ShadowMapSize.x;
@@ -144,7 +145,7 @@ void ShadowMapManager::DistributeCascades(const DistributeCascadeInfo& Info,
     {
         VERIFY_EXPR(m_pFilterableShadowMapSRV);
         const auto& FilterableSMDesc = m_pFilterableShadowMapSRV->GetTexture()->GetDesc();
-        ShadowAttribs.bIs32BitEVSM = FilterableSMDesc.Format == TEX_FORMAT_RGBA32_FLOAT || FilterableSMDesc.Format == TEX_FORMAT_RG32_FLOAT;
+        ShadowAttribs.bIs32BitEVSM   = FilterableSMDesc.Format == TEX_FORMAT_RGBA32_FLOAT || FilterableSMDesc.Format == TEX_FORMAT_RG32_FLOAT;
     }
 
     float3 LightSpaceX, LightSpaceY, LightSpaceZ;
@@ -154,20 +155,19 @@ void ShadowMapManager::DistributeCascades(const DistributeCascadeInfo& Info,
 
     auto min_cmp = std::min(std::min(std::abs(Info.pLightDir->x), std::abs(Info.pLightDir->y)), std::abs(Info.pLightDir->z));
     if (min_cmp == std::abs(Info.pLightDir->x))
-        LightSpaceX =  float3(1, 0, 0);
+        LightSpaceX = float3(1, 0, 0);
     else if (min_cmp == std::abs(Info.pLightDir->y))
-        LightSpaceX =  float3(0, 1, 0);
+        LightSpaceX = float3(0, 1, 0);
     else
-        LightSpaceX =  float3(0, 0, 1);
+        LightSpaceX = float3(0, 0, 1);
 
     LightSpaceY = cross(LightSpaceZ, LightSpaceX);
     LightSpaceX = cross(LightSpaceY, LightSpaceZ);
     LightSpaceX = normalize(LightSpaceX);
     LightSpaceY = normalize(LightSpaceY);
-    
 
     float4x4 WorldToLightViewSpaceMatr =
-        float4x4::ViewFromBasis( LightSpaceX, LightSpaceY, LightSpaceZ );
+        float4x4::ViewFromBasis(LightSpaceX, LightSpaceY, LightSpaceZ);
 
     ShadowAttribs.mWorldToLightViewT = WorldToLightViewSpaceMatr.Transpose();
 
@@ -177,14 +177,14 @@ void ShadowMapManager::DistributeCascades(const DistributeCascadeInfo& Info,
 
     float fMainCamNearPlane, fMainCamFarPlane;
     Info.pCameraProj->GetNearFarClipPlanes(fMainCamNearPlane, fMainCamFarPlane, IsGL);
-    if(Info.AdjustCascadeRange)
+    if (Info.AdjustCascadeRange)
     {
         Info.AdjustCascadeRange(-1, fMainCamNearPlane, fMainCamFarPlane);
     }
 
-    for(int i=0; i < MAX_CASCADES; ++i)
+    for (int i = 0; i < MAX_CASCADES; ++i)
         ShadowAttribs.fCascadeCamSpaceZEnd[i] = +FLT_MAX;
-    
+
     int iNumCascades           = SMDesc.ArraySize;
     ShadowAttribs.iNumCascades = iNumCascades;
     ShadowAttribs.fNumCascades = static_cast<float>(iNumCascades);
@@ -192,16 +192,16 @@ void ShadowMapManager::DistributeCascades(const DistributeCascadeInfo& Info,
     m_CascadeTransforms.resize(iNumCascades);
     for (int iCascade = 0; iCascade < iNumCascades; ++iCascade)
     {
-        auto& CurrCascade = ShadowAttribs.Cascades[iCascade];
-        float fCascadeNearZ = (iCascade == 0) ? fMainCamNearPlane : ShadowAttribs.fCascadeCamSpaceZEnd[iCascade-1];
-        float& fCascadeFarZ = ShadowAttribs.fCascadeCamSpaceZEnd[iCascade];
-        if (iCascade < iNumCascades-1) 
+        auto&  CurrCascade   = ShadowAttribs.Cascades[iCascade];
+        float  fCascadeNearZ = (iCascade == 0) ? fMainCamNearPlane : ShadowAttribs.fCascadeCamSpaceZEnd[iCascade - 1];
+        float& fCascadeFarZ  = ShadowAttribs.fCascadeCamSpaceZEnd[iCascade];
+        if (iCascade < iNumCascades - 1)
         {
             float ratio = fMainCamFarPlane / fMainCamNearPlane;
-            float power = static_cast<float>(iCascade+1) / static_cast<float>(iNumCascades);
-            float logZ = fMainCamNearPlane * pow(ratio, power);
-        
-            float range = fMainCamFarPlane - fMainCamNearPlane;
+            float power = static_cast<float>(iCascade + 1) / static_cast<float>(iNumCascades);
+            float logZ  = fMainCamNearPlane * pow(ratio, power);
+
+            float range    = fMainCamFarPlane - fMainCamNearPlane;
             float uniformZ = fMainCamNearPlane + range * power;
 
             fCascadeFarZ = Info.fPartitioningFactor * (logZ - uniformZ) + uniformZ;
@@ -211,14 +211,14 @@ void ShadowMapManager::DistributeCascades(const DistributeCascadeInfo& Info,
             fCascadeFarZ = fMainCamFarPlane;
         }
 
-        if(Info.AdjustCascadeRange)
+        if (Info.AdjustCascadeRange)
         {
             Info.AdjustCascadeRange(iCascade, fCascadeNearZ, fCascadeFarZ);
         }
         VERIFY(fCascadeNearZ > 0.f, "Near plane distance can't be zero");
         CurrCascade.f4StartEndZ.x = fCascadeNearZ;
         CurrCascade.f4StartEndZ.y = fCascadeFarZ;
-        
+
         // Set reference minimums and maximums for each coordinate
         float3 f3MinXYZ = float3(+FLT_MAX, +FLT_MAX, +FLT_MAX);
         float3 f3MaxXYZ = float3(-FLT_MAX, -FLT_MAX, -FLT_MAX);
@@ -231,31 +231,32 @@ void ShadowMapManager::DistributeCascades(const DistributeCascadeInfo& Info,
             float  fMinimalSphereRadius;
             GetFrustumMinimumBoundingSphere(Info.pCameraProj->_11, Info.pCameraProj->_22, fCascadeNearZ, fCascadeFarZ, f3MinimalSphereCenter, fMinimalSphereRadius);
             auto f3CenterLightSpace = f3MinimalSphereCenter * CameraWorld * WorldToLightViewSpaceMatr;
-            f3MinXYZ = f3CenterLightSpace - float3(fMinimalSphereRadius, fMinimalSphereRadius, fMinimalSphereRadius);
-            f3MaxXYZ = f3CenterLightSpace + float3(fMinimalSphereRadius, fMinimalSphereRadius, fMinimalSphereRadius);
+            f3MinXYZ                = f3CenterLightSpace - float3(fMinimalSphereRadius, fMinimalSphereRadius, fMinimalSphereRadius);
+            f3MaxXYZ                = f3CenterLightSpace + float3(fMinimalSphereRadius, fMinimalSphereRadius, fMinimalSphereRadius);
         }
         else
         {
-            float4x4 CascadeFrustumProjMatrix =  *Info.pCameraProj;
+            float4x4 CascadeFrustumProjMatrix = *Info.pCameraProj;
             CascadeFrustumProjMatrix.SetNearFarClipPlanes(fCascadeNearZ, fCascadeFarZ, IsGL);
-            float4x4 CascadeFrustumViewProjMatr = *Info.pCameraView * CascadeFrustumProjMatrix;
+            float4x4 CascadeFrustumViewProjMatr          = *Info.pCameraView * CascadeFrustumProjMatrix;
             float4x4 CascadeFrustumProjSpaceToWorldSpace = CascadeFrustumViewProjMatr.Inverse();
             float4x4 CascadeFrustumProjSpaceToLightSpace = CascadeFrustumProjSpaceToWorldSpace * WorldToLightViewSpaceMatr;
-            for(int i=0; i < 8; ++i)
+            for (int i = 0; i < 8; ++i)
             {
-                float3 f3FrustumCornerProjSpace
-                {
-                    (i & 0x01) ? +1.f : - 1.f,
-                    (i & 0x02) ? +1.f : - 1.f,
-                    (i & 0x04) ? +1.f : (IsGL ? -1.f : 0.f)
-                };
+                float3 f3FrustumCornerProjSpace //
+                    {
+                        (i & 0x01) ? +1.f : -1.f,
+                        (i & 0x02) ? +1.f : -1.f,
+                        (i & 0x04) ? +1.f : (IsGL ? -1.f : 0.f) //
+                    };
                 float3 f3CornerLightSpace = f3FrustumCornerProjSpace * CascadeFrustumProjSpaceToLightSpace;
+
                 f3MinXYZ = std::min(f3MinXYZ, f3CornerLightSpace);
                 f3MaxXYZ = std::max(f3MaxXYZ, f3CornerLightSpace);
             }
         }
-        
-        float3 f3CascadeExtent =  f3MaxXYZ - f3MinXYZ;
+
+        float3 f3CascadeExtent = f3MaxXYZ - f3MinXYZ;
         float3 f3CascadeCenter = (f3MaxXYZ + f3MinXYZ) * 0.5f;
         if (Info.EqualizeExtents)
         {
@@ -280,7 +281,7 @@ void ShadowMapManager::DistributeCascades(const DistributeCascadeInfo& Info,
             // Make sure that cascade is big enough so that varying filter is limited by 9x9
             constexpr float MaxVaryingFilterSize   = 9;
             constexpr float MaxVaryingFilterRadius = MaxVaryingFilterSize / 2.f;
-            
+
             // First, compute non-extended cascade extent for which world-space filter size will result
             // in a 9x9 filter kernel.
 
@@ -308,14 +309,14 @@ void ShadowMapManager::DistributeCascades(const DistributeCascadeInfo& Info,
             // FilterRadius <-  MaxVaryingFilterRadius
             // Extension    <- (MaxVaryingFilterRadius + FixedMargin) * 2
 
-            constexpr float NDCtoUVScale = 0.5f;
-            float2 f2MaxExtension = 2.f * (float2(MaxVaryingFilterRadius, MaxVaryingFilterRadius) + f2FixedMargin);
-            float2 f2MinCascadeExtent = ShadowAttribs.fFilterWorldSize * (f2ShadowMapSize - f2MaxExtension) / MaxVaryingFilterRadius * NDCtoUVScale;
-            float3 f3NewExtent; 
+            constexpr float NDCtoUVScale       = 0.5f;
+            float2          f2MaxExtension     = 2.f * (float2(MaxVaryingFilterRadius, MaxVaryingFilterRadius) + f2FixedMargin);
+            float2          f2MinCascadeExtent = ShadowAttribs.fFilterWorldSize * (f2ShadowMapSize - f2MaxExtension) / MaxVaryingFilterRadius * NDCtoUVScale;
+            float3          f3NewExtent;
             f3NewExtent.x = std::max(f3CascadeExtent.x, f2MinCascadeExtent.x);
             f3NewExtent.y = std::max(f3CascadeExtent.y, f2MinCascadeExtent.y);
             // Extend Z range proportionally
-            f3NewExtent.z = f3CascadeExtent.z * std::max(f3NewExtent.x / f3CascadeExtent.x, f3NewExtent.y / f3CascadeExtent.y);
+            f3NewExtent.z   = f3CascadeExtent.z * std::max(f3NewExtent.x / f3CascadeExtent.x, f3NewExtent.y / f3CascadeExtent.y);
             f3CascadeExtent = f3NewExtent;
 
 
@@ -327,11 +328,11 @@ void ShadowMapManager::DistributeCascades(const DistributeCascadeInfo& Info,
             // FilterRadius  <- FilterMargin
             // FilterMargin   = K * (ShadowMapSize - 2 * FixedMargin - 2 * FilterMargin)
             // FilterMargin   = K * (ShadowMapSize - 2 * FixedMargin) / (1 + 2 * K)
-            float2 K = float2(ShadowAttribs.fFilterWorldSize, ShadowAttribs.fFilterWorldSize) / float2(f3CascadeExtent.x, f3CascadeExtent.y) * NDCtoUVScale;
+            float2 K       = float2(ShadowAttribs.fFilterWorldSize, ShadowAttribs.fFilterWorldSize) / float2(f3CascadeExtent.x, f3CascadeExtent.y) * NDCtoUVScale;
             f2FilterMargin = K * (f2ShadowMapSize - 2.f * f2FixedMargin) / (float2(1, 1) + 2.f * K);
         }
 
-        float2 f2Margin = f2FixedMargin + f2FilterMargin;
+        float2 f2Margin    = f2FixedMargin + f2FilterMargin;
         float2 f2Extension = f2Margin * 2.f;
 
         // We need to remap the whole extent N x N to (N-ext) x (N-ext)
@@ -348,13 +349,14 @@ void ShadowMapManager::DistributeCascades(const DistributeCascadeInfo& Info,
         {
             float fTexelXSize = f3CascadeExtent.x / f2ShadowMapSize.x;
             float fTexelYSize = f3CascadeExtent.y / f2ShadowMapSize.y;
-            f3CascadeCenter.x = std::round(f3CascadeCenter.x/fTexelXSize) * fTexelXSize;
-            f3CascadeCenter.y = std::round(f3CascadeCenter.y/fTexelYSize) * fTexelYSize;
+            f3CascadeCenter.x = std::round(f3CascadeCenter.x / fTexelXSize) * fTexelXSize;
+            f3CascadeCenter.y = std::round(f3CascadeCenter.y / fTexelYSize) * fTexelYSize;
         }
 
         // Extend cascade Z range to allow room for filtering
         float fZExtension = std::max(f2Margin.x / f2ShadowMapSize.x, f2Margin.y / f2ShadowMapSize.y) * ShadowAttribs.fReceiverPlaneDepthBiasClamp;
-        fZExtension = std::min(fZExtension, 0.25f);
+        fZExtension       = std::min(fZExtension, 0.25f);
+
         CurrCascade.f4MarginProjSpace.z = fZExtension * (IsGL ? 2.f : 1.f);
         CurrCascade.f4MarginProjSpace.w = fZExtension * (IsGL ? 2.f : 1.f);
         f3CascadeExtent.z *= 1.f / (1.f - fZExtension * 2.f);
@@ -363,31 +365,31 @@ void ShadowMapManager::DistributeCascades(const DistributeCascadeInfo& Info,
         f3MinXYZ = f3CascadeCenter - f3CascadeExtent / 2.f;
         f3MaxXYZ = f3CascadeCenter + f3CascadeExtent / 2.f;
 
-        CurrCascade.f4LightSpaceScale.x =  2.f / f3CascadeExtent.x;
-        CurrCascade.f4LightSpaceScale.y =  2.f / f3CascadeExtent.y;
-        CurrCascade.f4LightSpaceScale.z =  (IsGL ? 2.f : 1.f) / f3CascadeExtent.z;
+        CurrCascade.f4LightSpaceScale.x = 2.f / f3CascadeExtent.x;
+        CurrCascade.f4LightSpaceScale.y = 2.f / f3CascadeExtent.y;
+        CurrCascade.f4LightSpaceScale.z = (IsGL ? 2.f : 1.f) / f3CascadeExtent.z;
         // Apply bias to shift the extent to [-1,1]x[-1,1]x[0,1] for DX or to [-1,1]x[-1,1]x[-1,1] for GL
         // Find bias such that f3MinXYZ -> (-1,-1,0) for DX or (-1,-1,-1) for GL
         CurrCascade.f4LightSpaceScaledBias.x = -f3MinXYZ.x * CurrCascade.f4LightSpaceScale.x - 1.f;
         CurrCascade.f4LightSpaceScaledBias.y = -f3MinXYZ.y * CurrCascade.f4LightSpaceScale.y - 1.f;
         CurrCascade.f4LightSpaceScaledBias.z = -f3MinXYZ.z * CurrCascade.f4LightSpaceScale.z + (IsGL ? -1.f : 0.f);
 
-        float4x4 ScaleMatrix = float4x4::Scale(CurrCascade.f4LightSpaceScale.x, CurrCascade.f4LightSpaceScale.y, CurrCascade.f4LightSpaceScale.z);
-        float4x4 ScaledBiasMatrix = float4x4::Translation( CurrCascade.f4LightSpaceScaledBias.x, CurrCascade.f4LightSpaceScaledBias.y, CurrCascade.f4LightSpaceScaledBias.z ) ;
+        float4x4 ScaleMatrix      = float4x4::Scale(CurrCascade.f4LightSpaceScale.x, CurrCascade.f4LightSpaceScale.y, CurrCascade.f4LightSpaceScale.z);
+        float4x4 ScaledBiasMatrix = float4x4::Translation(CurrCascade.f4LightSpaceScaledBias.x, CurrCascade.f4LightSpaceScaledBias.y, CurrCascade.f4LightSpaceScaledBias.z);
 
         // Note: bias is applied after scaling!
         float4x4& CascadeProjMatr = m_CascadeTransforms[iCascade].Proj;
-        CascadeProjMatr = ScaleMatrix * ScaledBiasMatrix;
-        
+        CascadeProjMatr           = ScaleMatrix * ScaledBiasMatrix;
+
         // Adjust the world to light space transformation matrix
         float4x4& WorldToLightProjSpaceMatr = m_CascadeTransforms[iCascade].WorldToLightProjSpace;
-        WorldToLightProjSpaceMatr = WorldToLightViewSpaceMatr * CascadeProjMatr;
+        WorldToLightProjSpaceMatr           = WorldToLightViewSpaceMatr * CascadeProjMatr;
+
+        const auto& NDCAttribs    = DevCaps.GetNDCAttribs();
+        float4x4    ProjToUVScale = float4x4::Scale(0.5f, NDCAttribs.YtoVScale, NDCAttribs.ZtoDepthScale);
+        float4x4    ProjToUVBias  = float4x4::Translation(0.5f, 0.5f, NDCAttribs.GetZtoDepthBias());
 
-        const auto& NDCAttribs = DevCaps.GetNDCAttribs();
-        float4x4 ProjToUVScale = float4x4::Scale( 0.5f, NDCAttribs.YtoVScale, NDCAttribs.ZtoDepthScale );
-        float4x4 ProjToUVBias = float4x4::Translation( 0.5f, 0.5f, NDCAttribs.GetZtoDepthBias());
-        
-        float4x4 WorldToShadowMapUVDepthMatr = WorldToLightProjSpaceMatr * ProjToUVScale * ProjToUVBias;
+        float4x4 WorldToShadowMapUVDepthMatr              = WorldToLightProjSpaceMatr * ProjToUVScale * ProjToUVBias;
         ShadowAttribs.mWorldToShadowMapUVDepthT[iCascade] = WorldToShadowMapUVDepthMatr.Transpose();
     }
 }
@@ -409,9 +411,9 @@ void ShadowMapManager::InitializeConversionTechniques(TEXTURE_FORMAT FilterableS
             continue;
         }
 
-        if (Tech.PSO) 
+        if (Tech.PSO)
         {
-            if(Tech.PSO->GetDesc().GraphicsPipeline.RTVFormats[0] != FilterableShadowMapFmt)
+            if (Tech.PSO->GetDesc().GraphicsPipeline.RTVFormats[0] != FilterableShadowMapFmt)
                 Tech = ShadowConversionTechnique();
             else
                 continue; // Already up to date
@@ -442,13 +444,13 @@ void ShadowMapManager::InitializeConversionTechniques(TEXTURE_FORMAT FilterableS
         {
             ShaderCI.EntryPoint = "VSMHorzPS";
             ShaderCI.Desc.Name  = "VSM horizontal pass PS";
-            PSODesc.Name = "VSM horizontal pass";
+            PSODesc.Name        = "VSM horizontal pass";
         }
         else if (mode == SHADOW_MODE_EVSM2)
         {
             ShaderCI.EntryPoint = "EVSMHorzPS";
             ShaderCI.Desc.Name  = "EVSM horizontal pass PS";
-            PSODesc.Name = "EVSM horizontal pass";
+            PSODesc.Name        = "EVSM horizontal pass";
         }
         else
         {
@@ -457,34 +459,36 @@ void ShadowMapManager::InitializeConversionTechniques(TEXTURE_FORMAT FilterableS
         RefCntAutoPtr<IShader> pVSMHorzPS;
         m_pDevice->CreateShader(ShaderCI, &pVSMHorzPS);
 
-        ShaderResourceVariableDesc Variables[] = 
-        {
-            {SHADER_TYPE_PIXEL, "g_tex2DShadowMap", SHADER_RESOURCE_VARIABLE_TYPE_MUTABLE}
-        };
+        ShaderResourceVariableDesc Variables[] =
+            {
+                {SHADER_TYPE_PIXEL, "g_tex2DShadowMap", SHADER_RESOURCE_VARIABLE_TYPE_MUTABLE} //
+            };
 
-        StaticSamplerDesc StaticSamplers[] = 
-        {
-            {SHADER_TYPE_PIXEL, "g_tex2DShadowMap", Sam_LinearClamp}
-        };
+        StaticSamplerDesc StaticSamplers[] =
+            {
+                {SHADER_TYPE_PIXEL, "g_tex2DShadowMap", Sam_LinearClamp} //
+            };
 
         if (m_pDevice->GetDeviceCaps().IsGLDevice())
         {
-            // Even though textures are never sampled in the shader, OpenGL requires proper 
+            // Even though textures are never sampled in the shader, OpenGL requires proper
             // sampler to be set even when texelFetch is used.
             PSODesc.ResourceLayout.StaticSamplers    = StaticSamplers;
             PSODesc.ResourceLayout.NumStaticSamplers = _countof(StaticSamplers);
         }
-        PSODesc.ResourceLayout.Variables         = Variables;
-        PSODesc.ResourceLayout.NumVariables      = _countof(Variables);
+        PSODesc.ResourceLayout.Variables    = Variables;
+        PSODesc.ResourceLayout.NumVariables = _countof(Variables);
+
         auto& GraphicsPipeline = PSODesc.GraphicsPipeline;
-        GraphicsPipeline.RasterizerDesc.FillMode              = FILL_MODE_SOLID;
-        GraphicsPipeline.RasterizerDesc.CullMode              = CULL_MODE_NONE;
-        GraphicsPipeline.DepthStencilDesc.DepthEnable         = False;
-        GraphicsPipeline.pVS                                  = pScreenSizeTriVS;
-        GraphicsPipeline.pPS                                  = pVSMHorzPS;
-        GraphicsPipeline.PrimitiveTopology                    = PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP;
-        GraphicsPipeline.NumRenderTargets                     = 1;
-        GraphicsPipeline.RTVFormats[0]                        = FilterableShadowMapFmt;
+
+        GraphicsPipeline.RasterizerDesc.FillMode      = FILL_MODE_SOLID;
+        GraphicsPipeline.RasterizerDesc.CullMode      = CULL_MODE_NONE;
+        GraphicsPipeline.DepthStencilDesc.DepthEnable = False;
+        GraphicsPipeline.pVS                          = pScreenSizeTriVS;
+        GraphicsPipeline.pPS                          = pVSMHorzPS;
+        GraphicsPipeline.PrimitiveTopology            = PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP;
+        GraphicsPipeline.NumRenderTargets             = 1;
+        GraphicsPipeline.RTVFormats[0]                = FilterableShadowMapFmt;
 
         m_pDevice->CreatePipelineState(PSODesc, &Tech.PSO);
         Tech.PSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, "cbConversionAttribs")->Set(m_pConversionAttribsBuffer);
@@ -496,7 +500,7 @@ void ShadowMapManager::InitializeConversionTechniques(TEXTURE_FORMAT FilterableS
         {
             ShaderCI.EntryPoint = "VertBlurPS";
             ShaderCI.Desc.Name  = "Vertical blur pass PS";
-            PSODesc.Name = "Vertical blur pass PSO";
+            PSODesc.Name        = "Vertical blur pass PSO";
             RefCntAutoPtr<IShader> pVertBlurPS;
             m_pDevice->CreateShader(ShaderCI, &pVertBlurPS);
             GraphicsPipeline.pPS = pVertBlurPS;
@@ -530,21 +534,22 @@ void ShadowMapManager::ConvertToFilterable(IDeviceContext* pCtx, const ShadowMap
 {
     if (m_ShadowMode == SHADOW_MODE_VSM || m_ShadowMode == SHADOW_MODE_EVSM2 || m_ShadowMode == SHADOW_MODE_EVSM4)
     {
-        auto& Tech = m_ConversionTech[m_ShadowMode];
+        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;
+               "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)
+        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
+                struct ConversionAttribs //
                 {
                     int   iCascade;
                     float fHorzFilterRadius;
@@ -552,10 +557,10 @@ void ShadowMapManager::ConvertToFilterable(IDeviceContext* pCtx, const ShadowMap
                     float fEVSMPositiveExponent;
 
                     float fEVSMNegativeExponent;
-                    int Is32BitEVSM;
+                    int   Is32BitEVSM;
                 };
-                MapHelper<ConversionAttribs> pAttribs(pCtx, m_pConversionAttribsBuffer, MAP_WRITE, MAP_FLAG_DISCARD );
-                pAttribs->iCascade      = i;
+                MapHelper<ConversionAttribs> pAttribs(pCtx, m_pConversionAttribsBuffer, MAP_WRITE, MAP_FLAG_DISCARD);
+                pAttribs->iCascade = i;
                 if (ShadowAttribs.iFixedFilterSize > 0)
                 {
                     pAttribs->fHorzFilterRadius = static_cast<float>(iFilterRadius);
@@ -563,11 +568,11 @@ void ShadowMapManager::ConvertToFilterable(IDeviceContext* pCtx, const ShadowMap
                 }
                 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);
+                    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;
@@ -591,4 +596,4 @@ void ShadowMapManager::ConvertToFilterable(IDeviceContext* pCtx, const ShadowMap
     }
 }
 
-}
+} // namespace Diligent